diff --git a/Modules/IGT/DataManagement/mitkNavigationToolStorage.cpp b/Modules/IGT/DataManagement/mitkNavigationToolStorage.cpp
index d9094697b6..27cad1b767 100644
--- a/Modules/IGT/DataManagement/mitkNavigationToolStorage.cpp
+++ b/Modules/IGT/DataManagement/mitkNavigationToolStorage.cpp
@@ -1,230 +1,239 @@
 /*===================================================================
 
 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 "mitkNavigationToolStorage.h"
 
 //Microservices
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 
 const std::string  mitk::NavigationToolStorage::US_INTERFACE_NAME = "org.mitk.services.NavigationToolStorage"; // Name of the interface
 const std::string  mitk::NavigationToolStorage::US_PROPKEY_SOURCE_ID = US_INTERFACE_NAME + ".sourceID";
 const std::string  mitk::NavigationToolStorage::US_PROPKEY_STORAGE_NAME = US_INTERFACE_NAME + ".name";
 
 mitk::NavigationToolStorage::NavigationToolStorage()
   : m_ToolCollection(std::vector<mitk::NavigationTool::Pointer>()),
   m_DataStorage(NULL),
   m_storageLocked(false)
 {
   this->SetName("ToolStorage (no name given)");
 }
 
 mitk::NavigationToolStorage::NavigationToolStorage(mitk::DataStorage::Pointer ds)
   : m_storageLocked(false)
 {
   m_ToolCollection = std::vector<mitk::NavigationTool::Pointer>();
   this->m_DataStorage = ds;
   this->SetName("Tool Storage (no name given)");
 }
 
 void mitk::NavigationToolStorage::SetName(std::string n)
 {
   m_Name = n;
   m_props[US_PROPKEY_STORAGE_NAME] = m_Name;
 }
 
 std::string mitk::NavigationToolStorage::GetName() const
 {
   return m_Name;
 }
 
 void mitk::NavigationToolStorage::UpdateMicroservice()
 {
   if (m_ServiceRegistration) { m_ServiceRegistration.SetProperties(m_props); }
 }
 
 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());
   }
 }
 
-void mitk::NavigationToolStorage::RegisterAsMicroservice(std::string sourceID){
-  if (sourceID.empty()) mitkThrow() << "Empty or null string passed to NavigationToolStorage::registerAsMicroservice().";
-
+void mitk::NavigationToolStorage::RegisterAsMicroservice(){
   // Get Context
   us::ModuleContext* context = us::GetModuleContext();
 
   // Define ServiceProps
-  m_props[US_PROPKEY_SOURCE_ID] = sourceID;
   m_ServiceRegistration = context->RegisterService(this, m_props);
   //Tell all widgets, that there is a new toolStorage registered, e.g. the old one might have changed.
   UpdateMicroservice();
 }
 
 void mitk::NavigationToolStorage::UnRegisterMicroservice(){
   if (!m_ServiceRegistration)
   {
     MITK_WARN("NavigationToolStorage")
       << "Cannot unregister microservice as it wasn't registered before.";
     return;
   }
 
   m_ServiceRegistration.Unregister();
   m_ServiceRegistration = 0;
 }
 
 bool mitk::NavigationToolStorage::DeleteTool(int number)
 {
   if (m_storageLocked)
   {
     MITK_WARN << "Storage is locked, cannot modify it!";
     return false;
   }
 
   else if ((unsigned int)number > m_ToolCollection.size())
   {
     MITK_WARN << "Tool no " << number << "doesn't exist, can't delete it!";
     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);
 
   //This line is important so that other widgets can get a notice that the toolStorage has changed!
   this->UpdateMicroservice();
   return true;
 }
 
 bool mitk::NavigationToolStorage::DeleteAllTools()
 {
   if (m_storageLocked)
   {
     MITK_WARN << "Storage is locked, cannot modify it!";
     return false;
   }
 
   while (m_ToolCollection.size() > 0) if (!DeleteTool(0)) return false;
   return true;
 }
 
 bool mitk::NavigationToolStorage::AddTool(mitk::NavigationTool::Pointer tool)
 {
   if (m_storageLocked)
   {
     MITK_WARN << "Storage is locked, cannot modify it!";
     return false;
   }
   else if (GetTool(tool->GetIdentifier()).IsNotNull())
   {
     MITK_WARN << "Tool ID already exists in storage, can't add!";
     return false;
   }
   else
   {
     m_ToolCollection.push_back(tool);
     if (m_DataStorage.IsNotNull())
     {
       if (!m_DataStorage->Exists(tool->GetDataNode()))
         m_DataStorage->Add(tool->GetDataNode());
     }
     //This line is important so that other widgets can get a notice that the toolStorage has changed!
     this->UpdateMicroservice();
     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();
 }
 
 void mitk::NavigationToolStorage::LockStorage()
 {
   m_storageLocked = true;
 }
 
 void mitk::NavigationToolStorage::UnLockStorage()
 {
   m_storageLocked = false;
 }
 
 bool mitk::NavigationToolStorage::isLocked()
 {
   return m_storageLocked;
 }
 
 bool mitk::NavigationToolStorage::AssignToolNumber(std::string identifier1, int number2)
 {
   if (this->GetTool(identifier1).IsNull())
   {
     MITK_WARN << "Identifier does not exist, cannot assign new number";
     return false;
   }
 
   if ((number2 >= m_ToolCollection.size()) || (number2 < 0))
   {
     MITK_WARN << "Invalid number, cannot assign new number";
     return false;
   }
 
   mitk::NavigationTool::Pointer tool2 = m_ToolCollection.at(number2);
 
   int number1 = -1;
 
   for (int i = 0; i < m_ToolCollection.size(); i++)
   {
     if (m_ToolCollection.at(i)->GetIdentifier() == identifier1) { number1 = i; }
   }
 
   m_ToolCollection[number2] = m_ToolCollection.at(number1);
 
   m_ToolCollection[number1] = tool2;
 
   MITK_DEBUG << "Swapped tool " << number2 << " with tool " << number1;
 
   //This line is important so that other widgets can get a notice that the toolStorage has changed!
   this->UpdateMicroservice();
 
   return true;
+}
+
+void mitk::NavigationToolStorage::SetSourceID(std::string _id)
+{
+  m_SourceID = _id;
+  m_props[US_PROPKEY_SOURCE_ID] = m_SourceID;
+}
+
+/** @return Returns the name of this storage. */
+std::string mitk::NavigationToolStorage::GetSourceID() const
+{
+  return m_SourceID;
 }
\ No newline at end of file
diff --git a/Modules/IGT/DataManagement/mitkNavigationToolStorage.h b/Modules/IGT/DataManagement/mitkNavigationToolStorage.h
index 31f1e83222..9fbcf37b7a 100644
--- a/Modules/IGT/DataManagement/mitkNavigationToolStorage.h
+++ b/Modules/IGT/DataManagement/mitkNavigationToolStorage.h
@@ -1,186 +1,201 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #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>
 
 // Microservices
 #include <mitkServiceInterface.h>
 #include <usServiceRegistration.h>
 #include <usServiceProperties.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:
     mitkClassMacroItkParent(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.
      */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(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 Registers this object as a Microservice, making it available to every module and/or plugin.
     * To unregister, call UnregisterMicroservice(). Make sure to pass the id of the Device that this tool is connected to.
     */
-    virtual void RegisterAsMicroservice(std::string sourceID);
+    virtual void RegisterAsMicroservice();
 
     /**
     *\brief Registers this object as a Microservice, making it available to every module and/or plugin.
     */
     virtual void UnRegisterMicroservice();
 
     /**
     *\brief Returns the id that this device is registered with. The id will only be valid, if the
     * NavigationDataSource has been registered using RegisterAsMicroservice().
     */
     std::string GetMicroserviceID();
 
     /**
     *\brief These constants are used in conjunction with Microservices
     */
-    static const std::string US_INTERFACE_NAME; // Name of the interface
-    static const std::string US_PROPKEY_SOURCE_ID; // ID of the device this ToolStorage is associated with
-    static const std::string US_PROPKEY_STORAGE_NAME; // name of the storage
+    // Name of the interface
+    static const std::string US_INTERFACE_NAME;
+    // ID of the NavigationDataSource this ToolStorage is associated with. Can be empty ("") and changed with SetSourceID().
+    static const std::string US_PROPKEY_SOURCE_ID;
+    // name of the storage
+    static const std::string US_PROPKEY_STORAGE_NAME;
 
 
     /**
      * @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);
 
     /** Assigns the given number to the tool with the given identifier. This means the tool is swapped with another tool in the internal tool vector.
      *  @return Returns true if the assignment was successfull. Returns false if assignment is not possible, e.g. because the identifier does not exist or if the given number is not available.
      **/
     bool AssignToolNumber(std::string identifier1, int number2);
 
     /**
      * @brief Deletes a tool from the collection.
      * Warning, this method operates on the data storage and is not thread save. Calling it from outside the main thread may cause crashes.
      */
     bool DeleteTool(int number);
 
     /**
      * @brief Deletes all tools from the collection.
      * Warning, this method operates on the data storage and is not thread save. Calling it from outside the main thread may cause crashes.
      */
     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();
 
     /**
      * @return Returns the corresponding data storage if one is set to this NavigationToolStorage.
      *         Returns NULL if none is set.
      */
     itkGetMacro(DataStorage,mitk::DataStorage::Pointer);
 
     /** Sets the name of this storage. The name should be understandable for the user.
      *  Something like "NDI Aurora Tool Storage". If a storage is loaded from the harddisk
      *  the name might be the filename.
      */
     void SetName(std::string);
 
     /** @return Returns the name of this storage. */
     std::string GetName() const;
 
+    /** Sets the name of this storage. The name should be understandable for the user.
+    *  Something like "NDI Aurora Tool Storage". If a storage is loaded from the harddisk
+    *  the name might be the filename.
+    *  @warning: if your microservice is already registered, you need to call UpdateMicroservice after changing the ID.
+    *  This can't be done inside this functions, as we might use different threads.
+    */
+    void SetSourceID(std::string);
+
+    /** @return Returns the name of this storage. */
+    std::string GetSourceID() const;
+
     /** Locks the storage. A logged storage may not be modified.
      *  If a method tries to modify the storage anyway a waring message is given.
      *  The storage is unlocked by default. A Storage might be locked when a
      *  tracking device is active and needs the storage to stay consistent.
      */
     void LockStorage();
 
     /** Unlocks the storage again. */
     void UnLockStorage();
 
     /** @return Returns true if the storage is locked at the moment, false if not. */
     bool isLocked();
 
     /** Sets the properties which causes the microservice to emit an update signal. */
     void UpdateMicroservice();
 
   protected:
     NavigationToolStorage();
     NavigationToolStorage(mitk::DataStorage::Pointer);
     ~NavigationToolStorage();
 
     std::vector<mitk::NavigationTool::Pointer> m_ToolCollection;
     mitk::DataStorage::Pointer m_DataStorage;
     std::string m_Name;
+    std::string m_SourceID;
     bool m_storageLocked;
 
   private:
     us::ServiceRegistration<Self> m_ServiceRegistration;
     us::ServiceProperties m_props;
 
   };
 } // namespace mitk
 MITK_DECLARE_SERVICE_INTERFACE(mitk::NavigationToolStorage, "org.mitk.services.NavigationToolStorage")
 #endif //NAVIGATIONTOOLSTORAGE
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationDataSourceSelectionWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationDataSourceSelectionWidget.cpp
index de982b5a4b..617f089554 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationDataSourceSelectionWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationDataSourceSelectionWidget.cpp
@@ -1,140 +1,137 @@
 /*===================================================================
 
 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 "QmitkNavigationDataSourceSelectionWidget.h"
 
 //mitk headers
 #include <mitkNavigationDataSource.h>
 #include <usGetModuleContext.h>
 #include <usServiceReference.h>
 
 
 
 QmitkNavigationDataSourceSelectionWidget::QmitkNavigationDataSourceSelectionWidget(QWidget* parent, Qt::WindowFlags f)
 : QWidget(parent, f)
 {
   m_Controls = NULL;
   CreateQtPartControl(this);
   CreateConnections();
 
 }
 
 
 QmitkNavigationDataSourceSelectionWidget::~QmitkNavigationDataSourceSelectionWidget()
 {
 
 }
 
 void QmitkNavigationDataSourceSelectionWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNavigationDataSourceSelectionWidgetControls;
     m_Controls->setupUi(parent);
 
     std::string empty = "";
     m_Controls->m_NavigationDataSourceWidget->Initialize<mitk::NavigationDataSource>(mitk::NavigationDataSource::US_PROPKEY_DEVICENAME,empty);
 
   }
 }
 
 void QmitkNavigationDataSourceSelectionWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_NavigationDataSourceWidget), SIGNAL(ServiceSelectionChanged(us::ServiceReferenceU)), this, SLOT(NavigationDataSourceSelected(us::ServiceReferenceU)) );
     connect((QObject*)(m_Controls->m_ToolView), SIGNAL(currentRowChanged(int)), this, SLOT(NavigationToolSelected(int)));
 
   }
 }
 
 void QmitkNavigationDataSourceSelectionWidget::NavigationToolSelected(int selection)
 {
   emit NavigationToolSelected(this->m_CurrentStorage->GetTool(selection));
 }
 
 void QmitkNavigationDataSourceSelectionWidget::NavigationDataSourceSelected(us::ServiceReferenceU s)
   {
     if (!s) //no device selected
       {
         //reset everything
         m_CurrentSource = NULL;
         m_CurrentStorage = NULL;
         emit NavigationDataSourceSelected(m_CurrentSource);
         return;
       }
 
     // Get Source
     us::ModuleContext* context = us::GetModuleContext();
     m_CurrentSource = context->GetService<mitk::NavigationDataSource>(s);
-    std::string id = s.GetProperty(mitk::NavigationDataSource::US_PROPKEY_ID).ToString();
 
     // clear tool list before filling it
     m_Controls->m_ToolView->clear();
     //Fill tool list
     MITK_INFO<<"no outputs: "<<m_CurrentSource->GetNumberOfOutputs();
     for(std::size_t i = 0; i < m_CurrentSource->GetNumberOfOutputs(); i++)
     {
       new QListWidgetItem(tr(m_CurrentSource->GetOutput(i)->GetName()), m_Controls->m_ToolView);
     }
 
-
-    // Create Filter for ToolStorage
-    std::string filter = "("+ mitk::NavigationToolStorage::US_PROPKEY_SOURCE_ID + "=" + id + ")";
-
     // Get Storage
+    std::string filter = "(" + mitk::NavigationToolStorage::US_PROPKEY_SOURCE_ID + "=" + m_CurrentSource->GetMicroserviceID() + ")";
     std::vector<us::ServiceReference<mitk::NavigationToolStorage> > refs = context->GetServiceReferences<mitk::NavigationToolStorage>(filter);
     if (refs.empty()) return; //no storage was found
     m_CurrentStorage = context->GetService(refs.front());
+
     if (m_CurrentStorage.IsNull())
       {
       MITK_WARN << "Found an invalid storage object!";
       return;
       }
     if (m_CurrentStorage->GetToolCount() != m_CurrentSource->GetNumberOfOutputs()) //there is something wrong with the storage
       {
       MITK_WARN << "Found a tool storage, but it has not the same number of tools like the NavigationDataSource. This storage won't be used because it isn't the right one.";
       m_CurrentStorage = NULL;
       }
 
     emit NavigationDataSourceSelected(m_CurrentSource);
   }
 
 mitk::NavigationDataSource::Pointer QmitkNavigationDataSourceSelectionWidget::GetSelectedNavigationDataSource()
   {
   return this->m_CurrentSource;
   }
 
 
 int QmitkNavigationDataSourceSelectionWidget::GetSelectedToolID()
   {
     return this->m_Controls->m_ToolView->currentIndex().row();
   }
 
 
 mitk::NavigationTool::Pointer QmitkNavigationDataSourceSelectionWidget::GetSelectedNavigationTool()
   {
     if (this->m_CurrentStorage.IsNull()) return NULL;
     if (m_Controls->m_ToolView->currentIndex().row() >= m_CurrentStorage->GetToolCount()) return NULL;
     return this->m_CurrentStorage->GetTool(m_Controls->m_ToolView->currentIndex().row());
   }
 
 
 mitk::NavigationToolStorage::Pointer QmitkNavigationDataSourceSelectionWidget::GetNavigationToolStorageOfSource()
   {
     return this->m_CurrentStorage;
   }
diff --git a/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.cpp
index 1196c0c290..0814f5f480 100644
--- a/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.cpp
@@ -1,271 +1,275 @@
 /*===================================================================
 
 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 "QmitkPolhemusTrackerWidget.h"
 
 #include <QFileDialog>
 #include <QScrollBar>
 #include <QMessageBox>
 
 #include <itksys/SystemTools.hxx>
 #include <Poco/Path.h>
 #include <QSettings>
 
 #include <mitkBaseRenderer.h>
 #include <mitkCameraController.h>
 #include "vtkRenderer.h"
 #include "vtkCamera.h"
 
 const std::string QmitkPolhemusTrackerWidget::VIEW_ID = "org.mitk.views.PolhemusTrackerWidget";
 
 QmitkPolhemusTrackerWidget::QmitkPolhemusTrackerWidget(QWidget* parent, Qt::WindowFlags f)
   : QmitkAbstractTrackingDeviceWidget(parent, f)
   , m_Controls(nullptr)
 {
 }
 void QmitkPolhemusTrackerWidget::Initialize()
 {
   InitializeSuperclassWidget();
   CreateQtPartControl(this);
 
   SetAdvancedSettingsEnabled(false);
   on_m_AdvancedSettings_clicked(); //hide advanced settings on setup
 }
 
 QmitkPolhemusTrackerWidget::~QmitkPolhemusTrackerWidget()
 {
   delete m_Controls;
 }
 
 void QmitkPolhemusTrackerWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkPolhemusTrackerWidget;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkPolhemusTrackerWidget::OnToolStorageChanged()
 {
     this->m_TrackingDevice = nullptr;
     MITK_DEBUG<<"Resetting Polhemus Tracking Device, because tool storage changed.";
 }
 
 void QmitkPolhemusTrackerWidget::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject*)(m_Controls->m_hemisphereTracking), SIGNAL(clicked()), this, SLOT(on_m_hemisphereTracking_clicked()));
     connect((QObject*)(m_Controls->m_ToggleHemisphere), SIGNAL(clicked()), this, SLOT(on_m_ToggleHemisphere_clicked()));
     connect((QObject*)(m_Controls->m_SetHemisphere), SIGNAL(clicked()), this, SLOT(on_m_SetHemisphere_clicked()));
     connect((QObject*)(m_Controls->m_GetHemisphere), SIGNAL(clicked()), this, SLOT(on_m_GetHemisphere_clicked()));
     connect((QObject*)(m_Controls->m_AdjustHemisphere), SIGNAL(clicked()), this, SLOT(on_m_AdjustHemisphere_clicked()));
     connect((QObject*)(m_Controls->m_AdvancedSettings), SIGNAL(clicked()), this, SLOT(on_m_AdvancedSettings_clicked()));
   }
 }
 
 mitk::TrackingDevice::Pointer QmitkPolhemusTrackerWidget::GetTrackingDevice()
 {
   if (m_TrackingDevice.IsNull())
   {
     m_TrackingDevice = mitk::PolhemusTrackingDevice::New();
     m_TrackingDevice->SetHemisphereTrackingEnabled(m_Controls->m_hemisphereTracking->isChecked());
   }
 
   return static_cast<mitk::TrackingDevice::Pointer>(m_TrackingDevice);
 }
 
 QmitkPolhemusTrackerWidget* QmitkPolhemusTrackerWidget::Clone(QWidget* parent) const
 {
   QmitkPolhemusTrackerWidget* clonedWidget = new QmitkPolhemusTrackerWidget(parent);
   clonedWidget->Initialize();
   return clonedWidget;
 }
 
 void QmitkPolhemusTrackerWidget::on_m_hemisphereTracking_clicked()
 {
   m_TrackingDevice->SetHemisphereTrackingEnabled(m_Controls->m_hemisphereTracking->isChecked());
 }
 
 void QmitkPolhemusTrackerWidget::on_m_ToggleHemisphere_clicked()
 {
   // Index 0 == All Tools == -1 for Polhemus interface; Index 2 == Tool 2 == 1 for Polhemus; etc...
   m_TrackingDevice->ToggleHemisphere(GetSelectedToolIndex());
 
   MITK_INFO << "Toggle Hemisphere for tool " << m_Controls->m_ToolSelection->currentText().toStdString();
 }
 
 void QmitkPolhemusTrackerWidget::on_m_SetHemisphere_clicked()
 {
   mitk::Vector3D _hemisphere;
   mitk::FillVector3D(_hemisphere, m_Controls->m_Hemisphere_X->value(), m_Controls->m_Hemisphere_Y->value(), m_Controls->m_Hemisphere_Z->value());
   m_TrackingDevice->SetHemisphere(GetSelectedToolIndex(), _hemisphere);
 
   //If you set a hemisphere vector which is unequal (0|0|0), this means, that there is no hemisphere tracking any more
   //disable the checkbox in case it was on before, so that it can be reactivated...
   if (_hemisphere.GetNorm() != 0)
     m_Controls->m_hemisphereTracking->setChecked(false);
 
   MITK_INFO << "Hemisphere set for tool " << m_Controls->m_ToolSelection->currentText().toStdString();
 }
 
 void QmitkPolhemusTrackerWidget::on_m_GetHemisphere_clicked()
 {
   mitk::Vector3D _hemisphere = m_TrackingDevice->GetHemisphere(GetSelectedToolIndex());
   m_Controls->m_Hemisphere_X->setValue(_hemisphere[0]);
   m_Controls->m_Hemisphere_Y->setValue(_hemisphere[1]);
   m_Controls->m_Hemisphere_Z->setValue(_hemisphere[2]);
 
   QString label;
 
   if (m_TrackingDevice->GetHemisphereTrackingEnabled(GetSelectedToolIndex()))
   {
     label = "HemisphereTracking is ON for tool ";
     label.append(m_Controls->m_ToolSelection->currentText());
   }
+  else if (GetSelectedToolIndex() == -1)
+  {
+    label = "HemisphereTracking is OFF for at least one tool.";
+  }
   else
   {
     label = "HemisphereTracking is OFF for tool ";
     label.append(m_Controls->m_ToolSelection->currentText());
   }
 
   m_Controls->m_StatusLabelHemisphereTracking->setText(label);
 
   MITK_INFO << "Updated SpinBox for Hemisphere of tool " << m_Controls->m_ToolSelection->currentText().toStdString();
 }
 
 void QmitkPolhemusTrackerWidget::on_m_AdjustHemisphere_clicked()
 {
   int _tool = GetSelectedToolIndex();
   QMessageBox msgBox;
   QString _text;
   if (_tool == -1)
   {
     _text.append("Adjusting hemisphere for all tools.");
     msgBox.setText(_text);
     _text.clear();
     _text = tr("Please make sure, that the entire tools (including tool tip AND sensor) are placed in the positive x hemisphere. Press 'Adjust hemisphere' if you are ready.");
     msgBox.setInformativeText(_text);
   }
   else
   {
     _text.append("Adjusting hemisphere for tool '");
     _text.append(m_Controls->m_ToolSelection->currentText());
     _text.append(tr("' at port %2.").arg(_tool));
     msgBox.setText(_text);
     _text.clear();
     _text = tr("Please make sure, that the entire tool (including tool tip AND sensor) is placed in the positive x hemisphere. Press 'Adjust hemisphere' if you are ready.");
     msgBox.setInformativeText(_text);
   }
 
   QPushButton *adjustButton = msgBox.addButton(tr("Adjust hemisphere"), QMessageBox::ActionRole);
   QPushButton *cancelButton = msgBox.addButton(QMessageBox::Cancel);
   msgBox.exec();
   if (msgBox.clickedButton() == adjustButton) {
     // adjust
     m_TrackingDevice->AdjustHemisphere(_tool);
     MITK_INFO << "Adjusting Hemisphere for tool " << m_Controls->m_ToolSelection->currentText().toStdString();
   }
   else if (msgBox.clickedButton() == cancelButton) {
     // abort
     MITK_INFO << "Cancel 'Adjust hemisphere'. No harm done...";
   }
 }
 
 void QmitkPolhemusTrackerWidget::OnConnected(bool _success)
 {
   if (!_success)
   {
     this->m_TrackingDevice = nullptr;
     return;
   }
 
   SetAdvancedSettingsEnabled(true);
 
   if (m_TrackingDevice->GetToolCount() != m_Controls->m_ToolSelection->count())
   {
     m_Controls->m_ToolSelection->clear();
 
     m_Controls->m_ToolSelection->addItem("All Tools");
 
     for (int i = 0; i < m_TrackingDevice->GetToolCount(); ++i)
     {
       m_Controls->m_ToolSelection->addItem(m_TrackingDevice->GetTool(i)->GetToolName());
     }
   }
 }
 
 void QmitkPolhemusTrackerWidget::OnStartTracking(bool _success)
 {
   if (!_success)
     return;
   //Rotate mitk standard multi widget, so that the view matches the sensor. Positive x == right, y == front, z == down;
   mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetCameraController()->SetViewToPosterior();
   mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetVtkRenderer()->GetActiveCamera()->SetViewUp(0, 0, -1);
 
 }
 
 void QmitkPolhemusTrackerWidget::OnDisconnected(bool _success)
 {
   if (!_success)
     return;
   SetAdvancedSettingsEnabled(false);
 }
 
 void QmitkPolhemusTrackerWidget::SetAdvancedSettingsEnabled(bool _enable)
 {
   m_Controls->m_ToolSelection->setEnabled(_enable);
   m_Controls->label_toolsToChange->setEnabled(_enable);
   m_Controls->label_UpdateOnRequest->setEnabled(_enable);
   m_Controls->m_GetHemisphere->setEnabled(_enable);
   m_Controls->m_Hemisphere_X->setEnabled(_enable);
   m_Controls->m_Hemisphere_Y->setEnabled(_enable);
   m_Controls->m_Hemisphere_Z->setEnabled(_enable);
   m_Controls->m_SetHemisphere->setEnabled(_enable);
   m_Controls->m_ToggleHemisphere->setEnabled(_enable);
   m_Controls->m_AdjustHemisphere->setEnabled(_enable);
 }
 
 void QmitkPolhemusTrackerWidget::on_m_AdvancedSettings_clicked()
 {
   bool _enable = m_Controls->m_AdvancedSettings->isChecked();
   m_Controls->m_ToolSelection->setVisible(_enable);
   m_Controls->label_toolsToChange->setVisible(_enable);
   m_Controls->label_UpdateOnRequest->setVisible(_enable);
   m_Controls->m_GetHemisphere->setVisible(_enable);
   m_Controls->m_Hemisphere_X->setVisible(_enable);
   m_Controls->m_Hemisphere_Y->setVisible(_enable);
   m_Controls->m_Hemisphere_Z->setVisible(_enable);
   m_Controls->m_SetHemisphere->setVisible(_enable);
   m_Controls->m_ToggleHemisphere->setVisible(_enable);
   m_Controls->m_AdjustHemisphere->setVisible(_enable);
   m_Controls->m_StatusLabelHemisphereTracking->setVisible(_enable);
 }
 
 int QmitkPolhemusTrackerWidget::GetSelectedToolIndex()
 {
   // Index 0 == All Tools == -1 for Polhemus interface; Index 1 == Tool 1 == 1 for Polhemus Interface; etc...
   int _index = m_Controls->m_ToolSelection->currentIndex() - 1;
   if (_index != -1)
   {
     //we need to find the internal Polhemus index for this tool. This is stored in the identifier of a navigation tool or as Port in PolhemusTool.
     mitk::PolhemusTool* _tool = dynamic_cast<mitk::PolhemusTool*>(m_TrackingDevice->GetToolByName(m_Controls->m_ToolSelection->currentText().toStdString()));
     _index = _tool->GetToolPort();
   }
   return _index;
 }
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp
index f3205dd8f2..89b4fa4ec5 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp
@@ -1,79 +1,79 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkMITKIGTNavigationToolManagerView.h"
 #include "QmitkStdMultiWidget.h"
 
 // MITK
 #include <usGetModuleContext.h>
 
 // Qt
 #include <QMessageBox>
 
 const std::string QmitkMITKIGTNavigationToolManagerView::VIEW_ID = "org.mitk.views.mitkigtnavigationtoolmanager";
 
 QmitkMITKIGTNavigationToolManagerView::QmitkMITKIGTNavigationToolManagerView()
   : QmitkAbstractView()
   , m_Controls(0)
 {
 }
 
 QmitkMITKIGTNavigationToolManagerView::~QmitkMITKIGTNavigationToolManagerView()
 {
   for (int i = 0; i < m_AllStoragesHandledByThisWidget.size(); i++)
     m_AllStoragesHandledByThisWidget.at(i)->UnRegisterMicroservice();
 }
 
 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);
     connect((QObject*)(m_Controls->m_toolManagerWidget), SIGNAL(NewStorageAdded(mitk::NavigationToolStorage::Pointer, std::string)), this, SLOT(NewStorageByWidget(mitk::NavigationToolStorage::Pointer, std::string)));
     connect((QObject*)(m_Controls->m_ToolStorageListWidget), SIGNAL(NavigationToolStorageSelected(mitk::NavigationToolStorage::Pointer)), this, SLOT(ToolStorageSelected(mitk::NavigationToolStorage::Pointer)));
   }
   m_Controls->m_toolManagerWidget->Initialize(this->GetDataStorage());
 }
 
 void QmitkMITKIGTNavigationToolManagerView::SetFocus()
 {
   m_Controls->m_ToolStorageListWidget->setFocus();
 }
 
 void QmitkMITKIGTNavigationToolManagerView::NewStorageByWidget(mitk::NavigationToolStorage::Pointer storage, std::string storageName)
 {
-  storage->RegisterAsMicroservice(storageName);
+  storage->RegisterAsMicroservice();
   m_AllStoragesHandledByThisWidget.push_back(storage);
 }
 
 void QmitkMITKIGTNavigationToolManagerView::ToolStorageSelected(mitk::NavigationToolStorage::Pointer storage)
 {
   if (storage.IsNull()) //no storage selected
   {
     //reset everything
     return;
   }
 
   this->m_Controls->m_toolManagerWidget->LoadStorage(storage);
 }
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
index bf0f822d00..60e73fd5f7 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
@@ -1,1257 +1,1263 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkMITKIGTTrackingToolboxView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 #include <QSettings>
 #include <qfiledialog.h>
 
 // MITK
 #include <mitkNavigationToolStorageDeserializer.h>
 #include <mitkTrackingVolumeGenerator.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNavigationToolStorageSerializer.h>
 #include <mitkIOUtil.h>
 #include <mitkLog.h>
 #include <mitkTrackingDeviceTypeCollection.h>
 #include <mitkUnspecifiedTrackingTypeInformation.h>
 
 //for exceptions
 #include <mitkIGTException.h>
 #include <mitkIGTIOException.h>
 
 #include "mitkPluginActivator.h"
 
 const std::string QmitkMITKIGTTrackingToolboxView::VIEW_ID = "org.mitk.views.mitkigttrackingtoolbox";
 
 QmitkMITKIGTTrackingToolboxView::QmitkMITKIGTTrackingToolboxView()
   : QmitkFunctionality()
   , m_Controls(nullptr)
   , m_MultiWidget(nullptr)
   , m_DeviceTypeCollection(nullptr)
 {
   m_TrackingLoggingTimer = new QTimer(this);
   m_TrackingRenderTimer = new QTimer(this);
   m_TimeoutTimer = new QTimer(this);
   m_tracking = false;
   m_connected = false;
   m_logging = false;
   m_loggedFrames = 0;
   m_SimpleModeEnabled = false;
 
   //create filename for autosaving of tool storage
   QString loggingPathWithoutFilename = QString(mitk::LoggingBackend::GetLogFile().c_str());
   if (!loggingPathWithoutFilename.isEmpty()) //if there already is a path for the MITK logging file use this one
   {
     //extract path from path+filename (if someone knows a better way to do this feel free to change it)
     int lengthOfFilename = QFileInfo(QString::fromStdString(mitk::LoggingBackend::GetLogFile())).fileName().size();
     loggingPathWithoutFilename.resize(loggingPathWithoutFilename.size() - lengthOfFilename);
     m_AutoSaveFilename = loggingPathWithoutFilename + "TrackingToolboxAutoSave.IGTToolStorage";
   }
   else //if not: use a temporary path from IOUtil
   {
     m_AutoSaveFilename = QString(mitk::IOUtil::GetTempPath().c_str()) + "TrackingToolboxAutoSave.IGTToolStorage";
   }
   MITK_INFO("IGT Tracking Toolbox") << "Filename for auto saving of IGT ToolStorages: " << m_AutoSaveFilename.toStdString();
 
   //! [Thread 1]
   //initialize worker thread
   m_WorkerThread = new QThread();
   m_Worker = new QmitkMITKIGTTrackingToolboxViewWorker();
   //! [Thread 1]
 
   ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
   if (pluginContext)
   {
     QString interfaceName = QString::fromStdString(us_service_interface_iid<mitk::TrackingDeviceTypeCollection>());
     QList<ctkServiceReference> serviceReference = pluginContext->getServiceReferences(interfaceName);
 
     if (serviceReference.size() > 0)
     {
       m_DeviceTypeServiceReference = serviceReference.at(0);
       const ctkServiceReference& r = serviceReference.at(0);
       m_DeviceTypeCollection = pluginContext->getService<mitk::TrackingDeviceTypeCollection>(r);
     }
     else
     {
       MITK_INFO << "No Tracking Device Collection!";
     }
   }
 }
 
 QmitkMITKIGTTrackingToolboxView::~QmitkMITKIGTTrackingToolboxView()
 {
   this->StoreUISettings();
   m_TrackingLoggingTimer->stop();
   m_TrackingRenderTimer->stop();
   m_TimeoutTimer->stop();
   delete m_TrackingLoggingTimer;
   delete m_TrackingRenderTimer;
   delete m_TimeoutTimer;
   try
   {
     //! [Thread 2]
     // wait for thread to finish
     m_WorkerThread->terminate();
     m_WorkerThread->wait();
     //clean up worker thread
     if (m_WorkerThread) { delete m_WorkerThread; }
     if (m_Worker) { delete m_Worker; }
     //! [Thread 2]
 
     //remove the tracking volume
     this->GetDataStorage()->Remove(m_TrackingVolumeNode);
     //unregister microservices
     if (m_toolStorage) { m_toolStorage->UnRegisterMicroservice(); }
 
     if (m_IGTLMessageProvider.IsNotNull()){ m_IGTLMessageProvider->UnRegisterMicroservice(); }
   }
   catch (std::exception& e) { MITK_WARN << "Unexpected exception during clean up of tracking toolbox view: " << e.what(); }
   catch (...) { MITK_WARN << "Unexpected unknown error during clean up of tracking toolbox view!"; }
   //store tool storage and UI settings for persistence
   this->AutoSaveToolStorage();
   this->StoreUISettings();
 
   m_DeviceTypeCollection = nullptr;
   mitk::PluginActivator::GetContext()->ungetService(m_DeviceTypeServiceReference);
 }
 
 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_ConnectDisconnectButton, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
     connect(m_Controls->m_StartStopTrackingButton, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
     connect(m_Controls->m_ConnectSimpleMode, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
     connect(m_Controls->m_StartTrackingSimpleMode, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
     connect(m_Controls->m_FreezeUnfreezeTrackingButton, SIGNAL(clicked()), this, SLOT(OnFreezeUnfreezeTracking()));
     connect(m_TrackingLoggingTimer, SIGNAL(timeout()), this, SLOT(UpdateLoggingTrackingTimer()));
     connect(m_TrackingRenderTimer, SIGNAL(timeout()), this, SLOT(UpdateRenderTrackingTimer()));
     connect(m_TimeoutTimer, SIGNAL(timeout()), this, SLOT(OnTimeOut()));
     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_VolumeSelectionBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(OnTrackingVolumeChanged(QString)));
     connect(m_Controls->m_ShowTrackingVolume, SIGNAL(clicked()), this, SLOT(OnShowTrackingVolumeChanged()));
     connect(m_Controls->m_AutoDetectTools, SIGNAL(clicked()), this, SLOT(OnAutoDetectTools()));
     connect(m_Controls->m_ResetTools, SIGNAL(clicked()), this, SLOT(OnResetTools()));
     connect(m_Controls->m_AddSingleTool, SIGNAL(clicked()), this, SLOT(OnAddSingleTool()));
     connect(m_Controls->m_NavigationToolCreationWidget, SIGNAL(NavigationToolFinished()), this, SLOT(OnAddSingleToolFinished()));
     connect(m_Controls->m_NavigationToolCreationWidget, SIGNAL(Canceled()), this, SLOT(OnAddSingleToolCanceled()));
     connect(m_Controls->m_csvFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
     connect(m_Controls->m_xmlFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
     connect(m_Controls->m_UseDifferentUpdateRates, SIGNAL(clicked()), this, SLOT(OnToggleDifferentUpdateRates()));
     connect(m_Controls->m_RenderUpdateRate, SIGNAL(valueChanged(int)), this, SLOT(OnChangeRenderUpdateRate()));
     connect(m_Controls->m_DisableAllTimers, SIGNAL(stateChanged(int)), this, SLOT(EnableDisableTimerButtons(int)));
     connect(m_Controls->m_advancedUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
     connect(m_Controls->m_simpleUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
 
     //connections for the tracking device configuration widget
     connect(m_Controls->m_configurationWidget, SIGNAL(TrackingDeviceSelectionChanged()), this, SLOT(OnTrackingDeviceChanged()));
 
 
     //! [Thread 3]
     //connect worker thread
     connect(m_Worker, SIGNAL(AutoDetectToolsFinished(bool, QString)), this, SLOT(OnAutoDetectToolsFinished(bool, QString)));
     connect(m_Worker, SIGNAL(ConnectDeviceFinished(bool, QString)), this, SLOT(OnConnectFinished(bool, QString)));
     connect(m_Worker, SIGNAL(StartTrackingFinished(bool, QString)), this, SLOT(OnStartTrackingFinished(bool, QString)));
     connect(m_Worker, SIGNAL(StopTrackingFinished(bool, QString)), this, SLOT(OnStopTrackingFinished(bool, QString)));
     connect(m_Worker, SIGNAL(DisconnectDeviceFinished(bool, QString)), this, SLOT(OnDisconnectFinished(bool, QString)));
     connect(m_WorkerThread, SIGNAL(started()), m_Worker, SLOT(ThreadFunc()));
 
     connect(m_Worker, SIGNAL(ConnectDeviceFinished(bool, QString)), m_Controls->m_configurationWidget, SLOT(OnConnected(bool)));
     connect(m_Worker, SIGNAL(DisconnectDeviceFinished(bool, QString)), m_Controls->m_configurationWidget, SLOT(OnDisconnected(bool)));
     connect(m_Worker, SIGNAL(StartTrackingFinished(bool, QString)), m_Controls->m_configurationWidget, SLOT(OnStartTracking(bool)));
     connect(m_Worker, SIGNAL(StopTrackingFinished(bool, QString)), m_Controls->m_configurationWidget, SLOT(OnStopTracking(bool)));
 
 
     //Add Listener, so that we know when the toolStorage changed.
     std::string m_Filter = "(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.NavigationToolStorage" + ")";
     mitk::PluginActivator::GetContext()->connectServiceListener(this, "OnToolStorageChanged", QString(m_Filter.c_str()));
 
     //move the worker to the thread
     m_Worker->moveToThread(m_WorkerThread);
     //! [Thread 3]
 
     //initialize widgets
     m_Controls->m_TrackingToolsStatusWidget->SetShowPositions(true);
     m_Controls->m_TrackingToolsStatusWidget->SetTextAlignment(Qt::AlignLeft);
     m_Controls->m_simpleWidget->setVisible(false);
 
     //initialize tracking volume node
     m_TrackingVolumeNode = mitk::DataNode::New();
     m_TrackingVolumeNode->SetName("TrackingVolume");
     m_TrackingVolumeNode->SetBoolProperty("Backface Culling", true);
     mitk::Color red;
     red.SetRed(1);
     m_TrackingVolumeNode->SetColor(red);
 
     //initialize buttons
     m_Controls->m_AutoDetectTools->setVisible(false); //only visible if supported by tracking device
     m_Controls->m_StartStopTrackingButton->setEnabled(false);
     m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
     m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
 
     //initialize warning labels
     m_Controls->m_renderWarningLabel->setVisible(false);
     m_Controls->m_TrackingFrozenLabel->setVisible(false);
 
     //Update List of available models for selected tool.
     std::vector<mitk::TrackingDeviceData> Compatibles;
     if ((m_Controls == NULL) || //check all these stuff for NULL, latterly this causes crashes from time to time
       (m_Controls->m_configurationWidget == NULL) ||
       (m_Controls->m_configurationWidget->GetTrackingDevice().IsNull()))
     {
       MITK_ERROR << "Couldn't get current tracking device or an object is NULL, something went wrong!";
       return;
     }
     else
     {
       Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(m_Controls->m_configurationWidget->GetTrackingDevice()->GetType());
     }
     m_Controls->m_VolumeSelectionBox->clear();
     for (std::size_t i = 0; i < Compatibles.size(); i++)
     {
       m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
     }
 
     //initialize tool storage
     m_toolStorage = mitk::NavigationToolStorage::New(GetDataStorage());
     m_toolStorage->SetName("TrackingToolbox Default Storage");
-    m_toolStorage->RegisterAsMicroservice("no tracking device");
+    m_toolStorage->RegisterAsMicroservice();
 
     //set home directory as default path for logfile
     m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(QDir::homePath()) + QDir::separator() + "logfile.csv");
 
     //tracking device may be changed already by the persistence of the
     //QmitkTrackingDeciveConfigurationWidget
     this->OnTrackingDeviceChanged();
 
     this->LoadUISettings();
 
     //add tracking volume node only to data storage
     this->GetDataStorage()->Add(m_TrackingVolumeNode);
     if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
     else m_TrackingVolumeNode->SetOpacity(0.25);
 
     //Update List of available models for selected tool.
     m_Controls->m_VolumeSelectionBox->clear();
     for (std::size_t i = 0; i < Compatibles.size(); i++)
     {
       m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
     }
   }
 }
 
 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 Tool Storage"), "/", tr("Tool Storage Files (*.IGTToolStorage)"));
   if (filename.isNull()) return;
 
   //read tool storage from disk
   std::string errorMessage = "";
   mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
   // try-catch block for exceptions
   try
   {
     this->ReplaceCurrentToolStorage(myDeserializer->Deserialize(filename.toStdString()), filename.toStdString());
   }
   catch (mitk::IGTException)
   {
     std::string errormessage = "Error during loading the tool storage file. Please only load tool storage files created with the NavigationToolManager view.";
     QMessageBox::warning(NULL, "Tool Storage Loading Error", errormessage.c_str());
     return;
   }
 
   if (m_toolStorage->isEmpty())
   {
     errorMessage = myDeserializer->GetErrorMessage();
     MessageBox(errorMessage);
     return;
   }
 
   //update label
   UpdateToolStorageLabel(filename);
 
   //update tool preview
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
 
   //save filename for persistent storage
   m_ToolStorageFilename = filename;
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnResetTools()
 {
   this->ReplaceCurrentToolStorage(mitk::NavigationToolStorage::New(GetDataStorage()), "TrackingToolbox Default Storage");
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   QString toolLabel = QString("<none>");
   m_Controls->m_toolLabel->setText(toolLabel);
   m_ToolStorageFilename = "";
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStartStopTracking()
 {
   if (!m_connected)
   {
     MITK_WARN << "Can't start tracking if no device is connected. Aborting";
     return;
   }
   if (m_tracking) { OnStopTracking(); }
   else { OnStartTracking(); }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnFreezeUnfreezeTracking()
 {
   if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Freeze Tracking")
   {
     m_Worker->GetTrackingDeviceSource()->Freeze();
     m_Controls->m_FreezeUnfreezeTrackingButton->setText("Unfreeze Tracking");
     m_Controls->m_TrackingFrozenLabel->setVisible(true);
   }
   else if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Unfreeze Tracking")
   {
     m_Worker->GetTrackingDeviceSource()->UnFreeze();
     m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
     m_Controls->m_TrackingFrozenLabel->setVisible(false);
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnConnectDisconnect()
 {
   if (m_connected) { OnDisconnect(); }
   else { OnConnect(); }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnConnect()
 {
   MITK_DEBUG << "Connect Clicked";
   //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;
   }
 
   //parse tracking device data
   mitk::TrackingDeviceData data = mitk::UnspecifiedTrackingTypeInformation::GetDeviceDataUnspecified();
   QString qstr = m_Controls->m_VolumeSelectionBox->currentText();
   if ((!qstr.isNull()) || (!qstr.isEmpty())) {
     std::string str = qstr.toStdString();
     data = m_DeviceTypeCollection->GetDeviceDataByName(str); //Data will be set later, after device generation
   }
 
   //! [Thread 4]
   //initialize worker thread
   m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eConnectDevice);
   m_Worker->SetTrackingDevice(this->m_Controls->m_configurationWidget->GetTrackingDevice());
   m_Worker->SetInverseMode(m_Controls->m_InverseMode->isChecked());
   m_Worker->SetNavigationToolStorage(this->m_toolStorage);
   m_Worker->SetTrackingDeviceData(data);
   //start worker thread
   m_WorkerThread->start();
   //! [Thread 4]
 
   //disable buttons
   this->m_Controls->m_MainWidget->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableDisableTimerButtons(int enable)
 {
   bool enableBool = enable;
   m_Controls->m_UpdateRateOptionsGroupBox->setEnabled(!enableBool);
   m_Controls->m_renderWarningLabel->setVisible(enableBool);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnConnectFinished(bool success, QString errorMessage)
 {
   m_WorkerThread->quit();
   m_WorkerThread->wait();
 
   //enable buttons
   this->m_Controls->m_MainWidget->setEnabled(true);
 
   if (!success)
   {
     MITK_WARN << errorMessage.toStdString();
     MessageBox(errorMessage.toStdString());
     return;
   }
 
   //! [Thread 6]
   //get data from worker thread
   m_TrackingDeviceData = m_Worker->GetTrackingDeviceData();
   m_ToolVisualizationFilter = m_Worker->GetToolVisualizationFilter();
   //! [Thread 6]
 
   //enable/disable Buttons
   DisableOptionsButtons();
   DisableTrackingConfigurationButtons();
 
   m_Controls->m_TrackingControlLabel->setText("Status: connected");
   m_Controls->m_ConnectDisconnectButton->setText("Disconnect");
   m_Controls->m_ConnectSimpleMode->setText("Disconnect");
   m_Controls->m_StartStopTrackingButton->setEnabled(true);
   m_Controls->m_StartTrackingSimpleMode->setEnabled(true);
   m_connected = true;
+
+  //During connection, thi sourceID of the tool storage changed. However, Microservice can't be updated on a different thread.
+  //UpdateMicroservice is necessary to use filter to get the right storage belonging to a source.
+  //Don't do it before m_connected is true, as we don't want to call content of OnToolStorageChanged.
+  m_toolStorage->UpdateMicroservice();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnDisconnect()
 {
   m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eDisconnectDevice);
   m_WorkerThread->start();
   m_Controls->m_MainWidget->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnDisconnectFinished(bool success, QString errorMessage)
 {
   m_WorkerThread->quit();
   m_WorkerThread->wait();
   m_Controls->m_MainWidget->setEnabled(true);
 
   if (!success)
   {
     MITK_WARN << errorMessage.toStdString();
     MessageBox(errorMessage.toStdString());
     return;
   }
 
   //enable/disable Buttons
   m_Controls->m_StartStopTrackingButton->setEnabled(false);
   m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
   EnableOptionsButtons();
   EnableTrackingConfigurationButtons();
   m_Controls->m_TrackingControlLabel->setText("Status: disconnected");
   m_Controls->m_ConnectDisconnectButton->setText("Connect");
   m_Controls->m_ConnectSimpleMode->setText("Connect");
   m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
   m_Controls->m_TrackingFrozenLabel->setVisible(false);
   m_connected = false;
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStartTracking()
 {
   //show tracking volume
   this->OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
   //Reset the view to a defined start. Do it here and not in OnStartTrackingFinished, to give other tracking devices the chance to reset the view to a different direction.
   this->GlobalReinit();
   m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStartTracking);
   m_WorkerThread->start();
   this->m_Controls->m_MainWidget->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStartTrackingFinished(bool success, QString errorMessage)
 {
   //! [Thread 5]
   m_WorkerThread->quit();
   m_WorkerThread->wait();
   //! [Thread 5]
   this->m_Controls->m_MainWidget->setEnabled(true);
 
   if (!success)
   {
     MessageBox(errorMessage.toStdString());
     MITK_WARN << errorMessage.toStdString();
     return;
   }
 
   if (!(m_Controls->m_DisableAllTimers->isChecked()))
   {
     if (m_Controls->m_UseDifferentUpdateRates->isChecked())
     {
       if (m_Controls->m_RenderUpdateRate->value() != 0)
         m_TrackingRenderTimer->start(1000 / (m_Controls->m_RenderUpdateRate->value()));
       m_TrackingLoggingTimer->start(1000 / (m_Controls->m_LogUpdateRate->value()));
     }
     else
     {
       m_TrackingRenderTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
       m_TrackingLoggingTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
     }
   }
 
   m_Controls->m_TrackingControlLabel->setText("Status: tracking");
 
   //connect the tool visualization widget
   for (std::size_t i = 0; i < m_Worker->GetTrackingDeviceSource()->GetNumberOfOutputs(); i++)
   {
     m_Controls->m_TrackingToolsStatusWidget->AddNavigationData(m_Worker->GetTrackingDeviceSource()->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); }
 
   //if activated enable open IGT link microservice
   if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
   {
     //create convertion filter
     m_IGTLConversionFilter = mitk::NavigationDataToIGTLMessageFilter::New();
     m_IGTLConversionFilter->SetName("IGT Tracking Toolbox");
     QString dataModeSelection = this->m_Controls->m_OpenIGTLinkDataFormat->currentText();
     if (dataModeSelection == "TDATA")
     {
       m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendTDataMsg);
     }
     else if (dataModeSelection == "TRANSFORM")
     {
       m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendTransMsg);
     }
     else if (dataModeSelection == "QTDATA")
     {
       m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendQTDataMsg);
     }
     else if (dataModeSelection == "POSITION")
     {
       m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendQTransMsg);
     }
     m_IGTLConversionFilter->ConnectTo(m_ToolVisualizationFilter);
     m_IGTLConversionFilter->RegisterAsMicroservice();
 
     //create server and message provider
     m_IGTLServer = mitk::IGTLServer::New(false);
     m_IGTLServer->SetName("Tracking Toolbox IGTL Server");
     m_IGTLMessageProvider = mitk::IGTLMessageProvider::New();
     m_IGTLMessageProvider->SetIGTLDevice(m_IGTLServer);
     m_IGTLMessageProvider->RegisterAsMicroservice();
   }
 
   m_tracking = true;
   m_Controls->m_ConnectDisconnectButton->setEnabled(false);
   m_Controls->m_StartStopTrackingButton->setText("Stop Tracking");
   m_Controls->m_StartTrackingSimpleMode->setText("Stop\nTracking");
   m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStopTracking()
 {
   if (!m_tracking) return;
   m_TrackingRenderTimer->stop();
   m_TrackingLoggingTimer->stop();
 
   m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStopTracking);
   m_WorkerThread->start();
   m_Controls->m_MainWidget->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStopTrackingFinished(bool success, QString errorMessage)
 {
   m_WorkerThread->quit();
   m_WorkerThread->wait();
   m_Controls->m_MainWidget->setEnabled(true);
   if (!success)
   {
     MessageBox(errorMessage.toStdString());
     MITK_WARN << errorMessage.toStdString();
     return;
   }
 
   m_Controls->m_TrackingControlLabel->setText("Status: connected");
   if (m_logging) StopLogging();
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
   m_tracking = false;
   m_Controls->m_StartStopTrackingButton->setText("Start Tracking");
   m_Controls->m_StartTrackingSimpleMode->setText("Start\nTracking");
   m_Controls->m_ConnectDisconnectButton->setEnabled(true);
   m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
 
   //unregister open IGT link micro service
   if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
   {
     m_IGTLConversionFilter->UnRegisterMicroservice();
     m_IGTLMessageProvider->UnRegisterMicroservice();
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnTrackingDeviceChanged()
 {
   mitk::TrackingDeviceType Type;
 
   if (m_Controls->m_configurationWidget->GetTrackingDevice().IsNotNull())
   {
     Type = m_Controls->m_configurationWidget->GetTrackingDevice()->GetType();
     //enable controls because device is valid
     m_Controls->m_TrackingToolsGoupBox->setEnabled(true);
     m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
   }
   else
   {
     Type = mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName();
     MessageBox("Error: This tracking device is not included in this project. Please make sure that the device is installed and activated in your MITK build.");
     m_Controls->m_TrackingToolsGoupBox->setEnabled(false);
     m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
     return;
   }
 
   // Code to enable/disable device specific buttons
   if (m_Controls->m_configurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
   {
     m_Controls->m_AutoDetectTools->setVisible(true);
   }
   else
   {
     m_Controls->m_AutoDetectTools->setVisible(false);
   }
 
   m_Controls->m_AddSingleTool->setEnabled(this->m_Controls->m_configurationWidget->GetTrackingDevice()->AddSingleToolIsAvailable());
 
   // Code to select appropriate tracking volume for current type
   std::vector<mitk::TrackingDeviceData> Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(Type);
   m_Controls->m_VolumeSelectionBox->clear();
   for (std::size_t i = 0; i < Compatibles.size(); i++)
   {
     m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnTrackingVolumeChanged(QString qstr)
 {
   if (qstr.isNull()) return;
   if (qstr.isEmpty()) return;
 
   mitk::TrackingVolumeGenerator::Pointer volumeGenerator = mitk::TrackingVolumeGenerator::New();
 
   std::string str = qstr.toStdString();
 
   mitk::TrackingDeviceData data = m_DeviceTypeCollection->GetDeviceDataByName(str);
   m_TrackingDeviceData = data;
 
   volumeGenerator->SetTrackingDeviceData(data);
   volumeGenerator->Update();
 
   mitk::Surface::Pointer volumeSurface = volumeGenerator->GetOutput();
 
   m_TrackingVolumeNode->SetData(volumeSurface);
 
   if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
   else m_TrackingVolumeNode->SetOpacity(0.25);
 
   GlobalReinit();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnShowTrackingVolumeChanged()
 {
   if (m_Controls->m_ShowTrackingVolume->isChecked())
   {
     OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
     m_TrackingVolumeNode->SetOpacity(0.25);
   }
   else
   {
     m_TrackingVolumeNode->SetOpacity(0.0);
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAutoDetectTools()
 {
   if (m_Controls->m_configurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
   {
     DisableTrackingConfigurationButtons();
     m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eAutoDetectTools);
     m_Worker->SetTrackingDevice(m_Controls->m_configurationWidget->GetTrackingDevice().GetPointer());
     m_Worker->SetDataStorage(this->GetDataStorage());
     m_WorkerThread->start();
     m_TimeoutTimer->start(7000);
     //disable controls until worker thread is finished
     this->m_Controls->m_MainWidget->setEnabled(false);
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAutoDetectToolsFinished(bool success, QString errorMessage)
 {
   //Check, if the thread is running. There might have been a timeOut inbetween and this causes crashes...
   if (m_WorkerThread->isRunning())
   {
     m_TimeoutTimer->stop();
     m_WorkerThread->quit();
     m_WorkerThread->wait();
   }
 
   //enable controls again
   this->m_Controls->m_MainWidget->setEnabled(true);
   EnableTrackingConfigurationButtons();
 
   if (!success)
   {
     MITK_WARN << errorMessage.toStdString();
     MessageBox(errorMessage.toStdString());
     EnableTrackingConfigurationButtons();
     return;
   }
 
   mitk::NavigationToolStorage::Pointer autoDetectedStorage = m_Worker->GetNavigationToolStorage();
 
   //save detected tools
   std::string _autoDetectText;
   _autoDetectText = "Autodetected ";
   _autoDetectText.append(this->m_TrackingDeviceData.Line); //This is the device name as string of the current TrackingDevice.
   _autoDetectText.append(" Storage");
   this->ReplaceCurrentToolStorage(autoDetectedStorage, _autoDetectText);
   //auto save the new storage to hard disc (for persistence)
   AutoSaveToolStorage();
   //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);
 
   EnableTrackingConfigurationButtons();
 
   //print a logging message about the detected tools
   switch (m_toolStorage->GetToolCount())
   {
   case 0:
     MITK_INFO("IGT Tracking Toolbox") << "Found no tools. Empty ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
     break;
   case 1:
     MITK_INFO("IGT Tracking Toolbox") << "Found one tool. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
     break;
   default:
     MITK_INFO("IGT Tracking Toolbox") << "Found " << m_toolStorage->GetToolCount() << " tools. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::MessageBox(std::string s)
 {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
 }
 
 void QmitkMITKIGTTrackingToolboxView::UpdateRenderTrackingTimer()
 {
   //update filter
   m_ToolVisualizationFilter->Update();
   MITK_DEBUG << "Number of outputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedOutputs();
   MITK_DEBUG << "Number of inputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedInputs();
 
   //update tool colors to show tool status
   for (unsigned int i = 0; i < m_ToolVisualizationFilter->GetNumberOfIndexedOutputs(); i++)
   {
     mitk::NavigationData::Pointer currentTool = m_ToolVisualizationFilter->GetOutput(i);
     if (currentTool->IsDataValid())
     {
       this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_VALID);
     }
     else
     {
       this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_WARNING);
     }
   }
 
   //refresh view and status widget
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   m_Controls->m_TrackingToolsStatusWidget->Refresh();
 }
 
 void QmitkMITKIGTTrackingToolboxView::UpdateLoggingTrackingTimer()
 {
   //update logging
   if (m_logging)
   {
     this->m_loggingFilter->Update();
     m_loggedFrames = this->m_loggingFilter->GetNumberOfRecordedSteps();
     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(); }
   }
   //refresh status widget
   m_Controls->m_TrackingToolsStatusWidget->Refresh();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnChooseFileClicked()
 {
   QDir currentPath = QFileInfo(m_Controls->m_LoggingFileName->text()).dir();
 
   // if no path was selected (QDir would select current working dir then) or the
   // selected path does not exist -> use home directory
   if (currentPath == QDir() || !currentPath.exists())
   {
     currentPath = QDir(QDir::homePath());
   }
 
   QString filename = QFileDialog::getSaveFileName(NULL, tr("Choose Logging File"), currentPath.absolutePath(), "*.*");
   if (filename == "") return;
   this->m_Controls->m_LoggingFileName->setText(filename);
   this->OnToggleFileExtension();
 }
 // bug-16470: toggle file extension after clicking on radio button
 void QmitkMITKIGTTrackingToolboxView::OnToggleFileExtension()
 {
   QString currentInputText = this->m_Controls->m_LoggingFileName->text();
   QString currentFile = QFileInfo(currentInputText).baseName();
   QDir currentPath = QFileInfo(currentInputText).dir();
   if (currentFile.isEmpty())
   {
     currentFile = "logfile";
   }
   // Setting currentPath to default home path when currentPath is empty or it does not exist
   if (currentPath == QDir() || !currentPath.exists())
   {
     currentPath = QDir::homePath();
   }
   // check if csv radio button is clicked
   if (this->m_Controls->m_csvFormat->isChecked())
   {
     // you needn't add a seperator to the input text when currentpath is the rootpath
     if (currentPath.isRoot())
     {
       this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".csv");
     }
 
     else
     {
       this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".csv");
     }
   }
   // check if xml radio button is clicked
   else if (this->m_Controls->m_xmlFormat->isChecked())
   {
     // you needn't add a seperator to the input text when currentpath is the rootpath
     if (currentPath.isRoot())
     {
       this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".xml");
     }
     else
     {
       this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".xml");
     }
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnToggleAdvancedSimpleMode()
 {
   if (m_SimpleModeEnabled)
   {
     m_Controls->m_simpleWidget->setVisible(false);
     m_Controls->m_MainWidget->setVisible(true);
     m_Controls->m_simpleUI->setChecked(false);
     m_SimpleModeEnabled = false;
   }
   else
   {
     m_Controls->m_simpleWidget->setVisible(true);
     m_Controls->m_MainWidget->setVisible(false);
     m_SimpleModeEnabled = true;
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnToggleDifferentUpdateRates()
 {
   if (m_Controls->m_UseDifferentUpdateRates->isChecked())
   {
     if (m_Controls->m_RenderUpdateRate->value() == 0)
       m_Controls->m_renderWarningLabel->setVisible(true);
     else
       m_Controls->m_renderWarningLabel->setVisible(false);
 
     m_Controls->m_UpdateRate->setEnabled(false);
     m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
 
     m_Controls->m_RenderUpdateRate->setEnabled(true);
     m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(true);
 
     m_Controls->m_LogUpdateRate->setEnabled(true);
     m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(true);
   }
 
   else
   {
     m_Controls->m_renderWarningLabel->setVisible(false);
 
     m_Controls->m_UpdateRate->setEnabled(true);
     m_Controls->m_OptionsUpdateRateLabel->setEnabled(true);
 
     m_Controls->m_RenderUpdateRate->setEnabled(false);
     m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
 
     m_Controls->m_LogUpdateRate->setEnabled(false);
     m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnChangeRenderUpdateRate()
 {
   if (m_Controls->m_RenderUpdateRate->value() == 0)
     m_Controls->m_renderWarningLabel->setVisible(true);
   else
     m_Controls->m_renderWarningLabel->setVisible(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::StartLogging()
 {
   if (m_ToolVisualizationFilter.IsNull())
   {
     MessageBox("Cannot activate logging without a connected device. Configure and connect a tracking device first.");
     return;
   }
 
   if (!m_logging)
   {
     //initialize logging filter
     m_loggingFilter = mitk::NavigationDataRecorder::New();
     m_loggingFilter->SetRecordOnlyValidData(m_Controls->m_SkipInvalidData->isChecked());
 
     m_loggingFilter->ConnectTo(m_ToolVisualizationFilter);
 
     if (m_Controls->m_LoggingLimit->isChecked()){ m_loggingFilter->SetRecordCountLimit(m_Controls->m_LoggedFramesLimit->value()); }
 
     //start filter with try-catch block for exceptions
     try
     {
       m_loggingFilter->StartRecording();
     }
     catch (mitk::IGTException)
     {
       std::string errormessage = "Error during start recording. Recorder already started recording?";
       QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
       m_loggingFilter->StopRecording();
       return;
     }
 
     //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)
   {
     //stop logging
     m_loggingFilter->StopRecording();
     m_logging = false;
 
     //update GUI
     this->m_Controls->m_LoggingLabel->setText("Logging OFF");
     EnableLoggingButtons();
 
     //write the results to a file
     if (m_Controls->m_csvFormat->isChecked())
     {
       mitk::IOUtil::SaveBaseData(m_loggingFilter->GetNavigationDataSet(), this->m_Controls->m_LoggingFileName->text().toStdString());
     }
     else if (m_Controls->m_xmlFormat->isChecked())
     {
       mitk::IOUtil::SaveBaseData(m_loggingFilter->GetNavigationDataSet(), this->m_Controls->m_LoggingFileName->text().toStdString());
     }
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAddSingleTool()
 {
   QString Identifier = "Tool#";
   QString Name = "NewTool";
   if (m_toolStorage.IsNotNull()) {
     Identifier += QString::number(m_toolStorage->GetToolCount());
     Name += QString::number(m_toolStorage->GetToolCount());
   }
   else {
     Identifier += "0";
     Name += "0";
   }
   m_Controls->m_NavigationToolCreationWidget->Initialize(GetDataStorage(), Identifier.toStdString(), Name.toStdString());
   m_Controls->m_NavigationToolCreationWidget->SetTrackingDeviceType(m_Controls->m_configurationWidget->GetTrackingDevice()->GetType(), false);
   m_Controls->m_TrackingToolsWidget->setCurrentIndex(1);
 
   //disable tracking volume during tool editing
   lastTrackingVolumeState = m_Controls->m_ShowTrackingVolume->isChecked();
   if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
   GlobalReinit();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolFinished()
 {
   m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
   if (this->m_toolStorage.IsNull())
   {
     //this shouldn't happen!
     MITK_WARN << "No ToolStorage available, cannot add tool, aborting!";
     return;
   }
   m_toolStorage->AddTool(m_Controls->m_NavigationToolCreationWidget->GetCreatedTool());
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
   m_Controls->m_toolLabel->setText("<manually added>");
 
   //auto save current storage for persistence
   MITK_INFO << "Auto saving manually added tools for persistence.";
   AutoSaveToolStorage();
 
   //enable tracking volume again
   if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
   GlobalReinit();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolCanceled()
 {
   m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
 
   //enable tracking volume again
   if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
   GlobalReinit();
 }
 
 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::TimeGeometry::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_SkipInvalidData->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_SkipInvalidData->setEnabled(true);
   m_Controls->m_StopLogging->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableOptionsButtons()
 {
   m_Controls->m_ShowTrackingVolume->setEnabled(false);
   m_Controls->m_UseDifferentUpdateRates->setEnabled(false);
   m_Controls->m_UpdateRate->setEnabled(false);
   m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
   m_Controls->m_RenderUpdateRate->setEnabled(false);
   m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
   m_Controls->m_LogUpdateRate->setEnabled(false);
   m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
   m_Controls->m_DisableAllTimers->setEnabled(false);
   m_Controls->m_OtherOptionsGroupBox->setEnabled(false);
   m_Controls->m_EnableOpenIGTLinkMicroService->setEnabled(false);
   m_Controls->m_OpenIGTLinkDataFormat->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableOptionsButtons()
 {
   m_Controls->m_ShowTrackingVolume->setEnabled(true);
   m_Controls->m_UseDifferentUpdateRates->setEnabled(true);
   m_Controls->m_DisableAllTimers->setEnabled(true);
   m_Controls->m_OtherOptionsGroupBox->setEnabled(true);
   m_Controls->m_EnableOpenIGTLinkMicroService->setEnabled(true);
   m_Controls->m_OpenIGTLinkDataFormat->setEnabled(true);
   OnToggleDifferentUpdateRates();
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableTrackingControls()
 {
   m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableTrackingControls()
 {
   m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableTrackingConfigurationButtons()
 {
   m_Controls->m_AutoDetectTools->setEnabled(true);
   m_Controls->m_AddSingleTool->setEnabled(this->m_Controls->m_configurationWidget->GetTrackingDevice()->AddSingleToolIsAvailable());
   m_Controls->m_LoadTools->setEnabled(true);
   m_Controls->m_ResetTools->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableTrackingConfigurationButtons()
 {
   m_Controls->m_AutoDetectTools->setEnabled(false);
   m_Controls->m_AddSingleTool->setEnabled(false);
   m_Controls->m_LoadTools->setEnabled(false);
   m_Controls->m_ResetTools->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::ReplaceCurrentToolStorage(mitk::NavigationToolStorage::Pointer newStorage, std::string newStorageName)
 {
   //first: get rid of the old one
   //don't reset if there is no tool storage. BugFix #17793
   if (m_toolStorage.IsNotNull()){
     m_toolStorage->UnLockStorage(); //only to be sure...
     m_toolStorage->UnRegisterMicroservice();
     m_toolStorage = nullptr;
   }
 
   //now: replace by the new one
   m_toolStorage = newStorage;
   m_toolStorage->SetName(newStorageName);
-  m_toolStorage->RegisterAsMicroservice("no tracking device");
+  m_toolStorage->RegisterAsMicroservice();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnTimeOut()
 {
   MITK_WARN << "TimeOut. Quitting the thread...";
   m_WorkerThread->quit();
   //only if we can't quit use terminate.
   if (!m_WorkerThread->wait(1000))
   {
     MITK_ERROR << "Can't quit the thread. Terminating... Might cause further problems, be careful!";
     m_WorkerThread->terminate();
     m_WorkerThread->wait();
   }
   m_TimeoutTimer->stop();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnToolStorageChanged(const ctkServiceEvent event)
 {
-  if ((event.getType() == ctkServiceEvent::MODIFIED))
+  //don't listen to any changes during connection, toolStorage is locked anyway, so this are only changes of e.g. sourceID which are not relevant for the widget.
+  if (!m_connected && (event.getType() == ctkServiceEvent::MODIFIED))
   {
     m_Controls->m_configurationWidget->OnToolStorageChanged();
   }
 }
 
 //! [StoreUISettings]
 void QmitkMITKIGTTrackingToolboxView::StoreUISettings()
 {
   // persistence service does not directly work in plugins for now
   // -> using QSettings
   QSettings settings;
 
   settings.beginGroup(QString::fromStdString(VIEW_ID));
   MITK_DEBUG << "Store UI settings";
   // set the values of some widgets and attrbutes to the QSettings
   settings.setValue("ShowTrackingVolume", QVariant(m_Controls->m_ShowTrackingVolume->isChecked()));
   settings.setValue("toolStorageFilename", QVariant(m_ToolStorageFilename));
   settings.setValue("VolumeSelectionBox", QVariant(m_Controls->m_VolumeSelectionBox->currentIndex()));
   settings.setValue("SimpleModeEnabled", QVariant(m_SimpleModeEnabled));
   settings.setValue("OpenIGTLinkDataFormat", QVariant(m_Controls->m_OpenIGTLinkDataFormat->currentIndex()));
   settings.setValue("EnableOpenIGTLinkMicroService", QVariant(m_Controls->m_EnableOpenIGTLinkMicroService->isChecked()));
   settings.endGroup();
 }
 //! [StoreUISettings]
 
 //! [LoadUISettings]
 void QmitkMITKIGTTrackingToolboxView::LoadUISettings()
 {
   // persistence service does not directly work in plugins for now -> using QSettings
   QSettings settings;
 
   settings.beginGroup(QString::fromStdString(VIEW_ID));
 
   // set some widgets and attributes by the values from the QSettings
   m_Controls->m_ShowTrackingVolume->setChecked(settings.value("ShowTrackingVolume", true).toBool());
   m_Controls->m_EnableOpenIGTLinkMicroService->setChecked(settings.value("EnableOpenIGTLinkMicroService", true).toBool());
   m_Controls->m_VolumeSelectionBox->setCurrentIndex(settings.value("VolumeSelectionBox", 0).toInt());
   m_Controls->m_OpenIGTLinkDataFormat->setCurrentIndex(settings.value("OpenIGTLinkDataFormat", 0).toInt());
   m_ToolStorageFilename = settings.value("toolStorageFilename", QVariant("")).toString();
   if (settings.value("SimpleModeEnabled", false).toBool()) { this->OnToggleAdvancedSimpleMode(); }
   settings.endGroup();
   //! [LoadUISettings]
 
   //! [LoadToolStorage]
   // try to deserialize the tool storage from the given tool storage file name
   if (!m_ToolStorageFilename.isEmpty())
   {
     // try-catch block for exceptions
     try
     {
       mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
       m_toolStorage->UnRegisterMicroservice();
       m_toolStorage = myDeserializer->Deserialize(m_ToolStorageFilename.toStdString());
-      m_toolStorage->RegisterAsMicroservice("no tracking device");
+      m_toolStorage->RegisterAsMicroservice();
 
       //update label
       UpdateToolStorageLabel(m_ToolStorageFilename);
 
       //update tool preview
       m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
       m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
     }
     catch (mitk::IGTException)
     {
       MITK_WARN("QmitkMITKIGTTrackingToolBoxView") << "Error during restoring tools. Problems with file (" << m_ToolStorageFilename.toStdString() << "), please check the file?";
       this->OnResetTools(); //if there where errors reset the tool storage to avoid problems later on
     }
   }
   //! [LoadToolStorage]
 }
 
 void QmitkMITKIGTTrackingToolboxView::UpdateToolStorageLabel(QString pathOfLoadedStorage)
 {
   QFileInfo myPath(pathOfLoadedStorage); //use this to seperate filename from path
   QString toolLabel = myPath.fileName();
   if (toolLabel.size() > 45) //if the tool storage name is to long trimm the string
   {
     toolLabel.resize(40);
     toolLabel += "[...]";
   }
   m_Controls->m_toolLabel->setText(toolLabel);
 }
 
 void QmitkMITKIGTTrackingToolboxView::AutoSaveToolStorage()
 {
   m_ToolStorageFilename = m_AutoSaveFilename;
   mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
   mySerializer->Serialize(m_ToolStorageFilename.toStdString(), m_toolStorage);
 }
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewWorker.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewWorker.cpp
index dd9db054c4..0d1b858a06 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewWorker.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewWorker.cpp
@@ -1,250 +1,250 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkMITKIGTTrackingToolboxViewWorker.h"
 
 #include <mitkTrackingDeviceSourceConfigurator.h>
 
 QmitkMITKIGTTrackingToolboxViewWorker::QmitkMITKIGTTrackingToolboxViewWorker()
 {
 }
 
 QmitkMITKIGTTrackingToolboxViewWorker::~QmitkMITKIGTTrackingToolboxViewWorker()
 {
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::SetWorkerMethod(WorkerMethod w)
 {
   m_WorkerMethod = w;
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::SetTrackingDevice(mitk::TrackingDevice::Pointer t)
 {
   m_TrackingDevice = t;
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::SetDataStorage(mitk::DataStorage::Pointer d)
 {
   m_DataStorage = d;
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::SetInverseMode(bool mode)
 {
   m_InverseMode = mode;
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::SetTrackingDeviceData(mitk::TrackingDeviceData d)
 {
   m_TrackingDeviceData = d;
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::SetNavigationToolStorage(mitk::NavigationToolStorage::Pointer n)
 {
   m_NavigationToolStorage = n;
 }
 
 //! [Thread 7]
 void QmitkMITKIGTTrackingToolboxViewWorker::ThreadFunc()
 {
   switch (m_WorkerMethod)
   {
   case eAutoDetectTools:
     this->AutoDetectTools();
     break;
   case eConnectDevice:
     this->ConnectDevice();
     break;
   case eStartTracking:
     this->StartTracking();
     break;
   case eStopTracking:
     this->StopTracking();
     break;
   case eDisconnectDevice:
     this->DisconnectDevice();
     break;
   default:
     MITK_WARN << "Undefined worker method was set ... something went wrong!";
     break;
   }
 }
 //! [Thread 7]
 
 void QmitkMITKIGTTrackingToolboxViewWorker::AutoDetectTools()
 {
   mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New(m_DataStorage);
   try
   {
     mitk::NavigationToolStorage::Pointer tempStorage = m_TrackingDevice->AutoDetectTools();
     for (int i = 0; i < tempStorage->GetToolCount(); i++) { autoDetectedStorage->AddTool(tempStorage->GetTool(i)); }
   }
   catch (mitk::Exception& e)
   {
     MITK_WARN << e.GetDescription();
     emit AutoDetectToolsFinished(false, e.GetDescription());
     return;
   }
   m_NavigationToolStorage = nullptr;
   m_NavigationToolStorage = autoDetectedStorage;
   emit AutoDetectToolsFinished(true, "");
   MITK_INFO << "AutoDetect Tools Finished.";
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::ConnectDevice()
 {
   std::string message = "";
 
   //build the IGT pipeline
   mitk::TrackingDevice::Pointer trackingDevice = m_TrackingDevice;
   trackingDevice->SetData(m_TrackingDeviceData);
 
   //set device to rotation mode transposed becaus we are working with VNL style quaternions
   if (m_InverseMode)
   {
     trackingDevice->SetRotationMode(mitk::TrackingDevice::RotationTransposed);
   }
 
   //Get Tracking Volume Data
   mitk::TrackingDeviceData data = m_TrackingDeviceData;
 
   //Create Navigation Data Source with the factory class
   mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory = mitk::TrackingDeviceSourceConfigurator::New(m_NavigationToolStorage, trackingDevice);
 
   m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource(m_ToolVisualizationFilter);
 
   if (m_TrackingDeviceSource.IsNull())
   {
     message = std::string("Cannot connect to device: ") + myTrackingDeviceSourceFactory->GetErrorMessage();
     emit ConnectDeviceFinished(false, QString(message.c_str()));
     return;
   }
 
   //set filter to rotation mode transposed becaus we are working with VNL style quaternions
   if (m_InverseMode)
     m_ToolVisualizationFilter->SetRotationMode(mitk::NavigationDataObjectVisualizationFilter::RotationTransposed);
 
   //First check if the created object is valid
   if (m_TrackingDeviceSource.IsNull())
   {
     message = myTrackingDeviceSourceFactory->GetErrorMessage();
     emit ConnectDeviceFinished(false, QString(message.c_str()));
     return;
   }
 
   MITK_INFO << "Connected device with " << m_TrackingDeviceSource->GetNumberOfOutputs() << " tools.";
 
   //connect to device
   try
   {
     m_TrackingDeviceSource->Connect();
     //Microservice registration:
     m_TrackingDeviceSource->RegisterAsMicroservice();
-
+    m_NavigationToolStorage->SetSourceID(m_TrackingDeviceSource->GetMicroserviceID());
     m_NavigationToolStorage->LockStorage();
   }
   catch (...) //todo: change to mitk::IGTException
   {
     message = "Error on connecting the tracking device.";
     emit ConnectDeviceFinished(false, QString(message.c_str()));
     return;
   }
   emit ConnectDeviceFinished(true, QString(message.c_str()));
 }
 
 mitk::TrackingDeviceSource::Pointer QmitkMITKIGTTrackingToolboxViewWorker::GetTrackingDeviceSource()
 {
   return this->m_TrackingDeviceSource;
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::StartTracking()
 {
   QString errorMessage = "";
   try
   {
     m_TrackingDeviceSource->StartTracking();
   }
   catch (...) //todo: change to mitk::IGTException
   {
     errorMessage += "Error while starting the tracking device!";
     emit StartTrackingFinished(false, errorMessage);
     return;
   }
   //remember the original colors of the tools
   m_OriginalColors = std::map<mitk::DataNode::Pointer, mitk::Color>();
   for (int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
   {
     mitk::DataNode::Pointer currentToolNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
     float c[3];
     currentToolNode->GetColor(c);
     mitk::Color color;
     color.SetRed(c[0]);
     color.SetGreen(c[1]);
     color.SetBlue(c[2]);
     m_OriginalColors[currentToolNode] = color;
   }
 
   emit StartTrackingFinished(true, errorMessage);
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::StopTracking()
 {
   //stop tracking
   try
   {
     m_TrackingDeviceSource->StopTracking();
   }
   catch (mitk::Exception& e)
   {
     emit StopTrackingFinished(false, e.GetDescription());
   }
 
   //restore the original colors of the tools
   for (int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
   {
     mitk::DataNode::Pointer currentToolNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
     if (m_OriginalColors.find(currentToolNode) == m_OriginalColors.end())
     {
       MITK_WARN << "Cannot restore original color of tool " << m_NavigationToolStorage->GetTool(i)->GetToolName();
     }
     else
     {
       currentToolNode->SetColor(m_OriginalColors[currentToolNode]);
     }
   }
 
   //emit signal
   emit StopTrackingFinished(true, "");
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::DisconnectDevice()
 {
   try
   {
     if (m_TrackingDeviceSource->IsTracking()) { m_TrackingDeviceSource->StopTracking(); }
     m_TrackingDeviceSource->Disconnect();
     m_TrackingDeviceSource->UnRegisterMicroservice();
 
     m_NavigationToolStorage->UnLockStorage();
 
     m_TrackingDeviceSource = nullptr;
   }
   catch (mitk::Exception& e)
   {
     emit DisconnectDeviceFinished(false, e.GetDescription());
   }
   emit DisconnectDeviceFinished(true, "");
 }
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
index eabc7aa9a4..27f1f46617 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
@@ -1,240 +1,241 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkNavigationDataPlayerView.h"
 
 // QT
 #include <QFileDialog>
 #include <QMessageBox>
 
 //mitk
 #include <mitkNavigationDataSet.h>
 #include <mitkNavigationDataReaderInterface.h>
 #include <mitkNavigationDataSequentialPlayer.h>
 #include <mitkNavigationDataPlayer.h>
 #include <mitkVirtualTrackingTool.h>
 #include <mitkIOUtil.h>
 
 // VTK
 #include <vtkSphereSource.h>
 
 const std::string QmitkNavigationDataPlayerView::VIEW_ID = "org.mitk.views.navigationdataplayer";
 
 QmitkNavigationDataPlayerView::QmitkNavigationDataPlayerView()
   : m_Controls( 0 )
 {
 }
 
 QmitkNavigationDataPlayerView::~QmitkNavigationDataPlayerView()
 {
 }
 
 void QmitkNavigationDataPlayerView::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::QmitkNavigationDataPlayerViewControls;
     m_Controls->setupUi( parent );
 
     this->CreateConnections();
 
     // make deselected Player invisible
     m_Controls->m_TimedWidget->setVisible(false);
   }
 }
 
 void QmitkNavigationDataPlayerView::SetFocus()
 {
   if ( m_Controls )
   {
     m_Controls->m_grpbxControls->setFocus();
   }
 }
 
 void QmitkNavigationDataPlayerView::CreateConnections()
 {
   connect( m_Controls->m_RdbSequential, SIGNAL(released()), this, SLOT(OnSelectPlayer()) );
   connect( m_Controls->m_RdbTimeBased, SIGNAL(released()), this, SLOT(OnSelectPlayer()) );
   connect( m_Controls->m_BtnOpenFile, SIGNAL(released()), this, SLOT(OnOpenFile()) );
   connect( m_Controls->m_ChkDisplay, SIGNAL(released()), this, SLOT(OnSetDisplay()) );
   connect( m_Controls->m_chkRepeat, SIGNAL(stateChanged(int)), this, SLOT(OnSetRepeat(int)) );
   connect( m_Controls->m_ChkMicroservice, SIGNAL(released()), this, SLOT(OnSetMicroservice()) );
 
   connect( m_Controls->m_SequentialWidget, SIGNAL(SignalUpdate()), this, SLOT(OnUpdate()) );
   connect( m_Controls->m_TimedWidget, SIGNAL(SignalUpdate()), this, SLOT(OnUpdate()) );
 
   this->SetInteractionComponentsEnabledState(false);
 }
 
 void QmitkNavigationDataPlayerView::OnOpenFile()
 {
   mitk::NavigationDataReaderInterface::Pointer reader = NULL;
 
   QString filter = tr("NavigationData File (*.csv *.xml)");
 
   QString fileName = QFileDialog::getOpenFileName(NULL, tr("Open NavigationData Set"), "", filter);
 
   if ( fileName.isNull() ) { return; } // user pressed cancel
 
   try
   {
     m_Data = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::LoadBaseData(fileName.toStdString()).GetPointer());
   }
   catch ( const mitk::Exception &e )
   {
     MITK_WARN("NavigationDataPlayerView") << "could not open file " << fileName.toStdString();
     QMessageBox::critical(0, "Error Reading File", "The file '" + fileName
                           +"' could not be read.\n" + e.GetDescription() );
     return;
   }
 
   if (m_Controls->m_ChkConvertToPointSet->isChecked())
     m_Data->ConvertNavigationDataToPointSet();
 
   // Update Labels
   m_Controls->m_LblFilePath->setText(fileName);
   m_Controls->m_LblFrames->setText(QString::number(m_Data->Size()));
   m_Controls->m_LblTools->setText(QString::number(m_Data->GetNumberOfTools()));
 
   // Initialize Widgets and create Player
   this->OnSelectPlayer();
   this->SetInteractionComponentsEnabledState(true);
 }
 
 void QmitkNavigationDataPlayerView::OnSelectPlayer()
 {
   if (m_Controls->m_RdbSequential->isChecked())
   {
     m_Controls->m_SequentialWidget->setVisible(true);
     m_Controls->m_TimedWidget->setVisible(false);
     mitk::NavigationDataSequentialPlayer::Pointer seqPlayer = mitk::NavigationDataSequentialPlayer::New();
     seqPlayer->SetNavigationDataSet(m_Data);
     m_Controls->m_SequentialWidget->SetPlayer(seqPlayer);
     m_Player = seqPlayer;
   } else {
     m_Controls->m_SequentialWidget->setVisible(false);
     m_Controls->m_TimedWidget->setVisible(true);
     mitk::NavigationDataPlayer::Pointer timedPlayer = mitk::NavigationDataPlayer::New();
     timedPlayer->SetNavigationDataSet(m_Data);
     m_Controls->m_TimedWidget->SetPlayer(timedPlayer);
     m_Player = timedPlayer;
   }
 
   this->ConfigurePlayer();
 
   // SetupRenderingPipeline
   this->OnSetDisplay();
 }
 
 void QmitkNavigationDataPlayerView::ConfigurePlayer()
 {
   // set repeat mode according to the checkbox
   m_Player->SetRepeat( m_Controls->m_chkRepeat->isChecked() );
 }
 
 void QmitkNavigationDataPlayerView::OnSetRepeat(int checkState)
 {
   m_Player->SetRepeat(checkState != 0);
 }
 
 void QmitkNavigationDataPlayerView::OnSetMicroservice(){
   if(m_Controls->m_ChkMicroservice->isChecked())
   {
     m_ToolStorage = mitk::NavigationToolStorage::New();
     for (itk::ProcessObject::DataObjectPointerArraySizeType i = 0;
          i < m_Player->GetNumberOfIndexedOutputs(); i++)
     {
       mitk::NavigationTool::Pointer currentDummyTool = mitk::NavigationTool::New();
       mitk::VirtualTrackingTool::Pointer dummyTool = mitk::VirtualTrackingTool::New();
       std::stringstream name;
       name << "Virtual Tool " << i;
       dummyTool->SetToolName(name.str());
       currentDummyTool->SetTrackingTool(dummyTool.GetPointer());
       currentDummyTool->SetDataNode(m_RenderingNodes.at(i));
       currentDummyTool->SetIdentifier(name.str());
       m_ToolStorage->AddTool(currentDummyTool);
     }
     m_Player->RegisterAsMicroservice();
     m_ToolStorage->SetName("NavigationDataPlayer Tool Storage");
-    m_ToolStorage->RegisterAsMicroservice(m_Player->GetMicroserviceID());
+    m_ToolStorage->SetSourceID(m_Player->GetMicroserviceID());
+    m_ToolStorage->RegisterAsMicroservice();
   } else {
     if (m_ToolStorage.IsNotNull()) m_ToolStorage->UnRegisterMicroservice();
     m_ToolStorage = NULL;
     m_Player->UnRegisterMicroservice();
   }
 }
 
 void QmitkNavigationDataPlayerView::OnUpdate(){
   if (m_VisFilter.IsNotNull())
   {
     m_VisFilter->Update();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkNavigationDataPlayerView::OnSetDisplay(){
   DestroyPipeline();
   if ( (m_Controls->m_ChkDisplay->isChecked()) && ( m_Player.IsNotNull() ))
   {
     CreatePipeline();
   }
 }
 
 void QmitkNavigationDataPlayerView::CreatePipeline(){
   m_VisFilter = mitk::NavigationDataObjectVisualizationFilter::New();
   m_VisFilter->ConnectTo(m_Player);
 
   for (unsigned int i = 0 ; i < m_Player->GetNumberOfIndexedOutputs(); i++ ) {
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     QString name = "Recorded Tool " + QString::number(i + 1);
     node->SetName(name.toStdString());
 
     //create small sphere and use it as surface
     mitk::Surface::Pointer mySphere = mitk::Surface::New();
     vtkSphereSource *vtkData = vtkSphereSource::New();
     vtkData->SetRadius(5.0f);
     vtkData->SetCenter(0.0, 0.0, 0.0);
     vtkData->Update();
     mySphere->SetVtkPolyData(vtkData->GetOutput());
     vtkData->Delete();
     node->SetData(mySphere);
     m_VisFilter->SetRepresentationObject(i, mySphere);
 
     // Add Node to DataStorageand to local list of Nodes
     GetDataStorage()->Add(node);
     m_RenderingNodes.push_back(node);
   }
   m_VisFilter->Update();
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(GetDataStorage());
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkNavigationDataPlayerView::DestroyPipeline(){
   m_VisFilter = NULL;
   for (unsigned int i = 0; i < m_RenderingNodes.size(); i++){
     this->GetDataStorage()->Remove(m_RenderingNodes[i]);
   }
   m_RenderingNodes.clear();
 }
 
 void QmitkNavigationDataPlayerView::SetInteractionComponentsEnabledState(bool isActive){
   m_Controls->m_grpbxSettings->setEnabled(isActive);
   m_Controls->m_grpbxControls->setEnabled(isActive);
 }
\ No newline at end of file