diff --git a/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.cpp b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.cpp
index caa615babf..b5ca3695ea 100644
--- a/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.cpp
@@ -1,70 +1,70 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #include <QmitkIGTCommonHelper.h>
 #include <QSettings>
 #include <QFileInfo>
 
-const std::string QmitkIGTCommonHelper::VIEW_ID = "org.mitk.views.igtcommoonhelper";
+const std::string QmitkIGTCommonHelper::VIEW_ID = "org.mitk.views.igtcommonhelper";
 
 void QmitkIGTCommonHelper::SetLastFileSavePath(const QString &str)
 {
   QSettings settings;
   settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
   settings.setValue("LastFileSavePath",QVariant(str));
   settings.endGroup();
 }
 
 void QmitkIGTCommonHelper::SetLastFileSavePathByFileName(const QString &str)
 {
   QFileInfo file(str);
   SetLastFileSavePath(file.absolutePath());
 }
 
 const QString QmitkIGTCommonHelper::GetLastFileSavePath()
 {
   QString path = "";
   QSettings settings;
   settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
   path = settings.value("LastFileSavePath",QString("")).toString();
   settings.endGroup();
 
   return path;
 }
 
 void QmitkIGTCommonHelper::SetLastFileLoadPath(const QString &str)
 {
   QSettings settings;
   settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
   settings.setValue("LastFileLoadPath",QVariant(str));
   settings.endGroup();
 }
 
 void QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(const QString &str)
 {
   QFileInfo file(str);
   SetLastFileLoadPath(file.absolutePath());
 }
 
 const QString QmitkIGTCommonHelper::GetLastFileLoadPath()
 {
   QString path = "";
   QSettings settings;
   settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
   path = settings.value("LastFileLoadPath",QString("")).toString();
   settings.endGroup();
 
   return path;
 }
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
index 1f0bee3268..b2e6943286 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
@@ -1,338 +1,340 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkNavigationToolCreationWidget.h"
 
 //mitk headers
 #include <mitkTrackingTypes.h>
 #include <mitkSurface.h>
 #include <mitkNavigationData.h>
 #include <mitkRenderingManager.h>
 #include "mitkTrackingDeviceTypeCollection.h"
 
 //qt headers
 #include <qfiledialog.h>
 #include <qmessagebox.h>
 #include <QDialog>
 #include <mitkIOUtil.h>
 #include <QmitkIGTCommonHelper.h>
 
 //poco headers
 #include <Poco/Path.h>
 
 // vtk
 #include <vtkSphereSource.h>
 #include <vtkConeSource.h>
 
 const std::string QmitkNavigationToolCreationWidget::VIEW_ID = "org.mitk.views.navigationtoolcreationwizardwidget";
 
 QmitkNavigationToolCreationWidget::QmitkNavigationToolCreationWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f)
 {
   m_Controls = NULL;
   m_AdvancedWidget = new QmitkNavigationToolCreationAdvancedWidget(this);
   m_AdvancedWidget->setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
   m_AdvancedWidget->setWindowTitle("Tool Creation Advanced Options");
   m_AdvancedWidget->setModal(false);
   CreateQtPartControl(this);
   CreateConnections();
 
 RefreshTrackingDeviceCollection();
 }
 
 QmitkNavigationToolCreationWidget::~QmitkNavigationToolCreationWidget()
 {
   m_Controls->m_CalibrationLandmarksList->SetPointSetNode(NULL);
   m_Controls->m_RegistrationLandmarksList->SetPointSetNode(NULL);
   delete m_AdvancedWidget;
 }
 
 void QmitkNavigationToolCreationWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNavigationToolCreationWidgetControls;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkNavigationToolCreationWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_cancel), SIGNAL(clicked()), this, SLOT(OnCancel()) );
     connect( (QObject*)(m_Controls->m_finished), SIGNAL(clicked()), this, SLOT(OnFinished()) );
     connect( (QObject*)(m_Controls->m_LoadSurface), SIGNAL(clicked()), this, SLOT(OnLoadSurface()) );
     connect( (QObject*)(m_Controls->m_LoadCalibrationFile), SIGNAL(clicked()), this, SLOT(OnLoadCalibrationFile()) );
     connect( (QObject*)(m_Controls->m_ShowAdvancedOptionsPB), SIGNAL(toggled(bool)), this, SLOT(OnShowAdvancedOptions(bool)) );
     connect( (QObject*)(m_AdvancedWidget), SIGNAL(DialogCloseRequested()), this, SLOT(OnProcessDialogCloseRequest()) );
     connect( (QObject*)(m_AdvancedWidget), SIGNAL(RetrieveDataForManualToolTipManipulation()), this, SLOT(OnRetrieveDataForManualTooltipManipulation()) );
 
     connect( m_Controls->m_Surface_Use_Other, SIGNAL(toggled(bool)), this, SLOT(OnSurfaceUseOtherToggled(bool)));
   }
 }
 
 void QmitkNavigationToolCreationWidget::Initialize(mitk::DataStorage* dataStorage, const std::string& supposedIdentifier, const std::string& supposedName)
 {
   m_DataStorage = dataStorage;
 
   //initialize UI components
   m_Controls->m_SurfaceChooser->SetDataStorage(m_DataStorage);
   m_Controls->m_SurfaceChooser->SetAutoSelectNewItems(true);
   m_Controls->m_SurfaceChooser->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
 
   //set default data
   m_Controls->m_ToolNameEdit->setText(supposedName.c_str());
   m_Controls->m_CalibrationFileName->setText("none");
   m_Controls->m_Surface_Use_Sphere->setChecked(true);
   m_AdvancedWidget->SetDataStorage(m_DataStorage);
   m_Controls->m_IdentifierEdit->setText(supposedIdentifier.c_str());
   this->InitializeUIToolLandmarkLists();
   m_Controls->m_CalibrationLandmarksList->EnableEditButton(false);
   m_Controls->m_RegistrationLandmarksList->EnableEditButton(false);
 }
 
 void QmitkNavigationToolCreationWidget::SetTrackingDeviceType(mitk::TrackingDeviceType type, bool changeable)
 {
   int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(type));
 
   if (index >= 0)
   {
     m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
   }
 }
 
 
 mitk::NavigationTool::Pointer QmitkNavigationToolCreationWidget::GetCreatedTool()
 {
   return m_CreatedTool;
 }
 
 //##################################################################################
 //############################## slots                  ############################
 //##################################################################################
 
 void QmitkNavigationToolCreationWidget::OnFinished()
 {
   //here we create a new tool
   m_CreatedTool = mitk::NavigationTool::New();
 
   //create DataNode...
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   if(m_Controls->m_Surface_Use_Sphere->isChecked())
   {
     //create small sphere and use it as surface
     mitk::Surface::Pointer mySphere = mitk::Surface::New();
     vtkConeSource *vtkData = vtkConeSource::New();
     vtkData->SetAngle(5.0);
     vtkData->SetResolution(50);
     vtkData->SetHeight(6.0f);
     vtkData->SetRadius(2.0f);
     vtkData->SetCenter(0.0, 0.0, 0.0);
     vtkData->Update();
     mySphere->SetVtkPolyData(vtkData->GetOutput());
     vtkData->Delete();
     newNode->SetData(mySphere);
   }
   else
   {
     newNode->SetData(m_Controls->m_SurfaceChooser->GetSelectedNode()->GetData());
   }
   newNode->SetName(m_Controls->m_ToolNameEdit->text().toLatin1());
 
   m_CreatedTool->SetDataNode(newNode);
 
   //fill NavigationTool object
   m_CreatedTool->SetCalibrationFile(m_Controls->m_CalibrationFileName->text().toLatin1().data());
   m_CreatedTool->SetIdentifier(m_Controls->m_IdentifierEdit->text().toLatin1().data());
   m_CreatedTool->SetSerialNumber(m_Controls->m_SerialNumberEdit->text().toLatin1().data());
 
 //Tracking Device
 m_CreatedTool->SetTrackingDeviceType(m_Controls->m_TrackingDeviceTypeChooser->currentText().toStdString());
 
   //ToolType
   if (m_Controls->m_ToolTypeChooser->currentText()=="Instrument") m_CreatedTool->SetType(mitk::NavigationTool::Instrument);
   else if (m_Controls->m_ToolTypeChooser->currentText()=="Fiducial") m_CreatedTool->SetType(mitk::NavigationTool::Fiducial);
   else if (m_Controls->m_ToolTypeChooser->currentText()=="Skinmarker") m_CreatedTool->SetType(mitk::NavigationTool::Skinmarker);
   else m_CreatedTool->SetType(mitk::NavigationTool::Unknown);
 
   //Tool Tip
   mitk::NavigationData::Pointer tempND = mitk::NavigationData::New(m_AdvancedWidget->GetManipulatedToolTip());
   m_CreatedTool->SetToolTipOrientation(tempND->GetOrientation());
   m_CreatedTool->SetToolTipPosition(tempND->GetPosition());
 
   //Tool Landmarks
   mitk::PointSet::Pointer toolCalLandmarks, toolRegLandmarks;
   GetUIToolLandmarksLists(toolCalLandmarks,toolRegLandmarks);
   m_CreatedTool->SetToolCalibrationLandmarks(toolCalLandmarks);
   m_CreatedTool->SetToolRegistrationLandmarks(toolRegLandmarks);
 
   emit NavigationToolFinished();
 }
 
 void QmitkNavigationToolCreationWidget::OnCancel()
 {
   m_CreatedTool = NULL;
 
   emit Canceled();
 }
 
 void QmitkNavigationToolCreationWidget::OnLoadSurface()
 {
   std::string filename = QFileDialog::getOpenFileName(NULL,tr("Open Surface"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("STL (*.stl)")).toLatin1().data();
   QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
   try
   {
     mitk::IOUtil::Load(filename.c_str(), *m_DataStorage);
   }
   catch (mitk::Exception &e)
   {
     MITK_ERROR << "Exception occured: " << e.what();
   }
 }
 
 void QmitkNavigationToolCreationWidget::OnLoadCalibrationFile()
 {
-  m_Controls->m_CalibrationFileName->setText(QFileDialog::getOpenFileName(NULL,tr("Open Calibration File"), "/", "*.*"));
+  QString fileName = QFileDialog::getOpenFileName(NULL,tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*");
+  QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(fileName);
+  m_Controls->m_CalibrationFileName->setText(fileName);
 }
 
 void QmitkNavigationToolCreationWidget::SetDefaultData(mitk::NavigationTool::Pointer DefaultTool)
 {
 m_Controls->m_ToolNameEdit->setText(QString(DefaultTool->GetDataNode()->GetName().c_str()));
 m_Controls->m_IdentifierEdit->setText(QString(DefaultTool->GetIdentifier().c_str()));
 m_Controls->m_SerialNumberEdit->setText(QString(DefaultTool->GetSerialNumber().c_str()));
 m_AdvancedWidget->SetDefaultTooltip( DefaultTool->GetToolTipTransform() );
 int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(DefaultTool->GetTrackingDeviceType()));
 
 if (index >= 0)
 {
   m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
 }
 
 m_Controls->m_CalibrationFileName->setText(QString(DefaultTool->GetCalibrationFile().c_str()));
 m_Controls->m_Surface_Use_Other->setChecked(true);
 switch(DefaultTool->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(DefaultTool->GetDataNode());
   FillUIToolLandmarkLists(DefaultTool->GetToolCalibrationLandmarks(),DefaultTool->GetToolRegistrationLandmarks());
 }
 
 
 //##################################################################################
 //############################## internal help methods #############################
 //##################################################################################
 void QmitkNavigationToolCreationWidget::MessageBox(std::string s)
 {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
 }
 
 void QmitkNavigationToolCreationWidget::OnShowAdvancedOptions(bool state)
 {
   if(state)
   {
     m_AdvancedWidget->show();
     m_AdvancedWidget->SetDefaultTooltip(m_AdvancedWidget->GetManipulatedToolTip()); //use the last one, if there is one
     m_AdvancedWidget->ReInitialize();
 
     // reinit the views with the new nodes
     mitk::DataStorage::SetOfObjects::ConstPointer rs = m_DataStorage->GetAll();
     mitk::TimeGeometry::Pointer bounds = m_DataStorage->ComputeBoundingGeometry3D(rs, "visible");    // initialize the views to the bounding geometry
     mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
   }
   else
   {
     m_AdvancedWidget->hide();
   }
 }
 
 void QmitkNavigationToolCreationWidget::OnProcessDialogCloseRequest()
 {
   m_AdvancedWidget->hide();
   m_Controls->m_ShowAdvancedOptionsPB->setChecked(false);
 }
 
 void QmitkNavigationToolCreationWidget::OnRetrieveDataForManualTooltipManipulation()
 {
   if(m_Controls->m_Surface_Use_Sphere->isChecked())
   {
     m_AdvancedWidget->SetToolTipSurface(true);
   }
   else
   {
     m_AdvancedWidget->SetToolTipSurface(false,
                                         dynamic_cast<mitk::DataNode*>(m_Controls->m_SurfaceChooser->GetSelectedNode().GetPointer()));
   }
 }
 
 void QmitkNavigationToolCreationWidget::OnSurfaceUseOtherToggled(bool checked)
 {
   m_Controls->m_LoadSurface->setEnabled(checked);
 }
 
 void QmitkNavigationToolCreationWidget::FillUIToolLandmarkLists(mitk::PointSet::Pointer calLandmarks, mitk::PointSet::Pointer regLandmarks)
 {
   m_calLandmarkNode->SetData(calLandmarks);
   m_regLandmarkNode->SetData(regLandmarks);
   m_Controls->m_CalibrationLandmarksList->SetPointSetNode(m_calLandmarkNode);
   m_Controls->m_RegistrationLandmarksList->SetPointSetNode(m_regLandmarkNode);
 }
 
 void QmitkNavigationToolCreationWidget::GetUIToolLandmarksLists(mitk::PointSet::Pointer& calLandmarks, mitk::PointSet::Pointer& regLandmarks)
 {
   calLandmarks = dynamic_cast<mitk::PointSet*>(m_calLandmarkNode->GetData());
   regLandmarks = dynamic_cast<mitk::PointSet*>(m_regLandmarkNode->GetData());
 }
 
 void QmitkNavigationToolCreationWidget::InitializeUIToolLandmarkLists()
 {
   m_calLandmarkNode = mitk::DataNode::New();
   m_regLandmarkNode = mitk::DataNode::New();
   FillUIToolLandmarkLists(mitk::PointSet::New(),mitk::PointSet::New());
 }
 
 void QmitkNavigationToolCreationWidget::RefreshTrackingDeviceCollection()
 {
   us::ModuleContext* context = us::GetModuleContext();
   std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > refs = context->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();
   if (refs.empty())
   {
     MITK_WARN << "No tracking device service found!";
     return;
   }
   mitk::TrackingDeviceTypeCollection* _DeviceTypeCollection = context->GetService<mitk::TrackingDeviceTypeCollection>(refs.front());
 
   for (auto name : _DeviceTypeCollection->GetTrackingDeviceTypeNames())
   {
     //if the device is not included yet, add name to comboBox and widget to stackedWidget
     if (m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(name)) == -1)
     {
       m_Controls->m_TrackingDeviceTypeChooser->addItem(QString::fromStdString(name));
     }
   }
 }
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
index 6aefa407aa..021c616e80 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
@@ -1,413 +1,413 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkNavigationToolManagementWidget.h"
 
 //mitk headers
 #include "mitkTrackingTypes.h"
 #include <mitkSurface.h>
 #include <mitkNavigationToolReader.h>
 #include <mitkNavigationToolWriter.h>
 #include <mitkNavigationToolStorage.h>
 #include <mitkNavigationToolStorageDeserializer.h>
 #include <mitkNavigationToolStorageSerializer.h>
 #include <QmitkIGTCommonHelper.h>
 
 //qt headers
 #include <qfiledialog.h>
 #include <qinputdialog.h>
 #include <qmessagebox.h>
 #include <qsettings.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();
 }
 
 
 QmitkNavigationToolManagementWidget::~QmitkNavigationToolManagementWidget()
 {
 }
 
 void QmitkNavigationToolManagementWidget::CreateQtPartControl(QWidget *parent)
   {
     if (!m_Controls)
     {
     // create GUI widgets
     m_Controls = new Ui::QmitkNavigationToolManagementWidgetControls;
     m_Controls->setupUi(parent);
     }
 
     //Disable StorageControls in the beginning, because there is no storage to edit
     DisableStorageControls();
   }
 
 void QmitkNavigationToolManagementWidget::OnLoadTool()
 {
   if(m_NavigationToolStorage->isLocked())
   {
     MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
    return;
   }
   mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New();
   std::string filename = QFileDialog::getOpenFileName(NULL,tr("Add Navigation Tool"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.IGTTool").toLatin1().data();
   QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
   if (filename == "") return;
   mitk::NavigationTool::Pointer readTool = myReader->DoRead(filename);
   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();
     m_NavigationToolStorage->UpdateMicroservice();
     }
 }
 
 void QmitkNavigationToolManagementWidget::OnSaveTool()
 {
     //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();
     std::string filename = QFileDialog::getSaveFileName(NULL,tr("Save Navigation Tool"), QmitkIGTCommonHelper::GetLastFileSavePath(), "*.IGTTool").toLatin1().data();
     QmitkIGTCommonHelper::SetLastFileSavePathByFileName(QString::fromStdString(filename));
     filename.append(".IGTTool");
     if (filename == "") return;
     if (!myWriter->DoWrite(filename,m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row())))
       MessageBox("Error: "+ myWriter->GetErrorMessage());
 }
 
 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_MoveToolUp), SIGNAL(clicked()), this, SLOT(OnMoveToolUp()) );
       connect( (QObject*)(m_Controls->m_MoveToolDown), SIGNAL(clicked()), this, SLOT(OnMoveToolDown()) );
       connect( (QObject*)(m_Controls->m_LoadStorage), SIGNAL(clicked()), this, SLOT(OnLoadStorage()) );
       connect( (QObject*)(m_Controls->m_SaveStorage), SIGNAL(clicked()), this, SLOT(OnSaveStorage()) );
       connect( (QObject*)(m_Controls->m_LoadTool), SIGNAL(clicked()), this, SLOT(OnLoadTool()) );
       connect( (QObject*)(m_Controls->m_SaveTool), SIGNAL(clicked()), this, SLOT(OnSaveTool()) );
       connect( (QObject*)(m_Controls->m_CreateNewStorage), SIGNAL(clicked()), this, SLOT(OnCreateStorage()) );
 
 
       //widget page "add tool":
       connect( (QObject*)(m_Controls->m_ToolCreationWidget), SIGNAL(Canceled()), this, SLOT(OnAddToolCancel()) );
       connect( (QObject*)(m_Controls->m_ToolCreationWidget), SIGNAL(NavigationToolFinished()), this, SLOT(OnAddToolSave()) );
     }
   }
 
 void QmitkNavigationToolManagementWidget::Initialize(mitk::DataStorage* dataStorage)
   {
   m_DataStorage = dataStorage;
   m_Controls->m_ToolCreationWidget->Initialize(m_DataStorage,"Tool0");
   }
 
 void QmitkNavigationToolManagementWidget::LoadStorage(mitk::NavigationToolStorage::Pointer storageToLoad)
   {
   if(storageToLoad.IsNotNull())
     {
     m_NavigationToolStorage = storageToLoad;
     m_Controls->m_StorageName->setText(m_NavigationToolStorage->GetName().c_str());
     EnableStorageControls();
     }
   else
     {
     m_NavigationToolStorage = NULL;
     DisableStorageControls();
     }
   UpdateToolTable();
   m_NavigationToolStorage->UpdateMicroservice();
   }
 
 //##################################################################################
 //############################## slots: main widget ################################
 //##################################################################################
 
 void QmitkNavigationToolManagementWidget::OnMoveToolUp()
 {
   if (m_NavigationToolStorage.IsNotNull())
   {
     int toolIndex = m_Controls->m_ToolList->currentIndex().row();
     if (toolIndex >= 0)
     {
       mitk::NavigationTool::Pointer currentNavigationTool = m_NavigationToolStorage->GetTool(toolIndex);
       if (currentNavigationTool.IsNotNull())
       {
         std::string currentIdentifier = currentNavigationTool->GetIdentifier();
         int NewNumber = m_Controls->m_ToolList->currentIndex().row() - 1;
         if (NewNumber < 0) { MITK_WARN << "Cannot move tool up because it is on the top!"; }
         else { m_NavigationToolStorage->AssignToolNumber(currentIdentifier, NewNumber); }
         UpdateToolTable();
         m_NavigationToolStorage->UpdateMicroservice();
       }
     }
   }
 }
 
 void QmitkNavigationToolManagementWidget::OnMoveToolDown()
 {
   if (m_NavigationToolStorage.IsNotNull())
   {
     int toolIndex = m_Controls->m_ToolList->currentIndex().row();
     if (toolIndex >= 0)
     {
       mitk::NavigationTool::Pointer currentNavigationTool = m_NavigationToolStorage->GetTool(toolIndex);
       if (currentNavigationTool.IsNotNull())
       {
         std::string currentIdentifier = currentNavigationTool->GetIdentifier();
         int NewNumber = m_Controls->m_ToolList->currentIndex().row() + 1;
         if (NewNumber >= m_NavigationToolStorage->GetToolCount()) { MITK_WARN << "Cannot move tool down because it is the last tool in this storage!"; }
         else { m_NavigationToolStorage->AssignToolNumber(currentIdentifier, NewNumber); }
         UpdateToolTable();
         m_NavigationToolStorage->UpdateMicroservice();
       }
     }
   }
 }
 
 
 void QmitkNavigationToolManagementWidget::OnAddTool()
   {
     if(m_NavigationToolStorage->isLocked())
     {
       MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
       return;
     }
     QString defaultIdentifier = "NavigationTool#"+QString::number(m_NavigationToolStorage->GetToolCount());
     QString defaultName = "NavigationTool"+QString::number(m_NavigationToolStorage->GetToolCount());
     m_Controls->m_ToolCreationWidget->Initialize(m_DataStorage,defaultIdentifier.toStdString(),defaultName.toStdString());
     m_edit = false;
     m_Controls->m_MainWidgets->setCurrentIndex(1);
     m_NavigationToolStorage->UpdateMicroservice();
   }
 
 void QmitkNavigationToolManagementWidget::OnDeleteTool()
   {
     //first: some checks
     if(m_NavigationToolStorage->isLocked())
     {
       MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
       return;
     }
     else if (m_Controls->m_ToolList->currentItem() == NULL) //if no item is selected, show error message:
     {
       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();
     m_NavigationToolStorage->UpdateMicroservice();
   }
 
 void QmitkNavigationToolManagementWidget::OnEditTool()
   {
     if(m_NavigationToolStorage->isLocked())
     {
       MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
       return;
     }
     else if (m_Controls->m_ToolList->currentItem() == NULL) //if no item is selected, show error message:
     {
       MessageBox("Error: Please select tool first!");
       return;
     }
     mitk::NavigationTool::Pointer selectedTool = m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row());
     m_Controls->m_ToolCreationWidget->SetDefaultData(selectedTool);
     m_NavigationToolStorage->SetName("test");
     m_edit = true;
     m_Controls->m_MainWidgets->setCurrentIndex(1);
     m_NavigationToolStorage->UpdateMicroservice();
   }
 
 void QmitkNavigationToolManagementWidget::OnCreateStorage()
   {
     QString storageName = QInputDialog::getText(NULL,"Storage Name","Name of the new tool storage:");
     if (storageName.isNull()) return;
     m_NavigationToolStorage = mitk::NavigationToolStorage::New(this->m_DataStorage);
     m_NavigationToolStorage->SetName(storageName.toStdString());
     m_Controls->m_StorageName->setText(m_NavigationToolStorage->GetName().c_str());
     EnableStorageControls();
     emit NewStorageAdded(m_NavigationToolStorage, storageName.toStdString());
   }
 
 void QmitkNavigationToolManagementWidget::OnLoadStorage()
   {
     mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(m_DataStorage);
     std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Navigation Tool Storage"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("IGT Tool Storage (*.IGTToolStorage)")).toStdString();
     if (filename == "") return;
 
     QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
 
     try
     {
       mitk::NavigationToolStorage::Pointer tempStorage = myDeserializer->Deserialize(filename);
 
       if (tempStorage.IsNull()) MessageBox("Error" + myDeserializer->GetErrorMessage());
       else
       {
         Poco::Path myPath = Poco::Path(filename.c_str());
         tempStorage->SetName(myPath.getFileName()); //set the filename as name for the storage, so the user can identify it
         this->LoadStorage(tempStorage);
         emit NewStorageAdded(m_NavigationToolStorage,myPath.getFileName());
+        m_NavigationToolStorage->UpdateMicroservice();
       }
     }
     catch (const mitk::Exception& exception)
     {
       MessageBox(exception.GetDescription());
     }
-    m_NavigationToolStorage->UpdateMicroservice();
   }
 
 void QmitkNavigationToolManagementWidget::OnSaveStorage()
   {
     QFileDialog *fileDialog = new QFileDialog;
     fileDialog->setDefaultSuffix("IGTToolStorage");
     QString suffix = "IGT Tool Storage (*.IGTToolStorage)";
     QString filename  = fileDialog->getSaveFileName(NULL, tr("Save Navigation Tool Storage"), QmitkIGTCommonHelper::GetLastFileSavePath(), suffix, &suffix);
 
     if (filename.isEmpty()) return; //canceled by the user
 
     // check file suffix
     QFileInfo file(filename);
     if(file.suffix().isEmpty()) filename += ".IGTToolStorage";
     //serialize tool storage
     mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
     if (!mySerializer->Serialize(filename.toStdString(),m_NavigationToolStorage))
       {
       MessageBox("Error: " + mySerializer->GetErrorMessage());
       return;
       }
     Poco::Path myPath = Poco::Path(filename.toStdString());
     m_Controls->m_StorageName->setText(QString::fromStdString(myPath.getFileName()));
 
     QmitkIGTCommonHelper::SetLastFileSavePath(file.absolutePath());
   }
 
 
 //##################################################################################
 //############################## slots: add tool widget ############################
 //##################################################################################
 
 void QmitkNavigationToolManagementWidget::OnAddToolSave()
   {
     mitk::NavigationTool::Pointer newTool = m_Controls->m_ToolCreationWidget->GetCreatedTool();
 
     if (m_edit) //here we edit a existing tool
       {
       mitk::NavigationTool::Pointer editedTool = m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row());
       editedTool->Graft(newTool);
       }
     else //here we create a new tool
       {
       m_NavigationToolStorage->AddTool(newTool);
       }
 
     UpdateToolTable();
 
     m_Controls->m_MainWidgets->setCurrentIndex(0);
     m_NavigationToolStorage->UpdateMicroservice();
   }
 
 void QmitkNavigationToolManagementWidget::OnAddToolCancel()
   {
     m_Controls->m_MainWidgets->setCurrentIndex(0);
   }
 
 
 //##################################################################################
 //############################## private help methods ##############################
 //##################################################################################
 void QmitkNavigationToolManagementWidget::UpdateToolTable()
   {
   m_Controls->m_ToolList->clear();
   if(m_NavigationToolStorage.IsNull()) return;
   for(int i=0; i<m_NavigationToolStorage->GetToolCount(); i++)
     {
       QString currentTool = "Tool" + QString::number(i) + ": " + QString(m_NavigationToolStorage->GetTool(i)->GetDataNode()->GetName().c_str())+ " ";
 
       currentTool += "(" + QString::fromStdString(m_NavigationToolStorage->GetTool(i)->GetTrackingDeviceType()) + "/";
 
       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::DisableStorageControls()
 {
   m_Controls->m_StorageName->setText("<none>");
   m_Controls->m_AddTool->setEnabled(false);
   m_Controls->m_LoadTool->setEnabled(false);
   m_Controls->m_MoveToolUp->setEnabled(false);
   m_Controls->m_MoveToolDown->setEnabled(false);
   m_Controls->m_selectedLabel->setEnabled(false);
   m_Controls->m_DeleteTool->setEnabled(false);
   m_Controls->m_EditTool->setEnabled(false);
   m_Controls->m_SaveTool->setEnabled(false);
   m_Controls->m_ToolList->setEnabled(false);
   m_Controls->m_SaveStorage->setEnabled(false);
   m_Controls->m_ToolLabel->setEnabled(false);
 }
 
 void QmitkNavigationToolManagementWidget::EnableStorageControls()
 {
   m_Controls->m_AddTool->setEnabled(true);
   m_Controls->m_LoadTool->setEnabled(true);
   m_Controls->m_MoveToolUp->setEnabled(true);
   m_Controls->m_MoveToolDown->setEnabled(true);
   m_Controls->m_selectedLabel->setEnabled(true);
   m_Controls->m_DeleteTool->setEnabled(true);
   m_Controls->m_EditTool->setEnabled(true);
   m_Controls->m_SaveTool->setEnabled(true);
   m_Controls->m_ToolList->setEnabled(true);
   m_Controls->m_SaveStorage->setEnabled(true);
   m_Controls->m_ToolLabel->setEnabled(true);
 }