diff --git a/Modules/Bundles/org.mitk.gui.qt.igtnavigationtoolmanager/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp b/Modules/Bundles/org.mitk.gui.qt.igtnavigationtoolmanager/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp
index 82015c1962..093d1f1b97 100644
--- a/Modules/Bundles/org.mitk.gui.qt.igtnavigationtoolmanager/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp
+++ b/Modules/Bundles/org.mitk.gui.qt.igtnavigationtoolmanager/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp
@@ -1,72 +1,70 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$ 
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkMITKIGTNavigationToolManagerView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 
 
 
 const std::string QmitkMITKIGTNavigationToolManagerView::VIEW_ID = "org.mitk.views.mitkigtnavigationtoolmanager";
 
 QmitkMITKIGTNavigationToolManagerView::QmitkMITKIGTNavigationToolManagerView()
 : QmitkFunctionality()
 , m_Controls( 0 )
 , m_MultiWidget( NULL )
 {
 }
 
 QmitkMITKIGTNavigationToolManagerView::~QmitkMITKIGTNavigationToolManagerView()
 {
 }
 
 
 void QmitkMITKIGTNavigationToolManagerView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkMITKIGTNavigationToolManagerViewControls;
     m_Controls->setupUi( parent );
   }
   m_Controls->m_toolManagerWidget->Initialize(this->GetDataStorage());
-  m_Controls->m_toolManagerWidget->EnableSingleToolSave(false);
-
 }
 
 
 void QmitkMITKIGTNavigationToolManagerView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkMITKIGTNavigationToolManagerView::StdMultiWidgetNotAvailable()
   {
   m_MultiWidget = NULL;
   }
 
 
 
diff --git a/Modules/Bundles/org.mitk.gui.qt.igttrackingtoolbox/src/internal/QmitkMITKIGTTrackingToolboxView.cpp b/Modules/Bundles/org.mitk.gui.qt.igttrackingtoolbox/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
index 38af98605f..ccda2de739 100644
--- a/Modules/Bundles/org.mitk.gui.qt.igttrackingtoolbox/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
+++ b/Modules/Bundles/org.mitk.gui.qt.igttrackingtoolbox/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
@@ -1,441 +1,436 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkMITKIGTTrackingToolboxView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 #include <qfiledialog.h>
 
 // MITK
 #include <mitkNavigationToolStorageDeserializer.h>
 #include <mitkTrackingDeviceSourceConfigurator.h>
 #include <mitkTrackingVolumeGenerator.h>
 #include <mitkNDITrackingDevice.h>
 #include <mitkEllipsoid.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNavigationToolStorageSerializer.h>
 
 // vtk
 #include <vtkSphereSource.h>
 
 
 const std::string QmitkMITKIGTTrackingToolboxView::VIEW_ID = "org.mitk.views.mitkigttrackingtoolbox";
 
 QmitkMITKIGTTrackingToolboxView::QmitkMITKIGTTrackingToolboxView()
 : QmitkFunctionality()
 , m_Controls( 0 )
 , m_MultiWidget( NULL )
 {
   m_TrackingTimer = new QTimer(this);
   m_tracking = false;
   m_logging = false;
   m_loggedFrames = 0;
 }
 
 QmitkMITKIGTTrackingToolboxView::~QmitkMITKIGTTrackingToolboxView()
 {
 
 }
 
 
 void QmitkMITKIGTTrackingToolboxView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkMITKIGTTrackingToolboxViewControls;
     m_Controls->setupUi( parent );
 
     //create connections
     connect( m_Controls->m_LoadTools, SIGNAL(clicked()), this, SLOT(OnLoadTools()) );
     connect( m_Controls->m_StartTracking, SIGNAL(clicked()), this, SLOT(OnStartTracking()) );
     connect( m_Controls->m_StopTracking, SIGNAL(clicked()), this, SLOT(OnStopTracking()) );
     connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(UpdateTrackingTimer()));
     connect( m_Controls->m_ChooseFile, SIGNAL(clicked()), this, SLOT(OnChooseFileClicked()));
     connect( m_Controls->m_StartLogging, SIGNAL(clicked()), this, SLOT(StartLogging()));
     connect( m_Controls->m_StopLogging, SIGNAL(clicked()), this, SLOT(StopLogging()));
     connect( m_Controls->m_configurationWidget, SIGNAL(TrackingDeviceSelectionChanged()), this, SLOT(OnTrackingDeviceChanged()));
     connect( m_Controls->m_AutoDetectTools, SIGNAL(clicked()), this, SLOT(OnAutoDetectTools()));
 
     //initialize widgets
     m_Controls->m_configurationWidget->EnableAdvancedUserControl(false);
     m_Controls->m_TrackingToolsStatusWidget->SetShowPositions(true);
     m_Controls->m_TrackingToolsStatusWidget->SetTextAlignment(Qt::AlignLeft);
 
     //initialize tracking volume node
     m_TrackingVolumeNode = mitk::DataNode::New();
     m_TrackingVolumeNode->SetName("TrackingVolume");
     this->GetDataStorage()->Add(m_TrackingVolumeNode);
 
     //initialize buttons
     m_Controls->m_StopTracking->setEnabled(false);
     m_Controls->m_StopLogging->setEnabled(false);
     m_Controls->m_AutoDetectTools->setVisible(false); //only visible if tracking device is Aurora
   }
 }
 
 
 void QmitkMITKIGTTrackingToolboxView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkMITKIGTTrackingToolboxView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnLoadTools()
 {
   //read in filename
   QString filename = QFileDialog::getOpenFileName(NULL,tr("Open Toolfile"), "/", tr("All Files (*.*)")); //later perhaps: tr("Toolfile (*.tfl)"
   if (filename.isNull()) return;
 
-  //initialize tool storage
-  m_toolStorage = mitk::NavigationToolStorage::New();
-
   //read tool storage from disk
   mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
   m_toolStorage = myDeserializer->Deserialize(filename.toStdString());
   if (m_toolStorage.IsNull())
     {
     MessageBox(myDeserializer->GetErrorMessage());
     m_toolStorage = NULL;
     return;
   }
 
   //update label
   Poco::Path myPath = Poco::Path(filename.toStdString()); //use this to seperate filename from path
   QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools from " + myPath.getFileName().c_str();
   m_Controls->m_toolLabel->setText(toolLabel);
 
   //update tool preview
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStartTracking()
 {
 //check if everything is ready to start tracking
 if (this->m_toolStorage.IsNull())
   {
   MessageBox("Error: No Tools Loaded Yet!");
   return;
   }
 else if (this->m_toolStorage->GetToolCount() == 0)
   {
   MessageBox("Error: No Way To Track Without Tools!");
   return;
   }
 
 //build the IGT pipeline
 mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory = mitk::TrackingDeviceSourceConfigurator::New(this->m_toolStorage,this->m_Controls->m_configurationWidget->GetTrackingDevice());
 m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource(this->m_ToolVisualizationFilter);
 if (m_TrackingDeviceSource.IsNull())
   {
   MessageBox(myTrackingDeviceSourceFactory->GetErrorMessage());
   return;
   }
 
 //initialize tracking
 try
   {
   m_TrackingDeviceSource->Connect();
   m_TrackingDeviceSource->StartTracking();
   }
 catch (...)
   {
   MessageBox("Error while starting the tracking device!");
   return;
   }
 m_TrackingTimer->start(1000/(m_Controls->m_UpdateRate->value()));
 m_Controls->m_TrackingControlLabel->setText("Status: tracking");
 
 //connect the tool visualization widget
 for(int i=0; i<m_TrackingDeviceSource->GetNumberOfOutputs(); i++)
   {
     m_Controls->m_TrackingToolsStatusWidget->AddNavigationData(m_TrackingDeviceSource->GetOutput(i));
   }
 m_Controls->m_TrackingToolsStatusWidget->ShowStatusLabels();
 if (m_Controls->m_ShowToolQuaternions->isChecked()) {m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(true);}
 else {m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(false);}
 
 //disable loading new tools
 this->m_Controls->m_LoadTools->setEnabled(false);
 this->m_Controls->m_AutoDetectTools->setEnabled(false);
 
 //set configuration finished
 this->m_Controls->m_configurationWidget->ConfigurationFinished();
 
 //show tracking volume
 if (m_Controls->m_ShowTrackingVolume->isChecked())
   {
   mitk::TrackingVolumeGenerator::Pointer volumeGenerator = mitk::TrackingVolumeGenerator::New();
   volumeGenerator->SetTrackingDeviceType(m_TrackingDeviceSource->GetTrackingDevice()->GetType());
   volumeGenerator->Update();
 
   mitk::Surface::Pointer volumeSurface = volumeGenerator->GetOutput();
 
   m_TrackingVolumeNode->SetData(volumeSurface);
   m_TrackingVolumeNode->SetOpacity(0.25);
   mitk::Color red;
   red.SetRed(1);
   m_TrackingVolumeNode->SetColor(red);
   }
 
 m_tracking = true;
 
 //disable Buttons
 m_Controls->m_StopTracking->setEnabled(true);
 m_Controls->m_StartTracking->setEnabled(false);
 DisableOptionsButtons();
 
 this->GlobalReinit();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStopTracking()
 {
 if (!m_tracking) return;
 m_TrackingTimer->stop();
 m_TrackingDeviceSource->StopTracking();
 m_TrackingDeviceSource->Disconnect();
 this->m_Controls->m_configurationWidget->Reset();
 m_Controls->m_TrackingControlLabel->setText("Status: stopped");
 if (m_logging) StopLogging();
 this->m_Controls->m_LoadTools->setEnabled(true);
 this->m_Controls->m_AutoDetectTools->setEnabled(true);
 m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
 m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
 m_TrackingVolumeNode->SetData(NULL);
 m_tracking = false;
 
 //enable Buttons
 m_Controls->m_StopTracking->setEnabled(false);
 m_Controls->m_StartTracking->setEnabled(true);
 EnableOptionsButtons();
 
 this->GlobalReinit();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnTrackingDeviceChanged()
 {
 if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() == mitk::NDIAurora)
   {m_Controls->m_AutoDetectTools->setVisible(true);}
 else
   {m_Controls->m_AutoDetectTools->setVisible(false);}
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAutoDetectTools()
 {
 if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() == mitk::NDIAurora)
     {
     mitk::NDITrackingDevice::Pointer currentDevice = dynamic_cast<mitk::NDITrackingDevice*>(m_Controls->m_configurationWidget->GetTrackingDevice().GetPointer());
     currentDevice->OpenConnection();
     currentDevice->StartTracking();
-    mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New();
+    mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New(this->GetDataStorage());
     for (int i=0; i<currentDevice->GetToolCount(); i++)
       {
       //create a navigation tool with sphere as surface
       std::stringstream toolname;
       toolname << "AutoDetectedTool" << i;
       mitk::NavigationTool::Pointer newTool = mitk::NavigationTool::New();
       newTool->SetSerialNumber(dynamic_cast<mitk::NDIPassiveTool*>(currentDevice->GetTool(i))->GetSerialNumber());
       newTool->SetIdentifier(toolname.str());
       newTool->SetTrackingDeviceType(mitk::NDIAurora);
       mitk::DataNode::Pointer newNode = mitk::DataNode::New();
       mitk::Ellipsoid::Pointer mySphere = mitk::Ellipsoid::New();
       vtkSphereSource *vtkData = vtkSphereSource::New();
       vtkData->SetRadius(3.0f);
       vtkData->SetCenter(0.0, 0.0, 0.0);
       vtkData->Update();
       mySphere->SetVtkPolyData(vtkData->GetOutput());
       vtkData->Delete();
       newNode->SetData(mySphere);
       newNode->SetName(toolname.str());
       newTool->SetDataNode(newNode);
-      this->GetDataStorage()->Add(newNode);
-      //add tool to navigation tool storage
       autoDetectedStorage->AddTool(newTool);
       }
     //save detected tools
     m_toolStorage = autoDetectedStorage;
     //update label
     QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools (Auto Detected)";
     m_Controls->m_toolLabel->setText(toolLabel);
     //update tool preview
     m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
     m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
     currentDevice->StopTracking();
     currentDevice->CloseConnection();
 
     if (m_toolStorage->GetToolCount()>0)
       {
       //ask the user if he wants to save the detected tools
       QMessageBox msgBox;
       msgBox.setText("Found " + QString::number(m_toolStorage->GetToolCount()) + " tools!");
       msgBox.setInformativeText("Do you want to save this tools as tool storage, so you can load them again?");
       msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
       msgBox.setDefaultButton(QMessageBox::No);
       int ret = msgBox.exec();
       if (ret == 16384) //yes
         {
         //ask the user for a filename
         QString fileName = QFileDialog::getSaveFileName(NULL, tr("Save File"),"",tr("*.*"));
         mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
         if (!mySerializer->Serialize(fileName.toStdString(),m_toolStorage)) MessageBox(mySerializer->GetErrorMessage());
         return;
         }
       else if (ret == 65536) //no
         {
         return;
         }
       }
     }
 }
 
 void QmitkMITKIGTTrackingToolboxView::MessageBox(std::string s)
   {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
   }
 
 void QmitkMITKIGTTrackingToolboxView::UpdateTrackingTimer()
   {
   m_ToolVisualizationFilter->Update();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   if (m_logging)
     {
     this->m_loggingFilter->Update();
     m_loggedFrames = this->m_loggingFilter->GetRecordCounter();
     this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: "+QString::number(m_loggedFrames));
     //check if logging stopped automatically
     if((m_loggedFrames>1)&&(!m_loggingFilter->GetRecording())){StopLogging();}
     }
   m_Controls->m_TrackingToolsStatusWidget->Refresh();
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnChooseFileClicked()
   {
   QString filename = QFileDialog::getSaveFileName(NULL,tr("Choose Logging File"), "/", "*.*");
   this->m_Controls->m_LoggingFileName->setText(filename);
   }
 
 void QmitkMITKIGTTrackingToolboxView::StartLogging()
   {
   if (!m_logging)
     {
     //initialize logging filter
     m_loggingFilter = mitk::NavigationDataRecorder::New();
     m_loggingFilter->SetRecordingMode(mitk::NavigationDataRecorder::NormalFile);
     if (m_Controls->m_xmlFormat->isChecked()) m_loggingFilter->SetOutputFormat(mitk::NavigationDataRecorder::xml);
     else if (m_Controls->m_csvFormat->isChecked()) m_loggingFilter->SetOutputFormat(mitk::NavigationDataRecorder::csv);
     m_loggingFilter->SetFileName(m_Controls->m_LoggingFileName->text().toStdString().c_str());
     if (m_Controls->m_LoggingLimit->isChecked()){m_loggingFilter->SetRecordCountLimit(m_Controls->m_LoggedFramesLimit->value());}
 
     //connect filter
     for(int i=0; i<m_ToolVisualizationFilter->GetNumberOfOutputs(); i++){m_loggingFilter->AddNavigationData(m_ToolVisualizationFilter->GetOutput(i));}
 
     //start filter
     m_loggingFilter->StartRecording();
 
     //update labels / logging variables
     this->m_Controls->m_LoggingLabel->setText("Logging ON");
     this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: 0");
     m_loggedFrames = 0;
     m_logging = true;
     DisableLoggingButtons();
     }
   }
 
 void QmitkMITKIGTTrackingToolboxView::StopLogging()
   {
   if (m_logging)
     {
     //update label
     this->m_Controls->m_LoggingLabel->setText("Logging OFF");
 
     m_loggingFilter->StopRecording();
     m_logging = false;
     EnableLoggingButtons();
     }
   }
 
 void QmitkMITKIGTTrackingToolboxView::GlobalReinit()
 {
 // get all nodes that have not set "includeInBoundingBox" to false
   mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
 
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
   // calculate bounding geometry of these nodes
   mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
   // initialize the views to the bounding geometry
   mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableLoggingButtons()
 {
     m_Controls->m_StartLogging->setEnabled(false);
     m_Controls->m_LoggingFileName->setEnabled(false);
     m_Controls->m_ChooseFile->setEnabled(false);
     m_Controls->m_LoggingLimit->setEnabled(false);
     m_Controls->m_LoggedFramesLimit->setEnabled(false);
     m_Controls->m_csvFormat->setEnabled(false);
     m_Controls->m_xmlFormat->setEnabled(false);
     m_Controls->m_StopLogging->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableLoggingButtons()
 {
     m_Controls->m_StartLogging->setEnabled(true);
     m_Controls->m_LoggingFileName->setEnabled(true);
     m_Controls->m_ChooseFile->setEnabled(true);
     m_Controls->m_LoggingLimit->setEnabled(true);
     m_Controls->m_LoggedFramesLimit->setEnabled(true);
     m_Controls->m_csvFormat->setEnabled(true);
     m_Controls->m_xmlFormat->setEnabled(true);
     m_Controls->m_StopLogging->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableOptionsButtons()
 {
     m_Controls->m_ShowTrackingVolume->setEnabled(false);
     m_Controls->m_UpdateRate->setEnabled(false);
     m_Controls->m_ShowToolQuaternions->setEnabled(false);
     m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableOptionsButtons()
 {
     m_Controls->m_ShowTrackingVolume->setEnabled(true);
     m_Controls->m_UpdateRate->setEnabled(true);
     m_Controls->m_ShowToolQuaternions->setEnabled(true);
     m_Controls->m_OptionsUpdateRateLabel->setEnabled(true);
 }
 
 
diff --git a/Modules/IGT/IGTToolManagement/mitkNavigationToolReader.cpp b/Modules/IGT/IGTToolManagement/mitkNavigationToolReader.cpp
index 08f16eede0..3b9a733fc2 100644
--- a/Modules/IGT/IGTToolManagement/mitkNavigationToolReader.cpp
+++ b/Modules/IGT/IGTToolManagement/mitkNavigationToolReader.cpp
@@ -1,128 +1,127 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 //Poco headers
 #include "Poco/Zip/Decompress.h"
 #include "Poco/Path.h"
 
 //mitk headers
 #include "mitkNavigationToolReader.h"
 #include "mitkTrackingTypes.h"
 #include <mitkStandardFileLocations.h>
 #include <mitkSceneIO.h>
 
 
 
-mitk::NavigationToolReader::NavigationToolReader(mitk::DataStorage::Pointer dataStorage)
+mitk::NavigationToolReader::NavigationToolReader()
   {
-  m_DataStorage = dataStorage;
+
   }
 
 mitk::NavigationToolReader::~NavigationToolReader()
   {
 
   }
 
 mitk::NavigationTool::Pointer mitk::NavigationToolReader::DoRead(std::string filename)
   {
   //decompress all files into a temporary directory
   std::ifstream file( filename.c_str(), std::ios::binary );
   if (!file.good())
     {
     m_ErrorMessage = "Cannot open '" + filename + "' for reading";
     return NULL;
     }
 
   std::string tempDirectory = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory() + Poco::Path::separator() + "toolFilesByNavigationToolReader" + Poco::Path::separator() + GetFileWithoutPath(filename);
   Poco::Zip::Decompress unzipper( file, Poco::Path( tempDirectory ) );
   unzipper.decompressAllFiles();
   
   //use SceneSerialization to load the DataStorage
   mitk::SceneIO::Pointer mySceneIO = mitk::SceneIO::New();
   mitk::DataStorage::Pointer loadedStorage = mySceneIO->LoadScene(tempDirectory + Poco::Path::separator() + GetFileWithoutPath(filename) + ".storage");
 
   if (loadedStorage->GetAll()->size()==0 || loadedStorage.IsNull())
     {
     m_ErrorMessage = "Invalid file: cannot parse tool data.";
     return NULL;
     }
   
   //convert the DataStorage back to a NavigationTool-Object
   mitk::DataNode::Pointer myNode = loadedStorage->GetAll()->ElementAt(0);
   mitk::NavigationTool::Pointer returnValue = ConvertDataNodeToNavigationTool(myNode, tempDirectory);
   
   //delete the data-storage file which is not needed any more. The toolfile must be left in the temporary directory becauses it is linked in the datatreenode of the tool
   std::remove((std::string(tempDirectory + Poco::Path::separator() + GetFileWithoutPath(filename) + ".storage")).c_str());
 
   return returnValue;
   }
 
 mitk::NavigationTool::Pointer mitk::NavigationToolReader::ConvertDataNodeToNavigationTool(mitk::DataNode::Pointer node, std::string toolPath)
   {
   mitk::NavigationTool::Pointer returnValue = mitk::NavigationTool::New();
   
   //DateTreeNode with Name and Surface
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetName(node->GetName());
   newNode->SetData(node->GetData());
-  m_DataStorage->Add(newNode);
   returnValue->SetDataNode(newNode);
 
   //Identifier
   std::string identifier;
   node->GetStringProperty("identifier",identifier);
   returnValue->SetIdentifier(identifier);
   
   //Serial Number
   std::string serial;
   node->GetStringProperty("serial number",serial);
   returnValue->SetSerialNumber(serial);
 
   //Tracking Device
   int device_type;
   node->GetIntProperty("tracking device type",device_type);
   returnValue->SetTrackingDeviceType(static_cast<mitk::TrackingDeviceType>(device_type));
 
   //Tool Type
   int type;
   node->GetIntProperty("tracking tool type",type);
   returnValue->SetType(static_cast<mitk::NavigationTool::NavigationToolType>(type));
 
   //Calibration File Name
   std::string calibration_filename;
   node->GetStringProperty("toolfileName",calibration_filename);
   if (calibration_filename=="none")
     {
     returnValue->SetCalibrationFile("none");
     }
   else
     {
     std::string calibration_filename_with_path = toolPath + Poco::Path::separator() + calibration_filename;
     returnValue->SetCalibrationFile(calibration_filename_with_path);
     }
   
   return returnValue;
   }
 
 std::string mitk::NavigationToolReader::GetFileWithoutPath(std::string FileWithPath)
   {
   std::string returnValue = "";
   returnValue = FileWithPath.substr(FileWithPath.rfind("/")+1, FileWithPath.length());
   //dirty hack: Windows path seperators
   if (returnValue.size() == FileWithPath.size()) returnValue = FileWithPath.substr(FileWithPath.rfind("\\")+1, FileWithPath.length());
   return returnValue;
-  }
\ No newline at end of file
+  }
diff --git a/Modules/IGT/IGTToolManagement/mitkNavigationToolReader.h b/Modules/IGT/IGTToolManagement/mitkNavigationToolReader.h
index d333401ed4..5e2f767070 100644
--- a/Modules/IGT/IGTToolManagement/mitkNavigationToolReader.h
+++ b/Modules/IGT/IGTToolManagement/mitkNavigationToolReader.h
@@ -1,72 +1,70 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-08-11 15:15:02 +0200 (Di, 11 Aug 2009) $
 Version:   $Revision $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef NAVIGATIONTOOLREADER_H_INCLUDED
 #define NAVIGATIONTOOLREADER_H_INCLUDED
 
 //itk headers
 #include <itkObjectFactory.h>
 
 //mitk headers
 #include <mitkCommon.h>
 #include "mitkNavigationTool.h"
 #include "mitkDataStorage.h"
 #include "mitkNavigationToolStorageDeserializer.h"
 #include <MitkIGTExports.h>
 
 namespace mitk {
   /**Documentation
   * \brief This class offers methods to read objects of the class NavigationTool from the
   *        harddisc. The tools have to be saved in a special format by the class NavigationToolWriter
   *        to be loadable.
   *
   * \ingroup IGT
   */  
   class MitkIGT_EXPORT NavigationToolReader : public itk::Object
   {
   friend class mitk::NavigationToolStorageDeserializer;
   public:
     mitkClassMacro(NavigationToolReader,itk::Object);
-    mitkNewMacro1Param(Self,mitk::DataStorage::Pointer);
+    itkNewMacro(Self);
 
     /**
      * @brief          This method reads a navigation tool from a file.
      * @param filename The filename where the tool is stored, "C:\temp\myTool.igtTool" for example.
      * @return         Returns a pointer to the tool which was read. Returns NULL, if something went
      *                 wrong and no tool was read. In this case you may also want the error message which is availiable
      *                 from the method GetErrorMessage().
      */
     mitk::NavigationTool::Pointer DoRead(std::string filename);
     
     itkGetMacro(ErrorMessage,std::string);
 
   protected:
-    NavigationToolReader(mitk::DataStorage::Pointer dataStorage);
+    NavigationToolReader();
     ~NavigationToolReader();
 
     std::string m_ErrorMessage;
 
-    mitk::DataStorage::Pointer m_DataStorage;
-
     mitk::NavigationTool::Pointer ConvertDataNodeToNavigationTool(mitk::DataNode::Pointer node, std::string toolPath);
 
     //################### protected help methods ########################
     std::string GetFileWithoutPath(std::string FileWithPath);
 
   };
 } // namespace mitk
-#endif //NAVIGATIONTOOLREADER
\ No newline at end of file
+#endif //NAVIGATIONTOOLREADER
diff --git a/Modules/IGT/IGTToolManagement/mitkNavigationToolStorage.cpp b/Modules/IGT/IGTToolManagement/mitkNavigationToolStorage.cpp
index 6f30e06bfe..dc1ae66d0b 100644
--- a/Modules/IGT/IGTToolManagement/mitkNavigationToolStorage.cpp
+++ b/Modules/IGT/IGTToolManagement/mitkNavigationToolStorage.cpp
@@ -1,78 +1,100 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkNavigationToolStorage.h"
 
 mitk::NavigationToolStorage::NavigationToolStorage()
   {
   m_ToolCollection = std::vector<mitk::NavigationTool::Pointer>();
+  this->m_DataStorage = NULL;
   }
 
-mitk::NavigationToolStorage::~NavigationToolStorage()
+mitk::NavigationToolStorage::NavigationToolStorage(mitk::DataStorage::Pointer ds)
   {
+  m_ToolCollection = std::vector<mitk::NavigationTool::Pointer>();
+  this->m_DataStorage = ds;
+  }
 
+
+
+mitk::NavigationToolStorage::~NavigationToolStorage()
+  {
+  if (m_DataStorage.IsNotNull()) //remove all nodes from the data storage
+    {
+    for(std::vector<mitk::NavigationTool::Pointer>::iterator it = m_ToolCollection.begin(); it != m_ToolCollection.end(); it++)
+        m_DataStorage->Remove((*it)->GetDataNode());
+    }
   }
 
 bool mitk::NavigationToolStorage::DeleteTool(int number)
   {
     if ((unsigned int)number > m_ToolCollection.size()) return false;
     std::vector<mitk::NavigationTool::Pointer>::iterator it = m_ToolCollection.begin() + number;
+    if(m_DataStorage.IsNotNull())
+      m_DataStorage->Remove((*it)->GetDataNode());
     m_ToolCollection.erase(it);
+
     return true;
   }
+
 bool mitk::NavigationToolStorage::DeleteAllTools()
   {
   while(m_ToolCollection.size() > 0) if (!DeleteTool(0)) return false;
   return true;
   }
 
 bool mitk::NavigationToolStorage::AddTool(mitk::NavigationTool::Pointer tool)
   {
   if (GetTool(tool->GetIdentifier()).IsNotNull()) return false;
   else
     {
     m_ToolCollection.push_back(tool);
+    if(m_DataStorage.IsNotNull())
+      {
+      if (!m_DataStorage->Exists(tool->GetDataNode()))
+        m_DataStorage->Add(tool->GetDataNode());
+      }
     return true;
     }
   }
 
 mitk::NavigationTool::Pointer mitk::NavigationToolStorage::GetTool(int number)
   {
   return m_ToolCollection.at(number);
   }
 
 mitk::NavigationTool::Pointer mitk::NavigationToolStorage::GetTool(std::string identifier)
   {
   for (int i=0; i<GetToolCount(); i++) if ((GetTool(i)->GetIdentifier())==identifier) return GetTool(i);
   return NULL;
   }
 
 mitk::NavigationTool::Pointer mitk::NavigationToolStorage::GetToolByName(std::string name)
   {
   for (int i=0; i<GetToolCount(); i++) if ((GetTool(i)->GetToolName())==name) return GetTool(i);
   return NULL;
   }
     
 int mitk::NavigationToolStorage::GetToolCount()
   {
   return m_ToolCollection.size();
   }
     
 bool mitk::NavigationToolStorage::isEmpty()
   {
   return m_ToolCollection.empty();
   }
diff --git a/Modules/IGT/IGTToolManagement/mitkNavigationToolStorage.h b/Modules/IGT/IGTToolManagement/mitkNavigationToolStorage.h
index 4a03bcdfc0..a2ea9c7957 100644
--- a/Modules/IGT/IGTToolManagement/mitkNavigationToolStorage.h
+++ b/Modules/IGT/IGTToolManagement/mitkNavigationToolStorage.h
@@ -1,103 +1,111 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-08-11 15:15:02 +0200 (Di, 11 Aug 2009) $
 Version:   $Revision $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef NAVIGATIONTOOLSTORAGE_H_INCLUDED
 #define NAVIGATIONTOOLSTORAGE_H_INCLUDED
 
 //itk headers
 #include <itkObjectFactory.h>
 
 //mitk headers
 #include <mitkCommon.h>
 #include <MitkIGTExports.h>
 #include "mitkNavigationTool.h"
+#include <mitkDataStorage.h>
 
 namespace mitk {
   /**Documentation
   * \brief An object of this class represents a collection of navigation tools.
   *        You may add/delete navigation tools or store/load the whole collection
   *        to/from the harddisc by using the class NavigationToolStorageSerializer
   *        and NavigationToolStorageDeserializer.
   *
   * \ingroup IGT
   */  
   class MitkIGT_EXPORT NavigationToolStorage : public itk::Object
   {
   public:
     mitkClassMacro(NavigationToolStorage,itk::Object);
+    /** @brief Constructs a NavigationToolStorage without reference to a DataStorage. The Data Nodes of tools have to be added and removed to a data storage outside this class.
+     *         Normaly the other constructor should be used.
+     */
     itkNewMacro(Self);
+    /** @brief Constructs a NavigationToolStorage with reference to a DataStorage. The Data Nodes of tools are added and removed automatically to this data storage. */
+    mitkNewMacro1Param(Self,mitk::DataStorage::Pointer);
     
     /**
      * @brief  Adds a tool to the storage. Be sure that the tool has a unique 
      *         identifier which is not already part of this storage.
      * @return Returns true if the tool was added to the storage, false if not
      *         (false can be returned if the identifier already exists in this storage
      *         for example).
      */
     bool AddTool(mitk::NavigationTool::Pointer tool);
     
     /**
      * @return Returns the tracking tool at the position "number"
      *         in the storage. Returns NULL if there is no
      *         tracking tool at this position.
      */
     mitk::NavigationTool::Pointer GetTool(int number);
     
     /**
      * @return Returns the tracking tool with the given identifier.
      *         Returns NULL if there is no
      *         tracking tool with this identifier in the storage.
      */
     mitk::NavigationTool::Pointer GetTool(std::string identifier);
 
     /**
      * @return Returns the tracking tool with the given name.
      *         Returns NULL if there is no
      *         tracking tool with this name in the storage.
      */
     mitk::NavigationTool::Pointer GetToolByName(std::string name);
     
 
     /**
      * @brief Deletes a tool from the collection.
      */
     bool DeleteTool(int number);
 
     /**
      * @brief Deletes all tools from the collection.
      */
     bool DeleteAllTools();
 
     /**
      * @return Returns the number of tools stored in the storage.
      */
     int GetToolCount();
 
     /**
      * @return Returns true if the storage is empty, false if not.
      */
     bool isEmpty();
     
   protected:
     NavigationToolStorage();
+    NavigationToolStorage(mitk::DataStorage::Pointer);
     ~NavigationToolStorage();
     
     std::vector<mitk::NavigationTool::Pointer> m_ToolCollection;
+    mitk::DataStorage::Pointer m_DataStorage;
 
   };
 } // namespace mitk
-#endif //NAVIGATIONTOOLSTORAGE
\ No newline at end of file
+#endif //NAVIGATIONTOOLSTORAGE
diff --git a/Modules/IGT/IGTToolManagement/mitkNavigationToolStorageDeserializer.cpp b/Modules/IGT/IGTToolManagement/mitkNavigationToolStorageDeserializer.cpp
index 11cb5aa1b8..b9ef7570fa 100644
--- a/Modules/IGT/IGTToolManagement/mitkNavigationToolStorageDeserializer.cpp
+++ b/Modules/IGT/IGTToolManagement/mitkNavigationToolStorageDeserializer.cpp
@@ -1,86 +1,86 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 //Poco headers
 #include "Poco/Zip/Decompress.h"
 #include "Poco/Path.h"
 #include "Poco/File.h"
 
 #include "mitkNavigationToolStorageDeserializer.h"
 #include <mitkSceneIO.h>
 #include <mitkStandardFileLocations.h>
 #include "mitkNavigationToolReader.h"
 
 mitk::NavigationToolStorageDeserializer::NavigationToolStorageDeserializer(mitk::DataStorage::Pointer dataStorage)
   {
   m_DataStorage = dataStorage;
   //create temp directory for this reader
   m_tempDirectory = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory() + Poco::Path::separator() + "tempNavigationToolDeserializer";
   Poco::File myFile(m_tempDirectory);  
   myFile.createDirectory();
   }
 
 mitk::NavigationToolStorageDeserializer::~NavigationToolStorageDeserializer()
   {
   //remove temp directory
   Poco::File myFile(m_tempDirectory);
   if (myFile.exists()) myFile.remove();
   }
 
 mitk::NavigationToolStorage::Pointer mitk::NavigationToolStorageDeserializer::Deserialize(std::string filename)
   {
   //decomress zip file into temporary directory
   decomressFiles(filename,m_tempDirectory);
   
   //now read all files and convert them to navigation tools
-  mitk::NavigationToolStorage::Pointer returnValue = mitk::NavigationToolStorage::New();
+  mitk::NavigationToolStorage::Pointer returnValue = mitk::NavigationToolStorage::New(m_DataStorage);
   bool cont = true;
   for (int i=0; cont==true; i++)
     {
     std::string fileName = m_tempDirectory + Poco::Path::separator() + "NavigationTool" + convertIntToString(i) + ".tool";
-    mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New(m_DataStorage);
+    mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New();
     mitk::NavigationTool::Pointer readTool = myReader->DoRead(fileName);
     if (readTool.IsNull()) cont = false;
     else returnValue->AddTool(readTool);
     //delete file
     std::remove(fileName.c_str());
     }
   return returnValue;
   }
 
 std::string mitk::NavigationToolStorageDeserializer::convertIntToString(int i)
   {
   std::string s;
   std::stringstream out;
   out << i;
   s = out.str();
   return s;
   }
 
 bool mitk::NavigationToolStorageDeserializer::decomressFiles(std::string filename,std::string path)
   {
   std::ifstream file( filename.c_str(), std::ios::binary );
   if (!file.good())
     {
     m_ErrorMessage = "Cannot open '" + filename + "' for reading";
     return false;
     }
   Poco::Zip::Decompress unzipper( file, Poco::Path( path ) );
   unzipper.decompressAllFiles();
   file.close();
   return true;
   }
diff --git a/Modules/IGT/Testing/mitkNavigationToolReaderAndWriterTest.cpp b/Modules/IGT/Testing/mitkNavigationToolReaderAndWriterTest.cpp
index 5e1bf0eb5f..ae7fdc947a 100644
--- a/Modules/IGT/Testing/mitkNavigationToolReaderAndWriterTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationToolReaderAndWriterTest.cpp
@@ -1,254 +1,245 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-02-25 17:27:17 +0100 (Mo, 25 Feb 2008) $
 Version:   $Revision: 7837 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 //Poco headers
 #include "Poco/Path.h"
 
 //mitk headers
 #include "mitkNavigationToolWriter.h"
 #include "mitkCommon.h"
 #include "mitkTestingMacros.h"
 #include "mitkStandardFileLocations.h"
 #include "mitkNavigationTool.h"
 #include "mitkSTLFileReader.h"
 #include "mitkBaseData.h"
 #include "mitkDataNode.h"
 #include "mitkSurface.h"
 #include "mitkStandaloneDataStorage.h"
 #include "mitkDataStorage.h"
 #include "mitkNavigationToolReader.h"
 
 #include <sstream>
 #include <fstream>
 
 
 class mitkNavigationToolReaderAndWriterTestClass
   {
   private:
     
     static mitk::Surface::Pointer testSurface;
 
   public:
 
     static void TestInstantiation()
     {
     // let's create an object of our class
     mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
     MITK_TEST_CONDITION_REQUIRED(myWriter.IsNotNull(),"Testing instantiation")
     }
 
     static void TestWrite()
     {
     //testcase with first test tool: a claron tool
 
     //create a NavigationTool which we can write on the harddisc
     std::string toolFileName = mitk::StandardFileLocations::GetInstance()->FindFile("ClaronTool", "Modules/IGT/Testing/Data");
     MITK_TEST_CONDITION(toolFileName.empty() == false, "Check if tool calibration of claron tool file exists");
     mitk::NavigationTool::Pointer myNavigationTool = mitk::NavigationTool::New();
     myNavigationTool->SetCalibrationFile(toolFileName);
 
     mitk::DataNode::Pointer myNode = mitk::DataNode::New();
     myNode->SetName("ClaronTool");
       
     //load an stl File
     mitk::STLFileReader::Pointer stlReader = mitk::STLFileReader::New();
     try
       {
       stlReader->SetFileName( mitk::StandardFileLocations::GetInstance()->FindFile("ClaronTool.stl", "Testing/Data/").c_str() );
       stlReader->Update();
       }
     catch (...)
       {
       MITK_TEST_FAILED_MSG(<<"Cannot read stl file.");
       }
 
     if ( stlReader->GetOutput() == NULL )
       {
       MITK_TEST_FAILED_MSG(<<"Cannot read stl file.");
       }
     else
       {
       testSurface = stlReader->GetOutput();
       myNode->SetData(testSurface);    
       }
     
     myNavigationTool->SetDataNode(myNode);
     myNavigationTool->SetIdentifier("ClaronTool#1");
     myNavigationTool->SetSerialNumber("0815");
     myNavigationTool->SetTrackingDeviceType(mitk::ClaronMicron);
     myNavigationTool->SetType(mitk::NavigationTool::Fiducial);
 
     //now create a writer and write it to the harddisc
     mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
     std::string filename = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestTool.tool";
     
     MITK_TEST_OUTPUT(<<"---- Testing navigation tool writer with first test tool (claron tool) ----");
     bool test = myWriter->DoWrite(filename,myNavigationTool);
     MITK_TEST_CONDITION_REQUIRED(test,"OK");
     }
 
     static void TestRead()
     {
-    mitk::DataStorage::Pointer testStorage = dynamic_cast<mitk::DataStorage*>(mitk::StandaloneDataStorage::New().GetPointer());
-    mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New(testStorage);
+    mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New();
     mitk::NavigationTool::Pointer readTool = myReader->DoRead(mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestTool.tool");
     MITK_TEST_OUTPUT(<<"---- Testing navigation tool reader with first test tool (claron tool) ----");
 
-    //Test if there was created a new tool
-    MITK_TEST_CONDITION_REQUIRED(readTool->GetDataNode() == testStorage->GetNamedNode(readTool->GetDataNode()->GetName()),"Test if tool was added to storage...");
-    
     //Test if the surfaces do have the same number of vertexes (it would be better to test for real equality of the surfaces!)
     MITK_TEST_CONDITION_REQUIRED(dynamic_cast<mitk::Surface*>(readTool->GetDataNode()->GetData())->GetSizeOfPolyDataSeries()==testSurface->GetSizeOfPolyDataSeries(),"Test if surface was restored correctly ...");
 
     MITK_TEST_CONDITION_REQUIRED(readTool->GetType()==mitk::NavigationTool::Fiducial,"Testing Tool Type");
 
     MITK_TEST_CONDITION_REQUIRED(readTool->GetTrackingDeviceType()==mitk::ClaronMicron,"Testing Tracking Device Type");
 
     MITK_TEST_CONDITION_REQUIRED(readTool->GetSerialNumber()=="0815","Testing Serial Number");
 
     std::ifstream TestFile(readTool->GetCalibrationFile().c_str());
     MITK_TEST_CONDITION_REQUIRED(TestFile,"Testing If Calibration File Exists");
  
     }
 
     static void TestWrite2()
     {
     //testcase with second test tool: an aurora tool
     //create a NavigationTool which we can write on the harddisc
     mitk::NavigationTool::Pointer myNavigationTool = mitk::NavigationTool::New();
    
     mitk::DataNode::Pointer myNode = mitk::DataNode::New();
     myNode->SetName("AuroraTool");
       
     //load an stl File
     mitk::STLFileReader::Pointer stlReader = mitk::STLFileReader::New();
     try
       {
       stlReader->SetFileName( mitk::StandardFileLocations::GetInstance()->FindFile("EMTool.stl", "Testing/Data/").c_str() );
       stlReader->Update();
       }
     catch (...)
       {
       MITK_TEST_FAILED_MSG(<<"Cannot read stl file.");
       }
 
     if ( stlReader->GetOutput() == NULL )
       {
       MITK_TEST_FAILED_MSG(<<"Cannot read stl file.");
       }
     else
       {
       testSurface = stlReader->GetOutput();
       myNode->SetData(testSurface);    
       }
     
     myNavigationTool->SetDataNode(myNode);
     myNavigationTool->SetIdentifier("AuroraTool#1");
     myNavigationTool->SetSerialNumber("0816");
     myNavigationTool->SetTrackingDeviceType(mitk::NDIAurora);
     myNavigationTool->SetType(mitk::NavigationTool::Instrument);
 
     //now create a writer and write it to the harddisc
     mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
     std::string filename = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestTool2.tool";
     
     MITK_TEST_OUTPUT(<<"---- Testing navigation tool writer with second tool (aurora tool) ----");
     bool test = myWriter->DoWrite(filename,myNavigationTool);
     MITK_TEST_CONDITION_REQUIRED(test,"OK");
     }
 
     static void TestRead2()
     {
-    mitk::DataStorage::Pointer testStorage = dynamic_cast<mitk::DataStorage*>(mitk::StandaloneDataStorage::New().GetPointer());
-    mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New(testStorage);
+    mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New();
     mitk::NavigationTool::Pointer readTool = myReader->DoRead(mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestTool2.tool");
     MITK_TEST_OUTPUT(<<"---- Testing navigation tool reader  with second tool (aurora tool) ----");
 
-    //Test if there was created a new tool
-    MITK_TEST_CONDITION_REQUIRED(readTool->GetDataNode() == testStorage->GetNamedNode(readTool->GetDataNode()->GetName()),"Test if tool was added to storage...");
-    
     //Test if the surfaces do have the same number of vertexes (it would be better to test for real equality of the surfaces!)
     MITK_TEST_CONDITION_REQUIRED(dynamic_cast<mitk::Surface*>(readTool->GetDataNode()->GetData())->GetSizeOfPolyDataSeries()==testSurface->GetSizeOfPolyDataSeries(),"Test if surface was restored correctly ...");
 
     //Test if the tool type is the same
     MITK_TEST_CONDITION_REQUIRED(readTool->GetType()==mitk::NavigationTool::Instrument,"Testing Tool Type");
 
     MITK_TEST_CONDITION_REQUIRED(readTool->GetTrackingDeviceType()==mitk::NDIAurora,"Testing Tracking Device Type");
 
     MITK_TEST_CONDITION_REQUIRED(readTool->GetSerialNumber()=="0816","Testing Serial Number");
 
     MITK_TEST_CONDITION_REQUIRED(readTool->GetCalibrationFile()=="none","Testing Calibration File");
     
     }
 
     static void CleanUp()
     {
     std::remove((mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestTool.tool").c_str());
     std::remove((mitk::StandardFileLocations::GetInstance()->GetOptionDirectory()+Poco::Path::separator()+".."+Poco::Path::separator()+"TestTool2.tool").c_str());
     }
 
     static void TestReadInvalidData()
     {
-    mitk::DataStorage::Pointer testStorage = dynamic_cast<mitk::DataStorage*>(mitk::StandaloneDataStorage::New().GetPointer());
-    mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New(testStorage);
+    mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New();
     mitk::NavigationTool::Pointer readTool = myReader->DoRead("invalidTool");
 
     MITK_TEST_CONDITION_REQUIRED(readTool.IsNull(), "Testing return value if filename is invalid");
     MITK_TEST_CONDITION_REQUIRED(myReader->GetErrorMessage() == "Cannot open 'invalidTool' for reading", "Testing error message in this case");
     }
 
     static void TestWriteInvalidData()
     {
     mitk::NavigationTool::Pointer myNavigationTool = mitk::NavigationTool::New();
     myNavigationTool->SetIdentifier("ClaronTool#1");
     myNavigationTool->SetSerialNumber("0815");
     myNavigationTool->SetTrackingDeviceType(mitk::ClaronMicron);
     myNavigationTool->SetType(mitk::NavigationTool::Fiducial);
 
     //now create a writer and write it to the harddisc
     mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
     std::string filename = "NH:/sfdsfsdsf.&%%%";
     
     MITK_TEST_OUTPUT(<<"---- Testing write invalid file ----");
     bool test = myWriter->DoWrite(filename,myNavigationTool);
     MITK_TEST_CONDITION_REQUIRED(!test,"testing write");
     MITK_TEST_CONDITION_REQUIRED(myWriter->GetErrorMessage() == "Could not open a zip file for writing: 'NH:/sfdsfsdsf.&%%%'","testing error message"); 
     }
 
   };
 
 mitk::Surface::Pointer mitkNavigationToolReaderAndWriterTestClass::testSurface = NULL;
 
 /** This function is testing the TrackingVolume class. */
 int mitkNavigationToolReaderAndWriterTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("NavigationToolWriter")
 
   mitkNavigationToolReaderAndWriterTestClass::TestInstantiation();
   mitkNavigationToolReaderAndWriterTestClass::TestWrite();
   mitkNavigationToolReaderAndWriterTestClass::TestRead();
   mitkNavigationToolReaderAndWriterTestClass::TestWrite2();
   mitkNavigationToolReaderAndWriterTestClass::TestRead2();
   mitkNavigationToolReaderAndWriterTestClass::TestReadInvalidData();
   mitkNavigationToolReaderAndWriterTestClass::TestWriteInvalidData();
   mitkNavigationToolReaderAndWriterTestClass::CleanUp();
 
 
   MITK_TEST_END()
 }
 
 
diff --git a/Modules/IGT/Testing/mitkNavigationToolStorageTest.cpp b/Modules/IGT/Testing/mitkNavigationToolStorageTest.cpp
index 6574644e07..0dab03d931 100644
--- a/Modules/IGT/Testing/mitkNavigationToolStorageTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationToolStorageTest.cpp
@@ -1,155 +1,196 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-02-25 17:27:17 +0100 (Mo, 25 Feb 2008) $
 Version:   $Revision: 7837 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkNavigationToolStorage.h"
 #include "mitkNavigationTool.h"
+#include "mitkStandaloneDataStorage.h"
 #include "mitkCommon.h"
 #include "mitkTestingMacros.h"
 
 class mitkNavigationToolStorageTestClass
   {
   public:
 
     static void TestInstantiation()
     {
     // let's create an object of our class
     mitk::NavigationToolStorage::Pointer myStorage = mitk::NavigationToolStorage::New();
-    MITK_TEST_CONDITION_REQUIRED(myStorage.IsNotNull(),"Testing instantiation")
+    MITK_TEST_CONDITION_REQUIRED(myStorage.IsNotNull(),"Testing instantiation with constructor 1.")
+
+    mitk::DataStorage::Pointer myDataStorage = mitk::StandaloneDataStorage::New();    
+    mitk::NavigationToolStorage::Pointer myStorage2 = mitk::NavigationToolStorage::New(myDataStorage);
+    MITK_TEST_CONDITION_REQUIRED(myStorage2.IsNotNull(),"Testing instantiation with constructor 2.")
+    
     }
   
     static void TestAddAndDelete()
     {
     mitk::NavigationToolStorage::Pointer myStorage = mitk::NavigationToolStorage::New();
     
     //first tool
     mitk::NavigationTool::Pointer myTool1 = mitk::NavigationTool::New();
     myTool1->SetIdentifier("001");
     MITK_TEST_CONDITION_REQUIRED(myStorage->AddTool(myTool1),"Testing: Add 1st tool.");
     MITK_TEST_CONDITION_REQUIRED(myStorage->GetToolCount()==1,"Testing: Is first tool in storage?");
     
     //second tool
     mitk::NavigationTool::Pointer myTool2 = mitk::NavigationTool::New();
     myTool2->SetIdentifier("002");
     MITK_TEST_CONDITION_REQUIRED(myStorage->AddTool(myTool2),"Testing: Add 2nd tool.");
     MITK_TEST_CONDITION_REQUIRED(myStorage->GetToolCount()==2,"Testing: Is second tool in storage?");
 
     //third tool (same identifier => not valid!)
     mitk::NavigationTool::Pointer myTool3 = mitk::NavigationTool::New();
     myTool3->SetIdentifier("002");
     MITK_TEST_CONDITION_REQUIRED(!myStorage->AddTool(myTool3),"Testing: Add 3rd tool, which is not valid.");
     MITK_TEST_CONDITION_REQUIRED(myStorage->GetToolCount()==2,"Testing: 3rd tool should NOT be in the storage!");
 
     //delete second tool
     myStorage->DeleteTool(1);
     MITK_TEST_CONDITION_REQUIRED(myStorage->GetToolCount()==1,"Testing: Delete 2nd tool.");
 
     //delete first tool 
     myStorage->DeleteTool(0);
     MITK_TEST_CONDITION_REQUIRED(myStorage->GetToolCount()==0,"Testing: Delete 1st tool.");
 
     //delete tool with wrong tool number
     MITK_TEST_CONDITION_REQUIRED(!myStorage->DeleteTool(412),"Testing: Delete non-existing tool. No error should occur!");
     }
 
     static void TestAddAndDelete100Tools()
     {
     mitk::NavigationToolStorage::Pointer myStorage = mitk::NavigationToolStorage::New();
     for(int i=0; i<100; i++)
       {
       mitk::NavigationTool::Pointer myTool = mitk::NavigationTool::New();
       std::stringstream str;
       str << i;
       myTool->SetIdentifier(str.str());
       myStorage->AddTool(myTool);
       }
     MITK_TEST_CONDITION_REQUIRED(myStorage->GetToolCount()==100,"Testing: Adding 100 tools.");
     for(int i=99; i>-1; i--)
       {
       myStorage->DeleteTool(i);
       }
     MITK_TEST_CONDITION_REQUIRED(myStorage->GetToolCount()==0,"Testing: Delete 100 tools.");
     }
 
     static void TestAddAndDelete100ToolsAtOnce()
     {
     mitk::NavigationToolStorage::Pointer myStorage = mitk::NavigationToolStorage::New();
     for(int i=0; i<100; i++)
       {
       mitk::NavigationTool::Pointer myTool = mitk::NavigationTool::New();
       std::stringstream str;
       str << i;
       myTool->SetIdentifier(str.str());
       myStorage->AddTool(myTool);
       }
     MITK_TEST_CONDITION_REQUIRED(myStorage->GetToolCount()==100,"Testing: Adding 100 tools.");
     MITK_TEST_CONDITION_REQUIRED(!myStorage->isEmpty(),"Testing: method isEmpty() with non empty storage.");
     MITK_TEST_CONDITION_REQUIRED(myStorage->DeleteAllTools(),"Testing: Delete method.");
     MITK_TEST_CONDITION_REQUIRED(myStorage->isEmpty(),"Testing: method isEmpty() with empty storage.");
      
     MITK_TEST_CONDITION_REQUIRED(myStorage->GetToolCount()==0,"Testing: Delete 100 tools at once.");
     }
 
     static void TestGetTool()
     {
     //let's create an object of our class
     mitk::NavigationToolStorage::Pointer myStorage = mitk::NavigationToolStorage::New();
     
     //let's add two different tools
     //first tool
     mitk::NavigationTool::Pointer myTool1 = mitk::NavigationTool::New();
     myTool1->SetSerialNumber("0815");
     myTool1->SetIdentifier("001");
     mitk::DataNode::Pointer toolNode = mitk::DataNode::New();
     toolNode->SetName("Tool1");
     myTool1->SetDataNode(toolNode);
     myStorage->AddTool(myTool1);
         
     //second tool
     mitk::NavigationTool::Pointer myTool2 = mitk::NavigationTool::New();
     myTool2->SetSerialNumber("0816");
     myTool2->SetIdentifier("002");
     myStorage->AddTool(myTool2);
     
     //let's try to get the first tool in different ways.
     mitk::NavigationTool::Pointer myToolGet = myStorage->GetTool(0);
     MITK_TEST_CONDITION_REQUIRED(myToolGet==myTool1,"Testing GetTool() by number.");
     myToolGet = myStorage->GetTool("001");
     MITK_TEST_CONDITION_REQUIRED(myToolGet==myTool1,"Testing GetTool() by identifier.");
     myToolGet = myStorage->GetToolByName("Tool1");
     MITK_TEST_CONDITION_REQUIRED(myToolGet==myTool1,"Testing GetTool() by name.");
 
     //let's try to get a tool which doesn't exist
     myToolGet = myStorage->GetToolByName("quatsch");
     MITK_TEST_CONDITION_REQUIRED(myToolGet.IsNull(),"Testing GetTool() with wrong name.");
     }
+
+    static void TestStorageHandling()
+    {
+    mitk::DataStorage::Pointer myDataStorage = mitk::StandaloneDataStorage::New();
+    mitk::NavigationToolStorage::Pointer myStorage = mitk::NavigationToolStorage::New(myDataStorage);
+    
+    //define first tool
+    mitk::NavigationTool::Pointer myTool1 = mitk::NavigationTool::New();
+    myTool1->SetIdentifier("001");
+    mitk::DataNode::Pointer node1 = mitk::DataNode::New();
+    node1->SetName("Tool1");
+    myTool1->SetDataNode(node1);
+
+    //define second tool
+    mitk::NavigationTool::Pointer myTool2 = mitk::NavigationTool::New();
+    myTool2->SetIdentifier("002");
+    mitk::DataNode::Pointer node2 = mitk::DataNode::New();
+    node2->SetName("Tool2");
+    myTool2->SetDataNode(node2);
+
+    //execute tests
+    MITK_TEST_CONDITION_REQUIRED(myStorage->AddTool(myTool1),"Testing: Add one tool.");
+    MITK_TEST_CONDITION_REQUIRED(myDataStorage->GetNamedNode("Tool1")==node1,"Testing: Is data node in data storage?");
+    MITK_TEST_CONDITION_REQUIRED(myStorage->DeleteAllTools(),"Deleting all tools.");
+    MITK_TEST_CONDITION_REQUIRED(myDataStorage->GetNamedNode("Tool1")==NULL,"Testing: Was data node removed from storage?");
+    MITK_TEST_CONDITION_REQUIRED(myStorage->AddTool(myTool1),"Testing: Add two tools (1).");
+    MITK_TEST_CONDITION_REQUIRED(myStorage->AddTool(myTool2),"Testing: Add two tools (2).");
+    MITK_TEST_CONDITION_REQUIRED(myDataStorage->GetNamedNode("Tool1")==node1,"Testing: Is data node in data storage (1)?");
+    MITK_TEST_CONDITION_REQUIRED(myDataStorage->GetNamedNode("Tool2")==node2,"Testing: Is data node in data storage (2)?");
+    MITK_TEST_CONDITION_REQUIRED(myStorage->DeleteTool(0),"Deleting tool 1.");
+    MITK_TEST_CONDITION_REQUIRED(myDataStorage->GetNamedNode("Tool1")==NULL,"Testing: Was data node 1 deleted?");
+    MITK_TEST_CONDITION_REQUIRED(myDataStorage->GetNamedNode("Tool2")==node2,"Testing: Is data node 2 still in data storage?");
+       
+    }
   };
 
 /** This function is testing the TrackingVolume class. */
 int mitkNavigationToolStorageTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("NavigationToolStorage")
 
   mitkNavigationToolStorageTestClass::TestInstantiation();
   mitkNavigationToolStorageTestClass::TestAddAndDelete();
   mitkNavigationToolStorageTestClass::TestAddAndDelete100Tools();
   mitkNavigationToolStorageTestClass::TestAddAndDelete100ToolsAtOnce();
   mitkNavigationToolStorageTestClass::TestGetTool();
+  mitkNavigationToolStorageTestClass::TestStorageHandling();
 
   MITK_TEST_END()
 }
 
 
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
index d2b8932e39..f6f9a54aac 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
@@ -1,362 +1,317 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-05-12 19:14:45 +0200 (Di, 12 Mai 2009) $
 Version:   $Revision: 1.12 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "QmitkNavigationToolManagementWidget.h"
 
 //mitk headers
 #include "mitkTrackingTypes.h"
 #include <mitkSTLFileReader.h>
 #include <mitkSurface.h>
 #include <mitkNavigationToolReader.h>
 #include <mitkNavigationToolWriter.h>
 #include <mitkNavigationToolStorage.h>
 #include <mitkNavigationToolStorageDeserializer.h>
 #include <mitkNavigationToolStorageSerializer.h>
 
 //qt headers
 #include <qfiledialog.h>
 #include <qmessagebox.h>
 
 //poco headers
 #include <Poco/Path.h>
 
 const std::string QmitkNavigationToolManagementWidget::VIEW_ID = "org.mitk.views.navigationtoolmanagementwidget";
 
 QmitkNavigationToolManagementWidget::QmitkNavigationToolManagementWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f)
 {
   m_Controls = NULL;
   CreateQtPartControl(this);
   CreateConnections();
   m_NavigationToolStorage = mitk::NavigationToolStorage::New();
   m_Controls->m_SurfaceChooser->SetAutoSelectNewItems(true);
 }
 
 
 QmitkNavigationToolManagementWidget::~QmitkNavigationToolManagementWidget()
 {
 }
 
 void QmitkNavigationToolManagementWidget::CreateQtPartControl(QWidget *parent)
   {
     if (!m_Controls)
     {
     // create GUI widgets
     m_Controls = new Ui::QmitkNavigationToolManagementWidgetControls;
     m_Controls->setupUi(parent);
     }
   }
 
 void QmitkNavigationToolManagementWidget::CreateConnections()
   {
     if ( m_Controls )
     {
       //main widget page:
       connect( (QObject*)(m_Controls->m_AddTool), SIGNAL(clicked()), this, SLOT(OnAddTool()) );
       connect( (QObject*)(m_Controls->m_DeleteTool), SIGNAL(clicked()), this, SLOT(OnDeleteTool()) );
       connect( (QObject*)(m_Controls->m_EditTool), SIGNAL(clicked()), this, SLOT(OnEditTool()) );
-      connect( (QObject*)(m_Controls->m_LoadSingleTool), SIGNAL(clicked()), this, SLOT(OnLoadSingleTool()) );
-      connect( (QObject*)(m_Controls->m_SaveSingleTool), SIGNAL(clicked()), this, SLOT(OnSaveSingleTool()) );
       connect( (QObject*)(m_Controls->m_LoadStorage), SIGNAL(clicked()), this, SLOT(OnLoadStorage()) );
       connect( (QObject*)(m_Controls->m_SaveStorage), SIGNAL(clicked()), this, SLOT(OnSaveStorage()) );
           
       //widget page "add tool":
       connect( (QObject*)(m_Controls->m_AddToolCancel), SIGNAL(clicked()), this, SLOT(OnAddToolCancel()) );
       connect( (QObject*)(m_Controls->m_AddToolSave), SIGNAL(clicked()), this, SLOT(OnAddToolSave()) );
       connect( (QObject*)(m_Controls->m_LoadSurface), SIGNAL(clicked()), this, SLOT(OnLoadSurface()) );
       connect( (QObject*)(m_Controls->m_LoadCalibrationFile), SIGNAL(clicked()), this, SLOT(OnLoadCalibrationFile()) );
     }
   }
 
 void QmitkNavigationToolManagementWidget::Initialize(mitk::DataStorage* dataStorage)
   {
   m_DataStorage = dataStorage;
   }
 
 //##################################################################################
 //############################## slots: main widget ################################
 //##################################################################################
 
 void QmitkNavigationToolManagementWidget::OnAddTool()
   {
     //initialize UI components
     m_Controls->m_SurfaceChooser->SetDataStorage(m_DataStorage);
     m_Controls->AddToolLabel->setText("<b>Add Tool:</b>");
     m_Controls->m_MainWidgets->setCurrentIndex(1);
 
     //reset input fields
     m_Controls->m_ToolNameEdit->setText("");
     m_Controls->m_IdentifierEdit->setText("NavigationTool#"+QString::number(m_NavigationToolStorage->GetToolCount()));
     m_Controls->m_SerialNumberEdit->setText("");
     m_Controls->m_CalibrationFileName->setText("");   
 
     m_edit = false;
   }
 
 void QmitkNavigationToolManagementWidget::OnDeleteTool()
   {
     //if no item is selected, show error message:
     if (m_Controls->m_ToolList->currentItem() == NULL) {MessageBox("Error: Please select tool first!");return;}
 
     m_DataStorage->Remove(m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row())->GetDataNode());
     m_NavigationToolStorage->DeleteTool(m_Controls->m_ToolList->currentIndex().row());
     UpdateToolTable();
 
   }
 
 void QmitkNavigationToolManagementWidget::OnEditTool()
   {
     //if no item is selected, show error message:
     if (m_Controls->m_ToolList->currentItem() == NULL) {MessageBox("Error: Please select tool first!");return;}
 
     //initialize UI components
     m_Controls->m_SurfaceChooser->SetDataStorage(m_DataStorage);
     m_Controls->AddToolLabel->setText("<b>Edit Tool:</b>");
     m_Controls->m_MainWidgets->setCurrentIndex(1);
 
     //fill forms
     mitk::NavigationTool::Pointer selectedTool = m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row());
     m_Controls->m_ToolNameEdit->setText(QString(selectedTool->GetDataNode()->GetName().c_str()));
     m_Controls->m_IdentifierEdit->setText(QString(selectedTool->GetIdentifier().c_str()));
     m_Controls->m_SerialNumberEdit->setText(QString(selectedTool->GetSerialNumber().c_str()));
     switch(selectedTool->GetTrackingDeviceType())
       {
       case mitk::NDIAurora:
               m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(0);break;
       case mitk::NDIPolaris:
               m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(1);break;
       case mitk::ClaronMicron:
               m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(2);break;
       default:
               m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(0);
       }
     m_Controls->m_CalibrationFileName->setText(QString(selectedTool->GetCalibrationFile().c_str()));
     switch(selectedTool->GetType())
       {
       case mitk::NavigationTool::Instrument:
         m_Controls->m_ToolTypeChooser->setCurrentIndex(0); break;
       case mitk::NavigationTool::Fiducial:
         m_Controls->m_ToolTypeChooser->setCurrentIndex(1); break;
       case mitk::NavigationTool::Skinmarker:
         m_Controls->m_ToolTypeChooser->setCurrentIndex(2); break;
       case mitk::NavigationTool::Unknown:
         m_Controls->m_ToolTypeChooser->setCurrentIndex(3); break;
       }
 
     m_Controls->m_SurfaceChooser->SetSelectedNode(selectedTool->GetDataNode());
     m_edit = true;
   }
 
-void QmitkNavigationToolManagementWidget::OnLoadSingleTool()
-  {
-    mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New(m_DataStorage);
-    mitk::NavigationTool::Pointer readTool = myReader->DoRead(QFileDialog::getOpenFileName(NULL,tr("Open Navigation Tool"), "/", "*.*").toAscii().data());
-    if (readTool.IsNull()) MessageBox("Error: " + myReader->GetErrorMessage());
-    else 
-      { 
-      if (!m_NavigationToolStorage->AddTool(readTool))
-        {
-        MessageBox("Error: Can't add tool!");
-        m_DataStorage->Remove(readTool->GetDataNode());
-        }
-      UpdateToolTable();
-      }
-  }
-
-void QmitkNavigationToolManagementWidget::OnSaveSingleTool()
-  {
-    //if no item is selected, show error message:
-    if (m_Controls->m_ToolList->currentItem() == NULL) {MessageBox("Error: Please select tool first!");return;}
-
-    mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
-    if (!myWriter->DoWrite(QFileDialog::getSaveFileName(NULL,tr("Save Navigation Tool"), "/", "*.*").toAscii().data(),m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row()))) 
-      MessageBox("Error: "+ myWriter->GetErrorMessage());
-  }
-
 void QmitkNavigationToolManagementWidget::OnLoadStorage()
   {
     mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(m_DataStorage);
     std::string filename = QFileDialog::getOpenFileName(NULL,tr("Open Navigation Tool"), "/", "*.*").toAscii().data();
     if (filename == "") return;
     mitk::NavigationToolStorage::Pointer tempStorage = myDeserializer->Deserialize(filename);
     if (tempStorage.IsNull()) MessageBox("Error" + myDeserializer->GetErrorMessage());
     else 
       {
       m_NavigationToolStorage = tempStorage;
       Poco::Path myPath = Poco::Path(filename.c_str());
       m_Controls->m_StorageName->setText(myPath.getFileName().c_str());
       }
     UpdateToolTable();
   }
 
 void QmitkNavigationToolManagementWidget::OnSaveStorage()
   {
     mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
     std::string filename = QFileDialog::getSaveFileName(NULL,tr("Save Navigation Tool"), "/", "*.*").toAscii().data();
     if (!mySerializer->Serialize(filename,m_NavigationToolStorage)) MessageBox("Error: " + mySerializer->GetErrorMessage());
     else 
       {
       Poco::Path myPath = Poco::Path(filename.c_str());
       m_Controls->m_StorageName->setText(myPath.getFileName().c_str());
       }
   }
 
 
 //##################################################################################
 //############################## slots: add tool widget ############################
 //##################################################################################
 
 void QmitkNavigationToolManagementWidget::OnAddToolSave()
   {
     mitk::NavigationTool::Pointer workTool;
    
     if (m_edit) //here we edit a existing tool
       {
       workTool = m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row());
       
       //edit existing DataNode...
       workTool->GetDataNode()->SetName(m_Controls->m_ToolNameEdit->text().toLatin1());
       workTool->GetDataNode()->SetData(m_Controls->m_SurfaceChooser->GetSelectedNode()->GetData());
       }
     else //here we create a new tool
       {
       workTool = mitk::NavigationTool::New();
     
       //create DataNode...
       mitk::DataNode::Pointer newNode = mitk::DataNode::New();
       newNode->SetName(m_Controls->m_ToolNameEdit->text().toLatin1());
       newNode->SetData(m_Controls->m_SurfaceChooser->GetSelectedNode()->GetData());
       m_DataStorage->Add(newNode);
       workTool->SetDataNode(newNode);
       }
 
     //fill NavigationTool object
     workTool->SetCalibrationFile(m_Controls->m_CalibrationFileName->text().toAscii().data());
     workTool->SetIdentifier(m_Controls->m_IdentifierEdit->text().toAscii().data());
     workTool->SetSerialNumber(m_Controls->m_SerialNumberEdit->text().toAscii().data());
     //Tracking Device
     if (m_Controls->m_TrackingDeviceTypeChooser->currentText()=="NDI Aurora") workTool->SetTrackingDeviceType(mitk::NDIAurora);
     else if (m_Controls->m_TrackingDeviceTypeChooser->currentText()=="NDI Polaris") workTool->SetTrackingDeviceType(mitk::NDIPolaris);
     else if (m_Controls->m_TrackingDeviceTypeChooser->currentText()=="Claron Technology Micron Tracker") workTool->SetTrackingDeviceType(mitk::ClaronMicron);
     else workTool->SetTrackingDeviceType(mitk::TrackingSystemNotSpecified);
     //ToolType
     if (m_Controls->m_ToolTypeChooser->currentText()=="Instrument") workTool->SetType(mitk::NavigationTool::Instrument);
     else if (m_Controls->m_ToolTypeChooser->currentText()=="Fiducial") workTool->SetType(mitk::NavigationTool::Fiducial);
     else if (m_Controls->m_ToolTypeChooser->currentText()=="Skinmarker") workTool->SetType(mitk::NavigationTool::Skinmarker);
     else workTool->SetType(mitk::NavigationTool::Unknown);
 
     if (!m_edit) m_NavigationToolStorage->AddTool(workTool);
 
     UpdateToolTable();
 
     m_Controls->m_MainWidgets->setCurrentIndex(0);
   }
 
 void QmitkNavigationToolManagementWidget::OnAddToolCancel()
   {
     m_Controls->m_MainWidgets->setCurrentIndex(0);
   }
 
 void QmitkNavigationToolManagementWidget::OnLoadSurface()
   {
     std::string filename = QFileDialog::getOpenFileName(NULL,tr("Open Surface"), "/", "*.stl").toLatin1().data();
     mitk::STLFileReader::Pointer stlReader = mitk::STLFileReader::New();
     try
       {
       stlReader->SetFileName( filename.c_str() );
       stlReader->Update();
       }
     catch (...)
       {
       }
 
     if ( stlReader->GetOutput() == NULL );
     else
       {
       mitk::DataNode::Pointer newNode = mitk::DataNode::New();
       newNode->SetName(filename);
       newNode->SetData(stlReader->GetOutput());
       m_DataStorage->Add(newNode);
       }
   }
 
 void QmitkNavigationToolManagementWidget::OnLoadCalibrationFile()
   {
     m_Controls->m_CalibrationFileName->setText(QFileDialog::getOpenFileName(NULL,tr("Open Calibration File"), "/", "*.*"));
   }
 
 
 
 //##################################################################################
 //############################## private help methods ##############################
 //##################################################################################
 void QmitkNavigationToolManagementWidget::UpdateToolTable()
   {
   m_Controls->m_ToolList->clear();
   for(int i=0; i<m_NavigationToolStorage->GetToolCount(); i++)
     {
       QString currentTool = "Tool" + QString::number(i) + ": " + QString(m_NavigationToolStorage->GetTool(i)->GetDataNode()->GetName().c_str())+ " ";
       switch (m_NavigationToolStorage->GetTool(i)->GetTrackingDeviceType())
         {
         case mitk::ClaronMicron:
               currentTool += "(MicronTracker/"; break;
         case mitk::NDIAurora:
               currentTool += "(NDI Aurora/"; break;
         case mitk::NDIPolaris:
               currentTool += "(NDI Polaris/"; break;
         default:
               currentTool += "(unknown tracking system/"; break;
         }
       switch (m_NavigationToolStorage->GetTool(i)->GetType())
         {
         case mitk::NavigationTool::Instrument:
               currentTool += "Instrument)"; break;
         case mitk::NavigationTool::Fiducial:
               currentTool += "Fiducial)"; break;
         case mitk::NavigationTool::Skinmarker:
               currentTool += "Skinmarker)"; break;
         default:
               currentTool += "Unknown)";
         }
       m_Controls->m_ToolList->addItem(currentTool);
     }
 
   }
 
 void QmitkNavigationToolManagementWidget::MessageBox(std::string s)
   {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
   }
-
-void QmitkNavigationToolManagementWidget::EnableSingleToolSave(bool enable)
-  {
-  if (enable)
-    {
-    m_Controls->m_LoadSingleTool->setVisible(true);
-    m_Controls->m_SaveSingleTool->setVisible(true);
-    m_Controls->m_singleToolLabel->setVisible(true);
-    }
-  else
-    {
-    m_Controls->m_LoadSingleTool->setVisible(false);
-    m_Controls->m_SaveSingleTool->setVisible(false);
-    m_Controls->m_singleToolLabel->setVisible(false);
-    }
-
-  }
\ No newline at end of file
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.h b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.h
index 081069cc5c..5e7902281a 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.h
@@ -1,97 +1,92 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-05-12 19:14:45 +0200 (Di, 12 Mai 2009) $
 Version:   $Revision: 1.12 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef QMITKNAVIGATIONTOOLMANAGEMENTWIDGET_H
 #define QMITKNAVIGATIONTOOLMANAGEMENTWIDGET_H
 
 //QT headers
 #include <QWidget>
 
 //mitk headers
 #include "MitkIGTUIExports.h"
 #include "mitkNavigationTool.h"
 #include <mitkNavigationToolStorage.h>
 
 //ui header
 #include "ui_QmitkNavigationToolManagementWidgetControls.h"
 
  /** Documentation:
   *   \brief An object of this class offers an UI to manage NavigationTools and 
   *			 NavigationToolStorages. This means a user may create, save and load 
   *  		 single NavigationTools and/or NavigationToolStorages with this widget.
   *
   *      Be sure to call the Initialize-methode before you start the widget
   *      otherwise some errors might occure.
   *
   *   \ingroup IGTUI
   */
 class MitkIGTUI_EXPORT QmitkNavigationToolManagementWidget : public QWidget
 {
   Q_OBJECT
 
   public:
     static const std::string VIEW_ID;
 
     void Initialize(mitk::DataStorage* dataStorage);
 
     QmitkNavigationToolManagementWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
     ~QmitkNavigationToolManagementWidget();
 
-    /** @brief Enables/disables if single tools can be saved or loaded. Default is on.*/
-    void EnableSingleToolSave(bool enable);
-
   protected slots:
 
     //main widget page:
     void OnAddTool();
     void OnDeleteTool();
     void OnEditTool();
-    void OnLoadSingleTool();
-    void OnSaveSingleTool();
     void OnLoadStorage();
     void OnSaveStorage();
 
     //widget page "add tool":
     void OnAddToolCancel();
     void OnAddToolSave();
     void OnLoadSurface();
     void OnLoadCalibrationFile();
 
 
   protected:
 
     /// \brief Creation of the connections
     virtual void CreateConnections();
 
     virtual void CreateQtPartControl(QWidget *parent);
     
     Ui::QmitkNavigationToolManagementWidgetControls* m_Controls;
 
     /** @brief holds the DataStorage */
     mitk::DataStorage* m_DataStorage;
 
     /** @brief holds the NavigationToolStorage we are working with. */
     mitk::NavigationToolStorage::Pointer m_NavigationToolStorage;
     
     /** @brief shows if we are in edit mode, if not we create new navigation tool objects. */
     bool m_edit;
 
     //############## private help methods #######################
     void MessageBox(std::string s);
     void UpdateToolTable();
 };
-#endif
\ No newline at end of file
+#endif
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidgetControls.ui b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidgetControls.ui
index 1abab918df..30e384dd74 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidgetControls.ui
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidgetControls.ui
@@ -1,565 +1,527 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkNavigationToolManagementWidgetControls</class>
  <widget class="QWidget" name="QmitkNavigationToolManagementWidgetControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>346</width>
+    <width>371</width>
     <height>534</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_3">
    <item>
     <widget class="QLabel" name="widget_title_label">
      <property name="text">
       <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:8.25pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-size:8pt;&quot;&gt;&lt;span style=&quot; font-size:14pt; font-weight:600;&quot;&gt;Navigation Tool Management&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="Line" name="line">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QStackedWidget" name="m_MainWidgets">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="main_page">
       <layout class="QVBoxLayout" name="verticalLayout">
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout">
          <item>
           <widget class="QLabel" name="label_10">
            <property name="text">
             <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:8.25pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:8pt; font-weight:600;&quot;&gt;Filename:&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QLabel" name="m_StorageName">
            <property name="text">
             <string>&lt;NO NAME&gt;</string>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_4">
          <item>
           <widget class="QLabel" name="label_11">
            <property name="text">
             <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:8.25pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:8pt; font-weight:600;&quot;&gt;Tools:&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer_4">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QPushButton" name="m_AddTool">
            <property name="text">
             <string>Add</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="m_DeleteTool">
            <property name="text">
             <string>Delete</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="m_EditTool">
            <property name="text">
             <string>Edit</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <widget class="QListWidget" name="m_ToolList"/>
        </item>
-       <item>
-        <layout class="QHBoxLayout" name="horizontalLayout_2">
-         <item>
-          <spacer name="horizontalSpacer_2">
-           <property name="orientation">
-            <enum>Qt::Horizontal</enum>
-           </property>
-           <property name="sizeHint" stdset="0">
-            <size>
-             <width>40</width>
-             <height>20</height>
-            </size>
-           </property>
-          </spacer>
-         </item>
-         <item>
-          <widget class="QLabel" name="m_singleToolLabel">
-           <property name="text">
-            <string>single tool (selected):</string>
-           </property>
-          </widget>
-         </item>
-         <item>
-          <widget class="QPushButton" name="m_LoadSingleTool">
-           <property name="text">
-            <string>Load</string>
-           </property>
-          </widget>
-         </item>
-         <item>
-          <widget class="QPushButton" name="m_SaveSingleTool">
-           <property name="text">
-            <string>Save</string>
-           </property>
-          </widget>
-         </item>
-        </layout>
-       </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_3">
          <item>
           <spacer name="horizontalSpacer_3">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QLabel" name="label_2">
            <property name="text">
             <string>whole storage:</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="m_LoadStorage">
            <property name="text">
             <string>Load</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="m_SaveStorage">
            <property name="text">
             <string>Save</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="new_tool_page">
       <layout class="QVBoxLayout" name="verticalLayout_2">
        <item>
         <widget class="QLabel" name="AddToolLabel">
          <property name="text">
           <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:8.25pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:8pt; font-weight:600; text-decoration: underline;&quot;&gt;Add Tool&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
         </widget>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_11">
          <item>
           <widget class="QLabel" name="label_3">
            <property name="minimumSize">
             <size>
              <width>100</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Name:</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QLineEdit" name="m_ToolNameEdit"/>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_10">
          <item>
           <widget class="QLabel" name="label_4">
            <property name="minimumSize">
             <size>
              <width>100</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Identifier:</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QLineEdit" name="m_IdentifierEdit"/>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_9">
          <item>
           <widget class="QLabel" name="label_5">
            <property name="minimumSize">
             <size>
              <width>100</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Serial Number:</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QLineEdit" name="m_SerialNumberEdit"/>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_8">
          <item>
           <widget class="QLabel" name="label_6">
            <property name="minimumSize">
             <size>
              <width>100</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Tracking Device:</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QComboBox" name="m_TrackingDeviceTypeChooser">
            <property name="minimumSize">
             <size>
              <width>150</width>
              <height>0</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>150</width>
              <height>16777215</height>
             </size>
            </property>
            <item>
             <property name="text">
              <string>NDI Aurora</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>NDI Polaris</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Claron Technology Micron Tracker</string>
             </property>
            </item>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer_6">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_7">
          <item>
           <widget class="QLabel" name="label_7">
            <property name="minimumSize">
             <size>
              <width>100</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Tool Type:</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QComboBox" name="m_ToolTypeChooser">
            <property name="minimumSize">
             <size>
              <width>150</width>
              <height>0</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>150</width>
              <height>16777215</height>
             </size>
            </property>
            <item>
             <property name="text">
              <string>Instrument</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Fiducial</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Skinmarker</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Unkown</string>
             </property>
            </item>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer_7">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_6">
          <item>
           <widget class="QLabel" name="label_8">
            <property name="minimumSize">
             <size>
              <width>100</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Calibration File:</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QLineEdit" name="m_CalibrationFileName"/>
          </item>
          <item>
           <widget class="QPushButton" name="m_LoadCalibrationFile">
            <property name="maximumSize">
             <size>
              <width>40</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="text">
             <string>Load</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_5">
          <item>
           <widget class="QLabel" name="label_9">
            <property name="minimumSize">
             <size>
              <width>100</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Surface:</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QmitkDataStorageComboBox" name="m_SurfaceChooser">
            <property name="minimumSize">
             <size>
              <width>150</width>
              <height>0</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>150</width>
              <height>16777215</height>
             </size>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer_8">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QPushButton" name="m_LoadSurface">
            <property name="maximumSize">
             <size>
              <width>40</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="text">
             <string>Load</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item>
         <widget class="Line" name="line_2">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
         </widget>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_12">
          <item>
           <spacer name="horizontalSpacer_5">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QPushButton" name="m_AddToolCancel">
            <property name="text">
             <string>cancel</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="m_AddToolSave">
            <property name="text">
             <string>save</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkDataStorageComboBox</class>
    <extends>QComboBox</extends>
    <header>QmitkDataStorageComboBox.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>