diff --git a/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
index 6cd28b9d46..dda7521c26 100644
--- a/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
@@ -1,716 +1,714 @@
 /*===================================================================
 
 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 "QmitkTrackingDeviceConfigurationWidget.h"
 #include <mitkClaronTrackingDevice.h>
 #include <mitkNDITrackingDevice.h>
 #include <mitkOptitrackTrackingDevice.h>
 #include <mitkIGTException.h>
 #include <mitkSerialCommunication.h>
 #include <mitkProgressBar.h>
 #include <qscrollbar.h>
 #include <qmessagebox.h>
 #include <qfiledialog.h>
 #include <mitkIGTException.h>
 #include <QSettings>
 
 #include <itksys/SystemTools.hxx>
 #include <Poco/Path.h>
 
 
 
 const std::string QmitkTrackingDeviceConfigurationWidget::VIEW_ID = "org.mitk.views.trackingdeviceconfigurationwidget";
 
 QmitkTrackingDeviceConfigurationWidget::QmitkTrackingDeviceConfigurationWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f)
 {
   //initialize worker thread
   m_TestConnectionWorker = new QmitkTrackingDeviceConfigurationWidgetConnectionWorker();
   m_ScanPortsWorker = new QmitkTrackingDeviceConfigurationWidgetScanPortsWorker();
   m_ScanPortsWorkerThread = new QThread();
   m_TestConnectionWorkerThread = new QThread();
 
   m_Controls = NULL;
   CreateQtPartControl(this);
   CreateConnections();
   m_MTCalibrationFile = "";
 
   //reset a few things
   ResetOutput();
   AddOutput("<br>NDI Polaris selected");
   this->m_TrackingDeviceConfigurated = false;
 
   m_AdvancedUserControl = true;
 }
 
 void QmitkTrackingDeviceConfigurationWidget::SetGUIStyle(QmitkTrackingDeviceConfigurationWidget::Style style)
 {
 switch(style)
   {
   case QmitkTrackingDeviceConfigurationWidget::SIMPLE:
 
     //move all UI elements to an empty dummy layout
     //m_Controls->dummyLayout->addItem(m_Controls->mainLayout);
     m_Controls->dummyLayout->addWidget(m_Controls->widget_title_label);
     m_Controls->dummyLayout->addWidget(m_Controls->choose_tracking_device_label);
     m_Controls->dummyLayout->addWidget(m_Controls->polaris_label);
     m_Controls->dummyLayout->addWidget(m_Controls->aurora_label);
     //m_Controls->dummyLayout->addWidget(m_Controls->aurora_label);
     m_Controls->dummyLayout->addWidget(m_Controls->microntracker_label);
     m_Controls->dummyLayout->addWidget(m_Controls->m_testConnectionMicronTracker);
     m_Controls->dummyLayout->addWidget(m_Controls->m_outputTextMicronTracker);
     m_Controls->dummyLayout->addWidget(m_Controls->m_outputTextAurora);
     m_Controls->dummyLayout->addWidget(m_Controls->m_testConnectionAurora);
     m_Controls->dummyLayout->addWidget(m_Controls->m_outputTextPolaris);
     m_Controls->dummyLayout->addWidget(m_Controls->m_testConnectionPolaris);
     m_Controls->dummyLayout->addWidget(m_Controls->m_polarisTrackingModeBox);
     m_Controls->dummyLayout->addWidget(m_Controls->m_testConnectionOptitrack);
     m_Controls->dummyLayout->addWidget(m_Controls->m_outputTextOptitrack);
     m_Controls->dummyLayout->addWidget(m_Controls->m_OptitrackExp);
     m_Controls->dummyLayout->addWidget(m_Controls->m_OptitrackThr);
     m_Controls->dummyLayout->addWidget(m_Controls->m_OptitrackLed);
     m_Controls->dummyLayout->addWidget(m_Controls->Optitrack_label);
     m_Controls->dummyLayout->addWidget(m_Controls->m_finishedLine);
     m_Controls->dummyLayout->addWidget(m_Controls->line);
     m_Controls->dummyLayout->addWidget(m_Controls->configuration_finished_label);
     m_Controls->dummyLayout->addItem(m_Controls->horizontalLayout_4);
     m_Controls->mainLayout->removeItem(m_Controls->horizontalLayout_4);
     m_Controls->dummyLayout->addWidget(m_Controls->configuration_finished_label);
     m_Controls->dummyLayout->addItem(m_Controls->verticalSpacer_2);
     m_Controls->verticalLayout_3->removeItem(m_Controls->verticalSpacer_2);
     m_Controls->dummyLayout->addItem(m_Controls->horizontalSpacer_9);
     m_Controls->horizontalLayout_9->removeItem(m_Controls->horizontalSpacer_9);
     m_Controls->dummyLayout->addItem(m_Controls->horizontalSpacer_3);
     m_Controls->horizontalLayout_11->removeItem(m_Controls->horizontalSpacer_3);
     m_Controls->dummyLayout->addItem(m_Controls->verticalSpacer_3);
     m_Controls->verticalLayout_7->removeItem(m_Controls->verticalSpacer_3);
     m_Controls->dummyLayout->addItem(m_Controls->verticalSpacer_4);
     m_Controls->verticalLayout_10->removeItem(m_Controls->verticalSpacer_4);
     m_Controls->dummyLayout->addItem(m_Controls->horizontalSpacer_10);
     m_Controls->verticalLayout_10->removeItem(m_Controls->horizontalSpacer_10);
 
     //set height to min
     m_Controls->m_outputTextPolaris->setMinimumHeight(0);
     m_Controls->m_outputTextPolaris->setMaximumHeight(0);
     m_Controls->m_outputTextMicronTracker->setMinimumHeight(0);
     m_Controls->m_outputTextMicronTracker->setMaximumHeight(0);
     m_Controls->m_outputTextAurora->setMinimumHeight(0);
     m_Controls->m_outputTextAurora->setMaximumHeight(0);
     m_Controls->m_finishedButton->setMinimumHeight(0);
     m_Controls->m_finishedButton->setMaximumHeight(0);
     m_Controls->m_resetButton->setMinimumHeight(0);
     m_Controls->m_resetButton->setMaximumHeight(0);
 
 
     //set the height of the tracking device combo box
     m_Controls->m_trackingDeviceChooser->setMinimumHeight(50);
 
     //move back the used elemets to the main layout
     m_Controls->simpleLayout->addWidget(m_Controls->m_trackingDeviceChooser);
     m_Controls->simpleLayout->addWidget(m_Controls->m_TrackingSystemWidget);
 
     m_Controls->mainWidget->setCurrentIndex(1);
 
     this->setMaximumHeight(150);
 
     this->EnableAdvancedUserControl(false);
 
 
     break;
 
   case QmitkTrackingDeviceConfigurationWidget::ADVANCED:
 
     //default at the moment => start settings are advanced
 
     break;
 
   }
 
 }
 
 QmitkTrackingDeviceConfigurationWidget::~QmitkTrackingDeviceConfigurationWidget()
 {
 StoreUISettings();
 if (m_ScanPortsWorker) delete m_ScanPortsWorker;
 if (m_TestConnectionWorker) delete m_TestConnectionWorker;
 if (m_ScanPortsWorkerThread) delete m_ScanPortsWorkerThread;
 if (m_TestConnectionWorkerThread) delete m_TestConnectionWorkerThread;
 }
 
 void QmitkTrackingDeviceConfigurationWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
   // create GUI widgets
   m_Controls = new Ui::QmitkTrackingDeviceConfigurationWidgetControls;
   m_Controls->setupUi(parent);
   }
 }
 
 void QmitkTrackingDeviceConfigurationWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_trackingDeviceChooser), SIGNAL(currentIndexChanged(int)), this, SLOT(TrackingDeviceChanged()) );
     connect( (QObject*)(m_Controls->m_testConnectionPolaris), SIGNAL(clicked()), this, SLOT(TestConnection()) );
     connect( (QObject*)(m_Controls->m_testConnectionAurora), SIGNAL(clicked()), this, SLOT(TestConnection()) );
     connect( (QObject*)(m_Controls->m_testConnectionMicronTracker), SIGNAL(clicked()), this, SLOT(TestConnection()) );
     connect( (QObject*)(m_Controls->m_testConnectionOptitrack), SIGNAL(clicked()), this, SLOT(TestConnection()) );
     connect( (QObject*)(m_Controls->m_resetButton), SIGNAL(clicked()), this, SLOT(ResetByUser()) );
     connect( (QObject*)(m_Controls->m_finishedButton), SIGNAL(clicked()), this, SLOT(Finished()) );
     connect( (QObject*)(m_Controls->m_AutoScanPolaris), SIGNAL(clicked()), this, SLOT(AutoScanPorts()) );
     connect( (QObject*)(m_Controls->m_AutoScanAurora), SIGNAL(clicked()), this, SLOT(AutoScanPorts()) );
     connect( (QObject*)(m_Controls->m_SetMTCalibrationFile), SIGNAL(clicked()), this, SLOT(SetMTCalibrationFileClicked()) );
     connect( (QObject*)(m_Controls->m_SetOptitrackCalibrationFile), SIGNAL(clicked()), this, SLOT(SetOptitrackCalibrationFileClicked()) );
 
     //slots for the worker thread
     connect(m_ScanPortsWorker, SIGNAL(PortsScanned(int,int,QString,int,int)), this, SLOT(AutoScanPortsFinished(int,int,QString,int,int)) );
     connect(m_TestConnectionWorker, SIGNAL(ConnectionTested(bool,QString)), this, SLOT(TestConnectionFinished(bool,QString)) );
     connect(m_ScanPortsWorkerThread,SIGNAL(started()), m_ScanPortsWorker, SLOT(ScanPortsThreadFunc()) );
     connect(m_TestConnectionWorkerThread,SIGNAL(started()), m_TestConnectionWorker, SLOT(TestConnectionThreadFunc()) );
 
     //move the worker to the thread
     m_ScanPortsWorker->moveToThread(m_ScanPortsWorkerThread);
     m_TestConnectionWorker->moveToThread(m_TestConnectionWorkerThread);
 
     //set a few UI components depending on Windows / Linux
     #ifdef WIN32
     m_Controls->portTypeLabelPolaris->setVisible(false);
     m_Controls->portTypePolaris->setVisible(false);
     m_Controls->portTypeLabelAurora->setVisible(false);
     m_Controls->portTypeAurora->setVisible(false);
     #else
     m_Controls->comPortLabelAurora->setText("Port Nr:");
     m_Controls->m_comPortLabelPolaris->setText("Port Nr:");
     m_Controls->m_portSpinBoxAurora->setPrefix("");
     m_Controls->m_portSpinBoxPolaris->setPrefix("");
     #endif
 
     //disable unused UI component
     m_Controls->m_polarisTrackingModeBox->setVisible(false); //don't delete this component, because it is used in the MBI part of MITK
   }
   LoadUISettings();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::TrackingDeviceChanged()
 {
   //show the correspondig widget
   m_Controls->m_TrackingSystemWidget->setCurrentIndex(m_Controls->m_trackingDeviceChooser->currentIndex());
 
   //the new trackingdevice is not configurated yet
   m_TrackingDeviceConfigurated = false;
 
   //reset output
   ResetOutput();
 
   //print output and do further initializations
   if (m_Controls->m_trackingDeviceChooser->currentIndex()==0)//NDI Polaris
     {
     AddOutput("<br>NDI Polaris selected");
     }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==1)  //NDI Aurora
     {
     AddOutput("<br>NDI Aurora selected");
     }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==2) //ClaronTechnology MicronTracker 2
     {
     AddOutput("<br>Microntracker selected");
     if (!mitk::ClaronTrackingDevice::New()->IsDeviceInstalled())
       {
       AddOutput("<br>ERROR: not installed!");
       }
     else if (this->m_MTCalibrationFile == "") //if configuration file for MicronTracker is empty: load default
       {
       mitk::ClaronTrackingDevice::Pointer tempDevice = mitk::ClaronTrackingDevice::New();
       m_MTCalibrationFile = tempDevice->GetCalibrationDir();
       Poco::Path myPath = Poco::Path(m_MTCalibrationFile.c_str());
       m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
       }
     }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==3)
   {
     AddOutput("<br>Optitrack selected");
     if (!mitk::OptitrackTrackingDevice::New()->IsDeviceInstalled())
       {
       AddOutput("<br>ERROR: not installed!");
       }
   }
 
 emit TrackingDeviceSelectionChanged();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::EnableUserReset(bool enable)
 {
   if (enable) m_Controls->m_resetButton->setVisible(true);
   else m_Controls->m_resetButton->setVisible(false);
 }
 
 void QmitkTrackingDeviceConfigurationWidget::TestConnection()
 {
 this->setEnabled(false);
 //construct a tracking device:
 mitk::TrackingDevice::Pointer testTrackingDevice = ConstructTrackingDevice();
 m_TestConnectionWorker->SetTrackingDevice(testTrackingDevice);
 m_TestConnectionWorkerThread->start();
 emit ProgressStarted();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::TestConnectionFinished(bool connected, QString output)
 {
 m_TestConnectionWorkerThread->quit();
 AddOutput(output.toStdString());
 MITK_INFO << "Test connection: " << connected;
 this->setEnabled(true);
 emit ProgressFinished();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::Finished()
   {
   m_TrackingDevice = ConstructTrackingDevice();
   m_Controls->m_TrackingSystemWidget->setEnabled(false);
   m_Controls->m_trackingDeviceChooser->setEnabled(false);
   m_Controls->choose_tracking_device_label->setEnabled(false);
   m_Controls->configuration_finished_label->setText("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\np, li { white-space: pre-wrap; }\n</style></head><body style=\" font-family:\'MS Shell Dlg 2\'; font-size:8.25pt; font-weight:400; font-style:normal;\">\n<p align=\"right\" style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-size:8pt;\"><span style=\" font-weight:600;\">Configuration finished</span></p></body></html>");
   this->m_TrackingDeviceConfigurated = true;
   emit TrackingDeviceConfigurationFinished();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::Reset()
   {
   m_TrackingDevice = NULL;
   m_Controls->m_TrackingSystemWidget->setEnabled(true);
   m_Controls->m_trackingDeviceChooser->setEnabled(true);
   m_Controls->choose_tracking_device_label->setEnabled(true);
   m_Controls->configuration_finished_label->setText("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\np, li { white-space: pre-wrap; }\n</style></head><body style=\" font-family:\'MS Shell Dlg 2\'; font-size:8.25pt; font-weight:400; font-style:normal;\">\n<p align=\"right\" style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-size:8pt;\"><span style=\" font-weight:600;\">Press \"Finished\" to confirm configuration</span></p></body></html>");
   this->m_TrackingDeviceConfigurated = false;
   emit TrackingDeviceConfigurationReseted();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::ResetByUser()
   {
   Reset();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::AutoScanPorts()
   {
   this->setEnabled(false);
   AddOutput("<br>Scanning...");
   m_ScanPortsWorkerThread->start();
   emit ProgressStarted();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::AutoScanPortsFinished(int PolarisPort, int AuroraPort, QString result, int PortTypePolaris, int PortTypeAurora)
   {
   m_ScanPortsWorkerThread->quit();
   #ifdef WIN32
     if((PortTypePolaris!=-1)||(PortTypeAurora!=-1)) {MITK_WARN << "Port type is specified although this should not be the case for Windows. Ignoring port type.";}
   #else //linux systems
     if (PortTypePolaris!=-1) {m_Controls->portTypePolaris->setCurrentIndex(PortTypePolaris);}
     if (PortTypeAurora!=-1)  {m_Controls->portTypeAurora->setCurrentIndex(PortTypeAurora);}
   #endif
   m_Controls->m_portSpinBoxPolaris->setValue(PolarisPort);
   m_Controls->m_portSpinBoxAurora->setValue(AuroraPort);
   AddOutput(result.toStdString());
   this->setEnabled(true);
   emit ProgressFinished();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::SetMTCalibrationFileClicked()
   {
   std::string filename = QFileDialog::getOpenFileName(NULL,tr("Open Calibration File"), "/", "*.*").toAscii().data();
   if (filename=="") {return;}
   else
     {
     m_MTCalibrationFile = filename;
     Poco::Path myPath = Poco::Path(m_MTCalibrationFile.c_str());
     m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
     }
   }
 
 void QmitkTrackingDeviceConfigurationWidget::SetOptitrackCalibrationFileClicked()
   {
   std::string filename = QFileDialog::getOpenFileName(NULL,tr("Open Calibration File"), "/", "*.*").toAscii().data();
   if (filename=="") {return;}
   else
     {
     m_OptitrackCalibrationFile = filename;
     Poco::Path myPath = Poco::Path(m_OptitrackCalibrationFile.c_str());
     m_Controls->m_OptitrackCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
     }
   }
 //######################### internal help methods #######################################
 void QmitkTrackingDeviceConfigurationWidget::ResetOutput()
   {
   m_output.str("");
   m_output <<"<body style=\" font-family:\'MS Shell Dlg 2\'; font-size:7pt; font-weight:400; font-style:normal;\" bgcolor=black><span style=\"color:#ffffff;\"><u>output:</u>";
   m_Controls->m_outputTextAurora->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextPolaris->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextMicronTracker->setHtml(QString(m_output.str().c_str()));
   }
 void QmitkTrackingDeviceConfigurationWidget::AddOutput(std::string s)
   {
   //print output
   m_output << s;
   m_Controls->m_outputTextAurora->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextPolaris->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextMicronTracker->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextOptitrack->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextPolaris->verticalScrollBar()->setValue(m_Controls->m_outputTextPolaris->verticalScrollBar()->maximum());
   m_Controls->m_outputTextAurora->verticalScrollBar()->setValue(m_Controls->m_outputTextAurora->verticalScrollBar()->maximum());
   m_Controls->m_outputTextMicronTracker->verticalScrollBar()->setValue(m_Controls->m_outputTextMicronTracker->verticalScrollBar()->maximum());
   m_Controls->m_outputTextOptitrack->verticalScrollBar()->setValue(m_Controls->m_outputTextOptitrack->verticalScrollBar()->maximum());
   repaint();
   }
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConstructTrackingDevice()
   {
   mitk::TrackingDevice::Pointer returnValue;
   //#### Step 1: configure tracking device:
   if (m_Controls->m_trackingDeviceChooser->currentIndex()==0)//NDI Polaris
       {
       if(m_Controls->m_radioPolaris5D->isChecked()) //5D Tracking
         {
         //not yet in the open source part so we'll only get NULL here.
         returnValue = ConfigureNDI5DTrackingDevice();
         }
       else //6D Tracking
         {
         returnValue = ConfigureNDI6DTrackingDevice();
         returnValue->SetType(mitk::NDIPolaris);
         }
       }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==1)//NDI Aurora
         {
         returnValue = ConfigureNDI6DTrackingDevice();
         returnValue->SetType(mitk::NDIAurora);
         }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==2)//ClaronTechnology MicronTracker 2
         {
 
         mitk::ClaronTrackingDevice::Pointer newDevice = mitk::ClaronTrackingDevice::New();
         if(this->m_MTCalibrationFile=="") AddOutput("<br>Warning: Calibration file is not set!");
         else
           {
           //extract path from calibration file and set the calibration dir of the device
           std::string path =  itksys::SystemTools::GetFilenamePath(m_MTCalibrationFile);
           newDevice->SetCalibrationDir(path);
           }
         returnValue = newDevice;
         }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==3)
   {
     // Create the Tracking Device this->m_OptitrackDevice = mitk::OptitrackTrackingDevice::New();
     returnValue = ConfigureOptitrackTrackingDevice();
     returnValue->SetType(mitk::NPOptitrack);
   }
   return returnValue;
   }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConfigureNDI5DTrackingDevice()
   {
   return NULL;
   }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConfigureOptitrackTrackingDevice()
   {
   mitk::OptitrackTrackingDevice::Pointer tempTrackingDevice = mitk::OptitrackTrackingDevice::New();
   // Set the calibration File
   tempTrackingDevice->SetCalibrationPath(m_OptitrackCalibrationFile);
 
   //Set the camera parameters
   tempTrackingDevice->SetExp(m_Controls->m_OptitrackExp->value());
   tempTrackingDevice->SetLed(m_Controls->m_OptitrackLed->value());
   tempTrackingDevice->SetThr(m_Controls->m_OptitrackThr->value());
 
   mitk::TrackingDevice::Pointer returnValue = static_cast<mitk::TrackingDevice*>(tempTrackingDevice);
   return returnValue;
   }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConfigureNDI6DTrackingDevice()
   {
   mitk::NDITrackingDevice::Pointer tempTrackingDevice = mitk::NDITrackingDevice::New();
 
   //get port
   int port = 0;
   if (m_Controls->m_trackingDeviceChooser->currentIndex()==1) port = m_Controls->m_portSpinBoxAurora->value();
   else port = m_Controls->m_portSpinBoxPolaris->value();
 
   //build prefix (depends on linux/win)
   QString prefix = "";
   #ifdef WIN32
   prefix ="COM";
   tempTrackingDevice->SetPortNumber(static_cast<mitk::SerialCommunication::PortNumber>(port)); //also set the com port for compatibility
   #else
   if (m_Controls->m_trackingDeviceChooser->currentIndex()==1) //Aurora
     prefix = m_Controls->portTypeAurora->currentText();
   else //Polaris
     prefix = m_Controls->portTypePolaris->currentText();
   #endif
 
   //build port name string
   QString portName = prefix + QString::number(port);
 
   tempTrackingDevice->SetDeviceName(portName.toStdString()); //set the port name
   tempTrackingDevice->SetBaudRate(mitk::SerialCommunication::BaudRate115200);//set baud rate
   mitk::TrackingDevice::Pointer returnValue = static_cast<mitk::TrackingDevice*>(tempTrackingDevice);
   return returnValue;
   }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::GetTrackingDevice()
   {
   if (!m_AdvancedUserControl) m_TrackingDevice = ConstructTrackingDevice();
   if (m_TrackingDevice.IsNull() || !m_TrackingDevice->IsDeviceInstalled()) return NULL;
   else return this->m_TrackingDevice;
   }
 
 bool QmitkTrackingDeviceConfigurationWidget::GetTrackingDeviceConfigured()
   {
   return this->m_TrackingDeviceConfigurated;
   }
 
 void QmitkTrackingDeviceConfigurationWidget::ConfigurationFinished()
   {
   Finished();
 
   }
 
 void QmitkTrackingDeviceConfigurationWidget::EnableAdvancedUserControl(bool enable)
   {
   m_AdvancedUserControl = enable;
   m_Controls->configuration_finished_label->setVisible(enable);
   m_Controls->m_finishedLine->setVisible(enable);
   m_Controls->m_resetButton->setVisible(enable);
   m_Controls->m_finishedButton->setVisible(enable);
   }
 
 
 void QmitkTrackingDeviceConfigurationWidget::StoreUISettings()
 {
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
   if ( this->GetPeristenceService() )
   {
     mitk::PropertyList::Pointer propList = this->GetPeristenceService()->GetPropertyList(id);
     propList->Set("PolarisPortWin",m_Controls->m_portSpinBoxPolaris->value());
     propList->Set("AuroraPortWin",m_Controls->m_portSpinBoxAurora->value());
     propList->Set("PortTypePolaris", m_Controls->portTypePolaris->currentIndex());
     propList->Set("PortTypeAurora", m_Controls->portTypeAurora->currentIndex());
     propList->Set("MTCalibrationFile",m_MTCalibrationFile);
     propList->Set("SelectedDevice",m_Controls->m_trackingDeviceChooser->currentIndex());
   }
   else
   {
     // QSettings as a fallback if the persistence service is not available
     QSettings settings;
 
     settings.beginGroup(QString::fromStdString(id));
 
     settings.setValue("trackingDeviceChooser", QVariant(m_Controls->m_trackingDeviceChooser->currentIndex()));
     settings.setValue("portSpinBoxAurora", QVariant(m_Controls->m_portSpinBoxAurora->value()));
     settings.setValue("portSpinBoxPolaris", QVariant(m_Controls->m_portSpinBoxPolaris->value()));
     settings.setValue("portTypePolaris", QVariant(m_Controls->portTypePolaris->currentIndex()));
     settings.setValue("portTypeAurora", QVariant(m_Controls->portTypeAurora->currentIndex()));
     settings.setValue("mTCalibrationFile", QVariant(QString::fromStdString(m_MTCalibrationFile)));
 
     settings.endGroup();
   }
 }
 
 void QmitkTrackingDeviceConfigurationWidget::LoadUISettings()
 {
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
   if ( this->GetPeristenceService() )
   {
     mitk::PropertyList::Pointer propList = this->GetPeristenceService()->GetPropertyList(id);
     if (propList.IsNull())
     {MITK_ERROR << "Property list for this UI (" << id <<") is not available, could not load UI settings!"; return;}
-    int portPolarisWin=0,portAuroraWin=0,portTypePolaris=0,portTypeAurora=0,SelectedDevice=-1;
+    int portPolarisWin,portAuroraWin,portTypePolaris,portTypeAurora,SelectedDevice;
     propList->Get("PolarisPortWin",portPolarisWin);
     propList->Get("AuroraPortWin",portAuroraWin);
     propList->Get("PortTypePolaris", portTypePolaris);
     propList->Get("PortTypeAurora", portTypeAurora);
     propList->Get("MTCalibrationFile",m_MTCalibrationFile);
     propList->Get("SelectedDevice",SelectedDevice);
     if (SelectedDevice<0)
     {
       MITK_ERROR << "Loaded data from persistence service is invalid (SelectedDevice:" <<SelectedDevice<<"): aborted to restore data!";
       return;
     }
     m_Controls->m_portSpinBoxPolaris->setValue(portPolarisWin);
     m_Controls->m_portSpinBoxAurora->setValue(portAuroraWin);
     m_Controls->portTypePolaris->setCurrentIndex(portTypePolaris);
     m_Controls->portTypeAurora->setCurrentIndex(portTypeAurora);
     m_Controls->m_TrackingSystemWidget->setCurrentIndex(SelectedDevice);
     m_Controls->m_trackingDeviceChooser->setCurrentIndex(SelectedDevice);
     MITK_INFO << "Sucessfully restored UI settings";
   }
   else
   {
     // QSettings as a fallback if the persistence service is not available
     QSettings settings;
-
     settings.beginGroup(QString::fromStdString(id));
 
     m_Controls->m_trackingDeviceChooser->setCurrentIndex(settings.value("trackingDeviceChooser", 0).toInt());
     m_Controls->m_portSpinBoxAurora->setValue(settings.value("portSpinBoxAurora", 0).toInt());
     m_Controls->m_portSpinBoxPolaris->setValue(settings.value("portSpinBoxPolaris", 0).toInt());
     m_Controls->portTypePolaris->setCurrentIndex(settings.value("portTypePolaris", 0).toInt());
     m_Controls->portTypeAurora->setCurrentIndex(settings.value("portTypeAurora", 0).toInt());
     m_MTCalibrationFile = settings.value("mTCalibrationFile", "").toString().toStdString();
 
     settings.endGroup();
   }
 
   m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString::fromStdString(m_MTCalibrationFile));
 }
-
 void QmitkTrackingDeviceConfigurationWidgetConnectionWorker::TestConnectionThreadFunc()
 {
 MITK_INFO << "Testing Connection!";
 QString output;
 bool connected = false;
 mitk::ProgressBar::GetInstance()->AddStepsToDo(4);
 try
   {
   if (!m_TrackingDevice->IsDeviceInstalled())
      {
      output = "ERROR: Device is not installed!";
      }
   else
     {
     //test connection and start tracking, generate output
     output = "<br>testing connection <br>  ...";
     m_TrackingDevice->OpenConnection();
     output += "OK";
     mitk::ProgressBar::GetInstance()->Progress();
 
     //try start/stop tracking
     output += "<br>testing tracking <br>  ...";
     m_TrackingDevice->StartTracking();
     mitk::ProgressBar::GetInstance()->Progress();
     m_TrackingDevice->StopTracking();
     mitk::ProgressBar::GetInstance()->Progress();
 
     //try close connection
     m_TrackingDevice->CloseConnection();
     mitk::ProgressBar::GetInstance()->Progress();
     output += "OK";
     connected = true;
     }
   }
 catch(mitk::IGTException &e)
   {
   output += "ERROR!";
   MITK_WARN << "Error while testing connection / start tracking of the device: " << e.GetDescription();
   }
 mitk::ProgressBar::GetInstance()->Progress(4);
 emit ConnectionTested(connected,output);
 }
 
 void QmitkTrackingDeviceConfigurationWidgetScanPortsWorker::ScanPortsThreadFunc()
 {
   int PolarisPort = -1;
   int AuroraPort = -1;
   int PortTypePolaris = -1;
   int PortTypeAurora = -1;
 
   QString result = "<br>Found Devices:";
   int resultSize = result.size(); //remember size of result: if it stays the same no device were found
 
   #ifdef WIN32
     mitk::ProgressBar::GetInstance()->AddStepsToDo(19);
 
     QString devName;
     for (unsigned int i = 1; i < 20; ++i)
     {
       QString statusOutput = "Scanning Port #" + QString::number(i);
       MITK_INFO << statusOutput.toStdString().c_str();
       if (i<10) devName = QString("COM%1").arg(i);
       else devName = QString("\\\\.\\COM%1").arg(i); // prepend "\\.\ to COM ports >9, to be able to allow connection"
       mitk::TrackingDeviceType scannedPort = ScanPort(devName);
       switch (scannedPort)
       {
       case mitk::NDIPolaris:
         result += "<br>" + devName + ": " + "NDI Polaris";
         PolarisPort = i;
         break;
       case mitk::NDIAurora:
         result += "<br>" + devName + ": " + "NDI Aurora";
         AuroraPort = i;
         break;
       }
       mitk::ProgressBar::GetInstance()->Progress();
     }
   #else //linux systems
     for(unsigned int i = 1; i < 6; ++i)
     {
       QString devName = QString("/dev/ttyS%1").arg(i);
       mitk::TrackingDeviceType scannedPort = ScanPort(devName);
       switch (scannedPort)
       {
       case mitk::NDIPolaris:
         result += "<br>" + devName + ": " + "NDI Polaris";
         PolarisPort = i;
         PortTypePolaris = 1;
         break;
       case mitk::NDIAurora:
         result += "<br>" + devName + ": " + "NDI Aurora";
         AuroraPort = i;
         PortTypeAurora = 1;
         break;
       }
 
     }
     for(unsigned int i = 0; i <7; ++i)
     {
       QString devName = QString("/dev/ttyUSB%1").arg(i);
       mitk::TrackingDeviceType scannedPort = ScanPort(devName);
       switch (scannedPort)
       {
       case mitk::NDIPolaris:
         result += "<br>" + devName + ": " + "NDI Polaris";
         PolarisPort = i;
         PortTypePolaris = 0;
         break;
       case mitk::NDIAurora:
         result += "<br>" + devName + ": " + "NDI Aurora";
         AuroraPort = i;
         PortTypeAurora = 0;
         break;
       }
 
     }
   #endif
 
   if ( result.size() == resultSize) result += "<br>none";
 
   emit PortsScanned(PolarisPort,AuroraPort,result,PortTypePolaris,PortTypeAurora);
 }
 
 mitk::TrackingDeviceType QmitkTrackingDeviceConfigurationWidgetScanPortsWorker::ScanPort(QString port)
 {
   mitk::NDITrackingDevice::Pointer tracker = mitk::NDITrackingDevice::New();
   tracker->SetDeviceName(port.toStdString());
   mitk::TrackingDeviceType returnValue = mitk::TrackingSystemInvalid;
   try
   {returnValue = tracker->TestConnection();}
   catch (mitk::IGTException)
   {}//do nothing: there is simply no device on this port
   return returnValue;
 }
 
 void QmitkTrackingDeviceConfigurationWidgetConnectionWorker::SetTrackingDevice(mitk::TrackingDevice::Pointer t)
 {
   m_TrackingDevice = t;
 }
diff --git a/Modules/US/USNavigation/Filter/mitkNodeDisplacementFilter.cpp b/Modules/US/USNavigation/Filter/mitkNodeDisplacementFilter.cpp
index 5a47413bf7..cba655ec29 100644
--- a/Modules/US/USNavigation/Filter/mitkNodeDisplacementFilter.cpp
+++ b/Modules/US/USNavigation/Filter/mitkNodeDisplacementFilter.cpp
@@ -1,161 +1,185 @@
 /*===================================================================
 
 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 "mitkNodeDisplacementFilter.h"
 
 
 
   mitk::NodeDisplacementFilter::NodeDisplacementFilter()
     : m_SelectedInput(-1)
   {
   }
 
   mitk::NodeDisplacementFilter::~NodeDisplacementFilter()
   {
   }
 
   bool mitk::NodeDisplacementFilter::AddNode( mitk::DataNode::Pointer node )
   {
     // Consistency Checks
     if (node.IsNull())
     {
       MITK_WARN("NodeDisplacementFilter")
         << "Null Node passed to NodeDisplacementFilter. Ignoring Node....";
       return false;
     }
     if (node->GetData() == 0)
     {
       MITK_WARN("NodeDisplacementFilter")
         << "Empty Node passed to NodeDisplacementFilter. Ignoring Node....";
       return false;
     }
     if(m_SelectedInput == -1)
     {
       MITK_ERROR("NodeDisplacementFilter")
         << "Cannot add nodes before input Stream was selected";
       mitkThrow() << "Cannot add nodes before input Stream was selected";
     }
 
     this->Update(); // make sure we are working on current data
     mitk::NavigationData::Pointer reference = this->GetOutput(m_SelectedInput);
 
     if (! reference->IsDataValid())
     {
       MITK_WARN("NodeDisplacementFilter")
         << "Cannot add node while selected tool is not tracked. Ignoring Node....";
       return false;
     }
 
     // find transformation and add node
     mitk::AffineTransform3D::Pointer inverseAffineTransform = mitk::AffineTransform3D::New();
     if ( ! reference->GetAffineTransform3D()->GetInverse(inverseAffineTransform) )
     {
       MITK_ERROR("NodeDisplacementFilter")
         << "Could not get the inverse transformation of the navigation data transformation.";
       mitkThrow() << "Could not get the inverse transformation of the navigation data transformation.";
     }
 
     inverseAffineTransform->Compose(node->GetData()->GetGeometry()->GetIndexToWorldTransform(), true);
     m_Transforms.push_back(inverseAffineTransform);
     m_Nodes.push_back(node);
 
     return true;
   }
 
   bool mitk::NodeDisplacementFilter::RemoveNode(unsigned int i)
   {
     if ( i >= m_Nodes.size() ) { return false; }
 
     m_Nodes.erase(m_Nodes.begin()+i);
     m_Transforms.erase(m_Transforms.begin()+i);
     return true;
   }
 
   int mitk::NodeDisplacementFilter::GetNumberOfNodes()
   {
     return m_Nodes.size();
   }
 
   mitk::DataNode::Pointer mitk::NodeDisplacementFilter::GetNode (unsigned int i)
   {
     if (i < m_Nodes.size() ) { return m_Nodes.at(i); }
     else { return NULL; }
   }
 
   std::vector< mitk::DataNode::Pointer > mitk::NodeDisplacementFilter::GetNodes()
   {
     return m_Nodes;
   }
 
   void mitk::NodeDisplacementFilter::SelectInput(int i)
   {
     if (i < 0) { mitkThrow() << "Negative Input selected in NodeDisplacementFilter"; }
     if (! (static_cast<unsigned int>(i) < this->GetInputs().size()))
     {
       MITK_ERROR("NodeDisplacementFilter")
         << "Selected input index is larger than actual number of inputs.";
       mitkThrow() << "Selected input index is larger than actual number of inputs in NodeDisplacementFilter";
     }
     m_SelectedInput = i;
   }
 
+  mitk::NavigationData::Pointer mitk::NodeDisplacementFilter::GetRawDisplacementNavigationData(unsigned int i)
+  {
+    mitk::NavigationData::Pointer returnValue = mitk::NavigationData::New();
+    if((m_Nodes.size()>i) && (m_Nodes.at(i).IsNotNull()))
+      {
+      try
+        {
+          returnValue = mitk::NavigationData::New(m_Nodes.at(i)->GetData()->GetGeometry()->GetIndexToWorldTransform());
+        }
+      catch (mitk::Exception& e)
+        {
+          returnValue->SetDataValid(false);
+          MITK_WARN << "Excetion while returning navigation data: " << e.GetDescription();
+        }
+      }
+    else
+      {
+        returnValue->SetDataValid(false);
+        MITK_WARN << "Node Nr. " << i << " does not exist!";
+      }
+
+    return returnValue;
+  }
+
   void mitk::NodeDisplacementFilter::GenerateData()
   {
     // copy the navigation data from the inputs to the outputs
     mitk::NavigationDataPassThroughFilter::GenerateData();
 
     // if no reference has been set yet, warn and abort
     if (m_SelectedInput == -1)
     {
       MITK_INFO("NodeDisplacementFilter")
         << "No input has been selected. Only forwarding NavigationData...";
       return;
     }
 
     // cancel, if selected tool is currently not being tracked
     if ( ! this->GetInput(m_SelectedInput)->IsDataValid() ) { return; }
 
     // outputs have been updated, now to transform the nodes
     // 1) Generate Pseudo-Geometry for Reference
     mitk::Geometry3D::Pointer refGeom = this->TransformToGeometry(
       this->GetInput(m_SelectedInput)->GetAffineTransform3D());
 
     // 2) For each node, calculate new position
     for (unsigned int index=0; index < m_Nodes.size(); index++)
     {
       mitk::Geometry3D::Pointer transformGeometry = refGeom->Clone();
 
       // create transformation to the reference position and from there to
       // the node position (node has fixed transformation from reference position)
       transformGeometry->Compose(m_Transforms.at(index), true);
 
       m_Nodes.at(index)->GetData()->SetGeometry(transformGeometry);
     }
   }
 
   void mitk::NodeDisplacementFilter::ResetNodes()
   {
     m_Nodes.clear();
     m_Transforms.clear();
   }
 
 mitk::Geometry3D::Pointer mitk::NodeDisplacementFilter::TransformToGeometry(mitk::AffineTransform3D::Pointer transform){
   mitk::Geometry3D::Pointer g3d = mitk::Geometry3D::New();
   g3d->SetIndexToWorldTransform(transform);
   //g3d->TransferItkToVtkTransform(); // update VTK Transform for rendering too //Included in SetIndexToWorldTransform
   g3d->Modified();
   return g3d;
 }
diff --git a/Modules/US/USNavigation/Filter/mitkNodeDisplacementFilter.h b/Modules/US/USNavigation/Filter/mitkNodeDisplacementFilter.h
index 6f03ea0e6a..dc170a6476 100644
--- a/Modules/US/USNavigation/Filter/mitkNodeDisplacementFilter.h
+++ b/Modules/US/USNavigation/Filter/mitkNodeDisplacementFilter.h
@@ -1,130 +1,133 @@
 /*===================================================================
 
 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 NODEDISPLACEMENTFILTER_H_INCLUDED
 #define NODEDISPLACEMENTFILTER_H_INCLUDED
 
 #include "MitkUSNavigationExports.h"
 
 #include <itkProcessObject.h>
 
 #include "mitkBaseRenderer.h"
 #include "mitkCommon.h"
 #include "mitkNavigationData.h"
 #include "mitkNavigationDataPassThroughFilter.h"
 
 //MITK
 
 namespace mitk {
   /**Documentation
   * \brief This filter moves DataNodes relatively to tracking Data from a 6-DoF Sensor.
   *
   * This behaviour can for example be used for rigid tracking of risk structures relative to a skin marker.
   * To use it, connect the Filter and select the input that delivers tracking data from the reference marker
   * via SelectInput().
   * Make sure tracking is started before proceeding any further: The filter requires tracking data from the
   * sensor to calculate the relative position of the added node.
   *
   * One can then add Nodes to the filter via AddNode(). Make sure that the node has a geometry and position set
   * in the tracking coordinate system of the reference input. The Filter will then calculate the offset between
   * Node and reference marker and continously update the node position accordign to the tracking data.
   *
   * \ingroup US
   */
   class MitkUSNavigation_EXPORT NodeDisplacementFilter : public NavigationDataPassThroughFilter
   {
   public:
     mitkClassMacro(NodeDisplacementFilter, NavigationDataPassThroughFilter);
     itkNewMacro(Self);
 
     /**
     * \brief Adds a node to the filter.
     * The position of which will then be continously update relatively to the selected input stream.
     *
     * The node should have a geometry and position set in the coordinate system of the selected input stream
     */
     bool AddNode(mitk::DataNode::Pointer node);
 
     /**
      * \brief Removes a node from the filter.
      * \param i index of the node, the index corresponds to the order in which the nodes where added by AddNode()
      * \return true if a node with the given index was removed, false if the index was greater or equal the number of nodes in the filter
      */
     bool RemoveNode(unsigned int i);
 
     /**
     * \brief Returns the number of nodes that were added to this filter.
     */
     virtual int GetNumberOfNodes();
 
     /**
     * \brief Returns the nth node that was added to this filter.
     */
     virtual mitk::DataNode::Pointer GetNode (unsigned int i = 0);
 
+    /** @return Returns the current pose in world coordinates of node i as raw navigation data. */
+    virtual mitk::NavigationData::Pointer GetRawDisplacementNavigationData(unsigned int i = 0);
+
     /**
     * \brief Returns a vector containing all nodes that have been added to this filter.
     *
     * Indexes in this vector correspond to indexes in the vector provided by GetOffsets().
     */
     virtual std::vector< mitk::DataNode::Pointer > GetNodes();
 
     /**
     * \brief Selects an input stream as the reference stream.
     *
     * Position and orientation of all Nodes will be Updated according to information from the selected stream.
     * Make sure to select the input before adding nodes. The input should deliver 6DoF Data. Behaviour is undefined
     * for 5-Dof Data. The selected input can be changed during intervention if both old and new reference input
     * Lie in the same coordinate system. Be aware however that the offsets will not be recalculated, just moved
     * to the new stream.
     */
     virtual void SelectInput(int i);
 
     /**Documentation
     * \brief Removes all added Nodes from the Filter but leaves all other configuration intact.
     */
     virtual void ResetNodes();
 
   protected:
     NodeDisplacementFilter();
     virtual ~NodeDisplacementFilter();
 
     virtual void GenerateData();
 
     /**
      * \brief Creates an Geometry 3D Object from an AffineTransformation.
      */
     mitk::Geometry3D::Pointer TransformToGeometry(mitk::AffineTransform3D::Pointer transform);
 
     /**
      * \brief All Nodes that are being managed by this Filter.
      */
     std::vector<mitk::DataNode::Pointer> m_Nodes;
 
     /**
      * \brief The transformation that each node has to be reached from the selected navigation tool.
      * The indexes correspond to indexes in the node vector.
      */
     std::vector<mitk::AffineTransform3D::Pointer> m_Transforms;
 
     /**
      * \brief The Input that is used as a reference to orient the managed nodes.
      */
     int m_SelectedInput;
   };
 } // namespace mitk
 
 #endif
diff --git a/Modules/US/USNavigation/mitkUSCombinedModality.h b/Modules/US/USNavigation/mitkUSCombinedModality.h
index 02146207c0..9ea5049983 100644
--- a/Modules/US/USNavigation/mitkUSCombinedModality.h
+++ b/Modules/US/USNavigation/mitkUSCombinedModality.h
@@ -1,256 +1,256 @@
 /*===================================================================
 
 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 MITKUSCombinedModality_H_HEADER_INCLUDED_
 #define MITKUSCombinedModality_H_HEADER_INCLUDED_
 
 #include <MitkUSNavigationExports.h>
 #include "mitkUSDevice.h"
 #include "mitkNavigationDataSource.h"
 
 namespace itk {
   template<class T> class SmartPointer;
 }
 
 namespace mitk {
   class NavigationDataSmoothingFilter;
   class NavigationDataDelayFilter;
   class USControlInterfaceBMode;
   class USControlInterfaceProbes;
   class USControlInterfaceDoppler;
 
   /**
    * \brief Combination of USDevice and NavigationDataSource.
    * This class can be used as any USDevice subclass. Additionally tracking data be
    * retrieved from the NavigationDataSource returned by GetTrackingDevice().
    *
    * A calibration of the ultrasound image stream to the navigation datas can be set
    * for the currently active zoom level (of the ultrasound device) by SetCalibration().
    * The ultrasound images are transformed according to this calibration in the
    * GenerateData() method.
    */
   class MitkUSNavigation_EXPORT USCombinedModality : public USDevice
   {
   public:
     static const std::string DeviceClassIdentifier;
     static const char*       DefaultProbeIdentifier;
     static const char*       ProbeAndDepthSeperator;
 
     mitkClassMacro(USCombinedModality, USDevice);
     mitkNewMacro4Param(USCombinedModality, USDevice::Pointer, itk::SmartPointer<NavigationDataSource>, std::string, std::string);
 
     itkGetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
-
     itkSetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
+    itkGetMacro(TrackingDevice, itk::SmartPointer<NavigationDataSource>);
     itkSetMacro(TrackingDevice, itk::SmartPointer<NavigationDataSource>);
 
     /**
     * \brief Getter for calibration data of the currently active depth and probe.
     *
     * \return Transformation for calibration or null if no calibration is available.
     */
     AffineTransform3D::Pointer GetCalibration();
 
     /**
      * \brief Getter for calibration data of the given depth and the currently active probe.
      *
      * \param depth depth of the b mode ultrasound image for which the calibration should be returned
      * \return Transformation for calibration or null if no calibration is available.
      */
     AffineTransform3D::Pointer GetCalibration(std::string depth);
 
     /**
      * \brief Getter for calibration data of the given depth and probe.
      *
      * \param depth depth of the b mode ultrasound image for which the calibration should be returned
      * \param probe probe of the ultrasound device for which the calibration should be returned
      * \return Transformation for calibration or null if no calibration is available.
      */
     AffineTransform3D::Pointer GetCalibration(std::string depth, std::string probe);
 
     /**
     * \brief Sets a transformation as calibration data.
     * Calibration data is set for the currently activated probe and their current
     * zoom factor. It also marks the device as calibrated.
     */
     void SetCalibration(AffineTransform3D::Pointer calibration);
 
     /**
      * \brief Removes the calibration data of the currently active depth and probe.
      * \return true on success, false if there was no calibration
      */
     bool RemoveCalibration();
 
     /**
      * \brief Removes the calibration data of the given depth and the currently active probe.
      *
      * \param depth depth of the b mode ultrasound image for which the calibration should be removed
      * \return true on success, false if there was no calibration
      */
     bool RemoveCalibration(std::string depth);
 
     /**
      * \brief Removes the calibration data of the given depth and probe.
      *
      * \param depth depth of the b mode ultrasound image for which the calibration should be removed
      * \param probe probe of the ultrasound device for which the calibration should be removed
      * \return true on success, false if there was no calibration
      */
     bool RemoveCalibration(std::string depth, std::string probe);
 
     /**
     * \brief Returns the Class of the Device.
     */
     virtual std::string GetDeviceClass();
 
     /**
     * \brief Wrapper for returning USImageSource of the UltrasoundDevice.
     */
     virtual USImageSource::Pointer GetUSImageSource();
 
     /**
     * \brief Wrapper for returning custom control interface of the UltrasoundDevice.
     */
     virtual itk::SmartPointer<USAbstractControlInterface> GetControlInterfaceCustom();
 
     /**
     * \brief Wrapper for returning B mode control interface of the UltrasoundDevice.
     */
     virtual itk::SmartPointer<USControlInterfaceBMode> GetControlInterfaceBMode();
 
     /**
     * \brief Wrapper for returning probes control interface of the UltrasoundDevice.
     */
     virtual itk::SmartPointer<USControlInterfaceProbes> GetControlInterfaceProbes();
 
     /**
     * \brief Wrapper for returning doppler control interface of the UltrasoundDevice.
     */
     virtual itk::SmartPointer<USControlInterfaceDoppler> GetControlInterfaceDoppler();
 
     virtual itk::SmartPointer<mitk::NavigationDataSource> GetNavigationDataSource();
 
     /**
      * \return true if the device is calibrated for the currently selected probe with the current zoom level
      */
     bool GetIsCalibratedForCurrentStatus();
 
     /**
      * \return true if a calibration was loaded for at least one probe and depth
      */
     bool GetContainsAtLeastOneCalibration();
 
     /**
     * \brief Remove this device from the micro service.
     * This method is public for mitk::USCombinedModality, because this devices
     * can be completly removed. This is not possible for API devices, which
     * should be available while their sub module is loaded.
     */
     void UnregisterOnService();
 
     /**
     * \brief Serializes all contained calibrations into an xml fragment.
     *
     * The returned string contains one parent node named "calibrations" and several
     * subnodes, one for each calibration that is present.
     */
     std::string SerializeCalibration();
 
     /**
     * \brief Deserializes a string provided by a prior call to Serialize().
     * If the bool flag is true, all prior calibrations will be deleted.
     * If the flag is set to false, prior calibrations will be retained, but overwritten
     * if one of equal name is present.
     *
     * \throws mitk::Exception if the given string could not be parsed correctly.
     */
     void DeserializeCalibration(const std::string &xmlString, bool clearPreviousCalibrations = true);
 
     void SetNumberOfSmoothingValues(unsigned int numberOfSmoothingValues);
 
     void SetDelayCount(unsigned int delayCount);
 
   protected:
     USCombinedModality(USDevice::Pointer usDevice, itk::SmartPointer<NavigationDataSource> trackingDevice, std::string manufacturer = "", std::string model = "");
     virtual ~USCombinedModality();
 
     /**
     * \brief Initializes UltrasoundDevice.
     */
     virtual bool OnInitialization();
 
     /**
     * \brief Connects UltrasoundDevice.
     */
     virtual bool OnConnection();
 
     /**
     * \brief Disconnects UltrasoundDevice.
     */
     virtual bool OnDisconnection();
 
     /**
     * \brief Activates UltrasoundDevice.
     */
     virtual bool OnActivation();
 
     /**
     * \brief Deactivates UltrasoundDevice.
     */
     virtual bool OnDeactivation();
 
     /**
     * \brief Freezes or unfreezes UltrasoundDevice.
     */
     virtual void OnFreeze(bool);
 
     /**
     * \brief Grabs the next frame from the input.
     * This method is called internally, whenever Update() is invoked by an Output.
     */
     void GenerateData();
 
     std::string GetIdentifierForCurrentCalibration();
     std::string GetIdentifierForCurrentProbe();
     std::string GetCurrentDepthValue();
 
     void RebuildFilterPipeline();
 
     USDevice::Pointer                                      m_UltrasoundDevice;
     itk::SmartPointer<NavigationDataSource>                m_TrackingDevice;
     std::map<std::string, AffineTransform3D::Pointer>      m_Calibrations;
 
     itk::SmartPointer<mitk::NavigationDataSmoothingFilter> m_SmoothingFilter;
     itk::SmartPointer<mitk::NavigationDataDelayFilter>     m_DelayFilter;
     itk::SmartPointer<mitk::NavigationDataSource>          m_LastFilter;
 
     unsigned int m_NumberOfSmoothingValues;
     unsigned int m_DelayCount;
 
   private:
     /**
     *  \brief The device's ServiceRegistration object that allows to modify it's Microservice registraton details.
     */
     us::ServiceRegistration<Self>           m_ServiceRegistration;
 
     /**
     * \brief Properties of the device's Microservice.
     */
     us::ServiceProperties                   m_ServiceProperties;
   };
 } // namespace mitk
 
 #endif // MITKUSCombinedModality_H_HEADER_INCLUDED_
diff --git a/Modules/USUI/Qmitk/QmitkUSDeviceManagerWidget.cpp b/Modules/USUI/Qmitk/QmitkUSDeviceManagerWidget.cpp
index b525c47303..5ee0a45294 100644
--- a/Modules/USUI/Qmitk/QmitkUSDeviceManagerWidget.cpp
+++ b/Modules/USUI/Qmitk/QmitkUSDeviceManagerWidget.cpp
@@ -1,169 +1,173 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //#define _USE_MATH_DEFINES
 #include <QmitkUSDeviceManagerWidget.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <QMessageBox>
 #include "mitkUSVideoDevice.h"
 
 const std::string QmitkUSDeviceManagerWidget::VIEW_ID = "org.mitk.views.QmitkUSDeviceManagerWidget";
 
 QmitkUSDeviceManagerWidget::QmitkUSDeviceManagerWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
 {
   m_Controls = NULL;
   CreateQtPartControl(this);
 }
 
 QmitkUSDeviceManagerWidget::~QmitkUSDeviceManagerWidget()
 {
 }
 
 //////////////////// INITIALIZATION /////////////////////
 
 void QmitkUSDeviceManagerWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkUSDeviceManagerWidgetControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_ConnectedDevices->SetAutomaticallySelectFirstEntry(true);
   }
 
   // Initializations
   std::string empty = "";
   m_Controls->m_ConnectedDevices->Initialize<mitk::USDevice>(
         mitk::USDevice::GetPropertyKeys().US_PROPKEY_LABEL, empty);
 }
 
 void QmitkUSDeviceManagerWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( m_Controls->m_BtnActivate,   SIGNAL( clicked() ), this, SLOT(OnClickedActivateDevice()) );
     //connect( m_Controls->m_BtnDisconnect, SIGNAL( clicked() ), this, SLOT(OnClickedDisconnectDevice()) );
     connect( m_Controls->m_BtnRemove, SIGNAL( clicked() ), this, SLOT(OnClickedRemoveDevice()) );
     connect( m_Controls->m_BtnNewDevice, SIGNAL( clicked() ), this, SLOT(OnClickedNewDevice()) );
     connect( m_Controls->m_ConnectedDevices, SIGNAL( ServiceSelectionChanged(us::ServiceReferenceU) ), this, SLOT(OnDeviceSelectionChanged(us::ServiceReferenceU)) );
   }
 }
 
 ///////////// Methods & Slots Handling Direct Interaction /////////////////
 
 void QmitkUSDeviceManagerWidget::OnClickedActivateDevice()
 {
   mitk::USDevice::Pointer device = m_Controls->m_ConnectedDevices->GetSelectedService<mitk::USDevice>();
   if (device.IsNull()) { return; }
 
   if (device->GetIsActive())
   {
     device->Deactivate();
     device->Disconnect();
   }
   else
   {
     QApplication::setOverrideCursor(Qt::WaitCursor);
     if ( device->GetDeviceState() < mitk::USDevice::State_Connected ) { device->Connect(); }
     if ( device->GetIsConnected()) { device->Activate(); }
     QApplication::restoreOverrideCursor();
 
     if ( ! device->GetIsActive() )
     {
       QMessageBox::warning(this, "Activation failed", "Could not activate device. Check logging for details.");
     }
+    else
+    {
+      emit DeviceActivated();
+    }
   }
 
   // Manually reevaluate Button logic
   OnDeviceSelectionChanged(m_Controls->m_ConnectedDevices->GetSelectedServiceReference());
 }
 
 void QmitkUSDeviceManagerWidget::OnClickedDisconnectDevice(){
   mitk::USDevice::Pointer device = m_Controls->m_ConnectedDevices->GetSelectedService<mitk::USDevice>();
   if (device.IsNull()) { return; }
 
   if (device->GetIsConnected())
   {
     device->Disconnect();
   }
   else
   {
     if ( ! device->Connect() )
     {
       QMessageBox::warning(this, "Connecting failed", "Could not connect to device. Check logging for details.");
     }
   }
 }
 
 void QmitkUSDeviceManagerWidget::OnClickedRemoveDevice()
 {
   mitk::USDevice::Pointer device = m_Controls->m_ConnectedDevices->GetSelectedService<mitk::USDevice>();
   if (device.IsNull()) { return; }
 
   if ( device->GetDeviceClass() == "org.mitk.modules.us.USVideoDevice" )
   {
     if ( device->GetIsActive() ) { device->Deactivate(); }
     if ( device->GetIsConnected() ) { device->Disconnect(); }
 
     dynamic_cast<mitk::USVideoDevice*>(device.GetPointer())->UnregisterOnService();
   }
 }
 
 void QmitkUSDeviceManagerWidget::OnClickedNewDevice()
 {
   emit NewDeviceButtonClicked();
 }
 
 void QmitkUSDeviceManagerWidget::OnDeviceSelectionChanged(us::ServiceReferenceU reference){
   if (! reference)
   {
     m_Controls->m_BtnActivate->setEnabled(false);
     m_Controls->m_BtnRemove->setEnabled(false);
     return;
   }
   std::string isConnected = reference.GetProperty( mitk::USDevice::GetPropertyKeys().US_PROPKEY_ISCONNECTED ).ToString();
   std::string isActive = reference.GetProperty( mitk::USDevice::GetPropertyKeys().US_PROPKEY_ISACTIVE ).ToString();
 
   if ( isActive.compare("false") == 0 )
   {
     m_Controls->m_BtnActivate->setEnabled(true);
     m_Controls->m_BtnActivate->setText("Activate");
   }
   else
   {
     m_Controls->m_BtnActivate->setEnabled(true);
     m_Controls->m_BtnActivate->setText("Deactivate");
   }
 
   std::string deviceClass = reference.GetProperty( mitk::USDevice::GetPropertyKeys().US_PROPKEY_CLASS ).ToString();
   m_Controls->m_BtnRemove->setEnabled(deviceClass == "org.mitk.modules.us.USVideoDevice");
 }
 
 void QmitkUSDeviceManagerWidget::DisconnectAllDevices()
 {
   //at the moment disconnects ALL devices. Maybe we only want to disconnect the devices handled by this widget?
   us::ModuleContext* thisContext = us::GetModuleContext();
   std::vector<us::ServiceReference<mitk::USDevice> > services = thisContext->GetServiceReferences<mitk::USDevice>();
   for(std::vector<us::ServiceReference<mitk::USDevice> >::iterator it = services.begin(); it != services.end(); ++it)
   {
     mitk::USDevice* currentDevice = thisContext->GetService(*it);
     currentDevice->Disconnect();
   }
   MITK_INFO << "Disconnected ALL US devises!";
 }
diff --git a/Modules/USUI/Qmitk/QmitkUSDeviceManagerWidget.h b/Modules/USUI/Qmitk/QmitkUSDeviceManagerWidget.h
index 05163726b0..3a152354d3 100644
--- a/Modules/USUI/Qmitk/QmitkUSDeviceManagerWidget.h
+++ b/Modules/USUI/Qmitk/QmitkUSDeviceManagerWidget.h
@@ -1,93 +1,96 @@
 /*===================================================================
 
 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 _QmitkUSDeviceManagerWidget_H_INCLUDED
 #define _QmitkUSDeviceManagerWidget_H_INCLUDED
 
 #include "MitkUSUIExports.h"
 #include "ui_QmitkUSDeviceManagerWidgetControls.h"
 #include "mitkUSDevice.h"
 #include <vector>
 
 //QT headers
 #include <QWidget>
 #include <QListWidgetItem>
 
 
 
 /**
 * @brief This Widget is used to manage available Ultrasound Devices.
 *
 * It allows activation, deactivation and disconnection of connected devices.
 *
 * @ingroup USUI
 */
 class MitkUSUI_EXPORT QmitkUSDeviceManagerWidget :public QWidget
 {
 
   //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkUSDeviceManagerWidget(QWidget* p = 0, Qt::WindowFlags f1 = 0);
     virtual ~QmitkUSDeviceManagerWidget();
 
     /* @brief This method is part of the widget an needs not to be called seperately. */
     virtual void CreateQtPartControl(QWidget *parent);
     /* @brief This method is part of the widget an needs not to be called seperately. (Creation of the connections of main and control widget.)*/
     virtual void CreateConnections();
     /* @brief Disconnects all devices immediately. */
     virtual void DisconnectAllDevices();
 
   signals:
     void NewDeviceButtonClicked();
 
+    /* This signal is emitted if a device is activated. */
+    void DeviceActivated();
+
   public slots:
 
   protected slots:
 
     /*
     \brief Called, when the button "Activate Device" was clicked.
     */
     void OnClickedActivateDevice();
 
     /*
     \brief Called, when the button "Disconnect Device" was clicked.
     */
     void OnClickedDisconnectDevice();
 
     void OnClickedRemoveDevice();
     void OnClickedNewDevice();
 
     /*
     \brief Called, when the selection in the devicelist changes.
     */
     void OnDeviceSelectionChanged(us::ServiceReferenceU reference);
 
 
   protected:
 
     Ui::QmitkUSDeviceManagerWidgetControls* m_Controls; ///< member holding the UI elements of this widget
 
   private:
 
 
 };
 
 #endif // _QmitkUSDeviceManagerWidget_H_INCLUDED
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 51c01833dd..916e167485 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
@@ -1,1179 +1,1182 @@
 /*===================================================================
 
 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 <mitkTrackingDeviceSourceConfigurator.h>
 #include <mitkTrackingVolumeGenerator.h>
 #include <mitkNDITrackingDevice.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNavigationToolStorageSerializer.h>
 #include <mitkProgressBar.h>
 #include <mitkNavigationDataSetWriterXML.h>
 #include <mitkNavigationDataSetWriterCSV.h>
 
 // vtk
 #include <vtkSphereSource.h>
 //for exceptions
 #include <mitkIGTException.h>
 #include <mitkIGTIOException.h>
 
 const std::string QmitkMITKIGTTrackingToolboxView::VIEW_ID = "org.mitk.views.mitkigttrackingtoolbox";
 
 QmitkMITKIGTTrackingToolboxView::QmitkMITKIGTTrackingToolboxView()
   : QmitkFunctionality()
   , m_Controls( 0 )
   , m_MultiWidget( NULL )
 {
   m_TrackingTimer = new QTimer(this);
   m_tracking = false;
   m_logging = false;
   m_loggedFrames = 0;
 
   //initialize worker thread
   m_WorkerThread = new QThread();
   m_Worker = new QmitkMITKIGTTrackingToolboxViewWorker();
 }
 
 QmitkMITKIGTTrackingToolboxView::~QmitkMITKIGTTrackingToolboxView()
 {
   this->StoreUISettings();
 
   try
   {
     //clean up worker thread
     if(m_WorkerThread) {delete m_WorkerThread;}
     if(m_Worker) {delete m_Worker;}
     //remove the tracking volume
     this->GetDataStorage()->Remove(m_TrackingVolumeNode);
     //remove the tool storage
     if(m_toolStorage) {m_toolStorage->UnRegisterMicroservice();}
     if(m_TrackingDeviceSource) {m_TrackingDeviceSource->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!";}
+  this->StoreUISettings();
 }
 
 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_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()) );
     connect( m_Controls->m_Disconnect, SIGNAL(clicked()), this, SLOT(OnDisconnect()) );
     connect( m_Controls->m_StartTracking, SIGNAL(clicked()), this, SLOT(OnStartTracking()) );
     connect( m_Controls->m_StopTracking, SIGNAL(clicked()), this, SLOT(OnStopTracking()) );
     connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(UpdateTrackingTimer()));
     connect( m_Controls->m_ChooseFile, SIGNAL(clicked()), this, SLOT(OnChooseFileClicked()));
     connect( m_Controls->m_StartLogging, SIGNAL(clicked()), this, SLOT(StartLogging()));
     connect( m_Controls->m_StopLogging, SIGNAL(clicked()), this, SLOT(StopLogging()));
     connect( m_Controls->m_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()));
 
     //connections for the tracking device configuration widget
     connect( m_Controls->m_configurationWidget, SIGNAL(TrackingDeviceSelectionChanged()), this, SLOT(OnTrackingDeviceChanged()));
     connect( m_Controls->m_configurationWidget, SIGNAL(ProgressStarted()), this, SLOT(DisableOptionsButtons()));
     connect( m_Controls->m_configurationWidget, SIGNAL(ProgressStarted()), this, SLOT(DisableTrackingConfigurationButtons()));
     connect( m_Controls->m_configurationWidget, SIGNAL(ProgressStarted()), this, SLOT(DisableTrackingControls()));
     connect( m_Controls->m_configurationWidget, SIGNAL(ProgressFinished()), this, SLOT(EnableOptionsButtons()));
     connect( m_Controls->m_configurationWidget, SIGNAL(ProgressFinished()), this, SLOT(EnableTrackingConfigurationButtons()));
     connect( m_Controls->m_configurationWidget, SIGNAL(ProgressFinished()), this, SLOT(EnableTrackingControls()));
 
     //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()) );
 
     //move the worker to the thread
     m_Worker->moveToThread(m_WorkerThread);
 
     //initialize widgets
     m_Controls->m_configurationWidget->EnableAdvancedUserControl(false);
     m_Controls->m_TrackingToolsStatusWidget->SetShowPositions(true);
     m_Controls->m_TrackingToolsStatusWidget->SetTextAlignment(Qt::AlignLeft);
 
     //initialize tracking volume node
     m_TrackingVolumeNode = mitk::DataNode::New();
     m_TrackingVolumeNode->SetName("TrackingVolume");
     m_TrackingVolumeNode->SetOpacity(0.25);
     m_TrackingVolumeNode->SetBoolProperty("Backface Culling",true);
     mitk::Color red;
     red.SetRed(1);
     m_TrackingVolumeNode->SetColor(red);
 
     //initialize buttons
     m_Controls->m_Connect->setEnabled(true);
     m_Controls->m_Disconnect->setEnabled(false);
     m_Controls->m_StartTracking->setEnabled(false);
     m_Controls->m_StopTracking->setEnabled(false);
     m_Controls->m_AutoDetectTools->setVisible(false); //only visible if tracking device is Aurora
 
     //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 = mitk::GetDeviceDataForLine( m_Controls->m_configurationWidget->GetTrackingDevice()->GetType());
     }
     m_Controls->m_VolumeSelectionBox->clear();
     for(int 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");
 
     //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 if the volume should be shown
     if ( m_Controls->m_ShowTrackingVolume->isChecked() )
     {
       this->GetDataStorage()->Add(m_TrackingVolumeNode);
     }
   }
 }
 
 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 deserializing. Problems with file,please check the file?";
     QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
     return;
   }
 
   if(m_toolStorage->isEmpty())
   {
     errorMessage = myDeserializer->GetErrorMessage();
     MessageBox(errorMessage);
     return;
   }
 
   //update label
   Poco::Path myPath = Poco::Path(filename.toStdString()); //use this to seperate filename from path
   QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools from " + myPath.getFileName().c_str();
   m_Controls->m_toolLabel->setText(toolLabel);
 
   //update tool preview
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
 
   //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("Loaded Tools: <none>");
   m_Controls->m_toolLabel->setText(toolLabel);
 
   m_ToolStorageFilename = "";
-
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnConnect()
 {
   MITK_INFO << "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::DeviceDataUnspecified;
   QString qstr =  m_Controls->m_VolumeSelectionBox->currentText();
   if ( (! qstr.isNull()) || (! qstr.isEmpty()) ) {
     std::string str = qstr.toStdString();
     data = mitk::GetDeviceDataByName(str); //Data will be set later, after device generation
   }
 
   //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();
 
   //disable buttons
   this->m_Controls->m_MainWidget->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnConnectFinished(bool success, QString errorMessage)
 {
   m_WorkerThread->quit();
 
   //enable buttons
   this->m_Controls->m_MainWidget->setEnabled(true);
 
   if (!success)
   {
     MITK_WARN << errorMessage.toStdString();
     MessageBox(errorMessage.toStdString());
     return;
   }
 
   //get data from worker thread
   m_TrackingDeviceSource = m_Worker->GetTrackingDeviceSource();
   m_TrackingDeviceData = m_Worker->GetTrackingDeviceData();
   m_ToolVisualizationFilter = m_Worker->GetToolVisualizationFilter();
 
   //enable/disable Buttons
   m_Controls->m_Disconnect->setEnabled(true);
   m_Controls->m_StartTracking->setEnabled(true);
   m_Controls->m_StopTracking->setEnabled(false);
   m_Controls->m_Connect->setEnabled(false);
   DisableOptionsButtons();
   DisableTrackingConfigurationButtons();
   m_Controls->m_configurationWidget->ConfigurationFinished();
 
   m_Controls->m_TrackingControlLabel->setText("Status: connected");
 }
 
 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_Controls->m_MainWidget->setEnabled(true);
 
   if (!success)
   {
     MITK_WARN << errorMessage.toStdString();
     MessageBox(errorMessage.toStdString());
     return;
   }
 
   //enable/disable Buttons
   m_Controls->m_Disconnect->setEnabled(false);
   m_Controls->m_StartTracking->setEnabled(false);
   m_Controls->m_StopTracking->setEnabled(false);
   m_Controls->m_Connect->setEnabled(true);
   EnableOptionsButtons();
   EnableTrackingConfigurationButtons();
   m_Controls->m_configurationWidget->Reset();
   m_Controls->m_TrackingControlLabel->setText("Status: disconnected");
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStartTracking()
 {
   m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStartTracking);
   m_WorkerThread->start();
   this->m_Controls->m_MainWidget->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStartTrackingFinished(bool success, QString errorMessage)
 {
   m_WorkerThread->quit();
   this->m_Controls->m_MainWidget->setEnabled(true);
 
   if(!success)
   {
     MessageBox(errorMessage.toStdString());
     MITK_WARN << errorMessage.toStdString();
     return;
   }
 
   m_TrackingTimer->start(1000/(m_Controls->m_UpdateRate->value()));
   m_Controls->m_TrackingControlLabel->setText("Status: tracking");
 
   //connect the tool visualization widget
   for(int i=0; i<m_TrackingDeviceSource->GetNumberOfOutputs(); i++)
   {
     m_Controls->m_TrackingToolsStatusWidget->AddNavigationData(m_TrackingDeviceSource->GetOutput(i));
   }
   m_Controls->m_TrackingToolsStatusWidget->ShowStatusLabels();
   if (m_Controls->m_ShowToolQuaternions->isChecked()) {m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(true);}
   else {m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(false);}
 
   //show tracking volume
   this->OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
 
   //enable/disable Buttons
   m_Controls->m_Disconnect->setEnabled(true);
   m_Controls->m_StartTracking->setEnabled(false);
   m_Controls->m_StopTracking->setEnabled(true);
   m_Controls->m_Connect->setEnabled(false);
 
   m_tracking = true;
 
   this->GlobalReinit();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStopTracking()
 {
   if (!m_tracking) return;
   m_TrackingTimer->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_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;
 
   //enable/disable Buttons
   m_Controls->m_Disconnect->setEnabled(true);
   m_Controls->m_StartTracking->setEnabled(true);
   m_Controls->m_StopTracking->setEnabled(false);
   m_Controls->m_Connect->setEnabled(false);
 
   this->GlobalReinit();
 }
 
 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::TrackingSystemNotSpecified;
     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 (Type == mitk::NDIAurora) //Aurora
   {
     m_Controls->m_AutoDetectTools->setVisible(true);
     m_Controls->m_AddSingleTool->setEnabled(false);
   }
   else //Polaris or Microntracker
   {
     m_Controls->m_AutoDetectTools->setVisible(false);
     m_Controls->m_AddSingleTool->setEnabled(true);
   }
 
   // Code to select appropriate tracking volume for current type
   std::vector<mitk::TrackingDeviceData> Compatibles = mitk::GetDeviceDataForLine(Type);
   m_Controls->m_VolumeSelectionBox->clear();
   for(int 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;
   if (m_Controls->m_ShowTrackingVolume->isChecked())
   {
     mitk::TrackingVolumeGenerator::Pointer volumeGenerator = mitk::TrackingVolumeGenerator::New();
 
     std::string str = qstr.toStdString();
 
     mitk::TrackingDeviceData data = mitk::GetDeviceDataByName(str);
     m_TrackingDeviceData = data;
 
     volumeGenerator->SetTrackingDeviceData(data);
     volumeGenerator->Update();
 
     mitk::Surface::Pointer volumeSurface = volumeGenerator->GetOutput();
 
     m_TrackingVolumeNode->SetData(volumeSurface);
 
     GlobalReinit();
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnShowTrackingVolumeChanged()
 {
   if (m_Controls->m_ShowTrackingVolume->isChecked())
   {
     OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
     GetDataStorage()->Add(m_TrackingVolumeNode);
   }
   else
   {
     GetDataStorage()->Remove(m_TrackingVolumeNode);
     GlobalReinit();
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAutoDetectTools()
 {
   if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() == mitk::NDIAurora)
   {
     DisableTrackingConfigurationButtons();
     m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eAutoDetectTools);
     m_Worker->SetTrackingDevice(m_Controls->m_configurationWidget->GetTrackingDevice().GetPointer());
     m_Worker->SetDataStorage(this->GetDataStorage());
     m_WorkerThread->start();
     //disable controls until worker thread is finished
     this->m_Controls->m_MainWidget->setEnabled(false);
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAutoDetectToolsFinished(bool success, QString errorMessage)
 {
   m_WorkerThread->quit();
 
   //enable controls again
   this->m_Controls->m_MainWidget->setEnabled(true);
 
   if(!success)
   {
     MITK_WARN << errorMessage.toStdString();
     MessageBox(errorMessage.toStdString());
     EnableTrackingConfigurationButtons();
     return;
   }
 
   mitk::NavigationToolStorage::Pointer autoDetectedStorage = m_Worker->GetNavigationToolStorage();
 
   //save detected tools
   this->ReplaceCurrentToolStorage(autoDetectedStorage,"Autodetected NDI Aurora Storage");
   //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();
 
   if (m_toolStorage->GetToolCount()>0)
   {
     //ask the user if he wants to save the detected tools
     QMessageBox msgBox;
     switch(m_toolStorage->GetToolCount())
     {
     case 1:
       msgBox.setText("Found one tool!");
       break;
     default:
       msgBox.setText("Found " + QString::number(m_toolStorage->GetToolCount()) + " tools!");
     }
     msgBox.setInformativeText("Do you want to save this tools as tool storage, so you can load them again?");
     msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
     msgBox.setDefaultButton(QMessageBox::No);
     int ret = msgBox.exec();
 
     if (ret == 16384) //yes
     {
       //ask the user for a filename
       QString fileName = QFileDialog::getSaveFileName(NULL, tr("Save File"),"/",tr("*.IGTToolStorage"));
       //check for empty filename
       if(fileName == "") {return;}
       mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
 
       //when Serialize method is used exceptions are thrown, need to be adapted
       //try-catch block for exception handling in Serializer
       try
       {
         mySerializer->Serialize(fileName.toStdString(),m_toolStorage);
       }
       catch(mitk::IGTException)
       {
         std::string errormessage = "Error during serialization. Please check the Zip file.";
         QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
       }
 
       return;
     }
     else if (ret == 65536) //no
     {
       return;
     }
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::MessageBox(std::string s)
 {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
 }
 
 void QmitkMITKIGTTrackingToolboxView::UpdateTrackingTimer()
 {
   m_ToolVisualizationFilter->Update();
   MITK_DEBUG << "Number of outputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedOutputs();
   MITK_DEBUG << "Number of inputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedInputs();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   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();}
   }
   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::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->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::NavigationDataSetWriterCSV* writer = new mitk::NavigationDataSetWriterCSV();
       writer->Write(this->m_Controls->m_LoggingFileName->text().toStdString(),m_loggingFilter->GetNavigationDataSet());
       delete writer;
       }
     else if (m_Controls->m_xmlFormat->isChecked())
       {
       mitk::NavigationDataSetWriterXML* writer = new mitk::NavigationDataSetWriterXML();
       writer->Write(this->m_Controls->m_LoggingFileName->text().toStdString(),m_loggingFilter->GetNavigationDataSet());
       delete writer;
       }
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAddSingleTool()
 {
   QString Identifier = "Tool#";
   if (m_toolStorage.IsNotNull()) Identifier += QString::number(m_toolStorage->GetToolCount());
   else Identifier += "0";
   m_Controls->m_NavigationToolCreationWidget->Initialize(GetDataStorage(),Identifier.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);
   QString toolLabel = QString("Loaded Tools: <manually added>");
 
   //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_StopLogging->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableLoggingButtons()
 {
   m_Controls->m_StartLogging->setEnabled(true);
   m_Controls->m_LoggingFileName->setEnabled(true);
   m_Controls->m_ChooseFile->setEnabled(true);
   m_Controls->m_LoggingLimit->setEnabled(true);
   m_Controls->m_LoggedFramesLimit->setEnabled(true);
   m_Controls->m_csvFormat->setEnabled(true);
   m_Controls->m_xmlFormat->setEnabled(true);
   m_Controls->m_StopLogging->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableOptionsButtons()
 {
   m_Controls->m_ShowTrackingVolume->setEnabled(false);
   m_Controls->m_UpdateRate->setEnabled(false);
   m_Controls->m_ShowToolQuaternions->setEnabled(false);
   m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableOptionsButtons()
 {
   m_Controls->m_ShowTrackingVolume->setEnabled(true);
   m_Controls->m_UpdateRate->setEnabled(true);
   m_Controls->m_ShowToolQuaternions->setEnabled(true);
   m_Controls->m_OptionsUpdateRateLabel->setEnabled(true);
 }
 
 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);
   if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAurora) m_Controls->m_AddSingleTool->setEnabled(true);
   m_Controls->m_LoadTools->setEnabled(true);
   m_Controls->m_ResetTools->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableTrackingConfigurationButtons()
 {
   m_Controls->m_AutoDetectTools->setEnabled(false);
   if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAurora) 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 = NULL;
   }
 
   //now: replace by the new one
   m_toolStorage = newStorage;
   m_toolStorage->SetName(newStorageName);
   m_toolStorage->RegisterAsMicroservice("no tracking device");
 }
 
 void QmitkMITKIGTTrackingToolboxView::StoreUISettings()
 {
   // persistence service does not directly work in plugins for now
   // -> using QSettings
   QSettings settings;
 
   settings.beginGroup(QString::fromStdString(VIEW_ID));
 
   // 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.endGroup();
 }
 
 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_VolumeSelectionBox->setCurrentIndex(settings.value("VolumeSelectionBox", 0).toInt());
   m_ToolStorageFilename = settings.value("toolStorageFilename", QVariant("")).toString();
 
   settings.endGroup();
 
+
   // 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");
 
       //update label
       Poco::Path myPath = Poco::Path(m_ToolStorageFilename.toStdString()); //use this to seperate filename from path
       QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools from " + myPath.getFileName().c_str();
       m_Controls->m_toolLabel->setText(toolLabel);
 
       //update tool preview
       m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
       m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
     }
     catch(mitk::IGTException)
     {
-      MITK_WARN("QmitkMITKIGTTrackingToolBoxView") << "Error during deserializing. Problems with file,please check the file?";
+      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
     }
   }
 }
 
+
 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;
 }
 
 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;
   }
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::AutoDetectTools()
 {
   mitk::ProgressBar::GetInstance()->AddStepsToDo(4);
   mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New(m_DataStorage);
   mitk::NDITrackingDevice::Pointer currentDevice = dynamic_cast<mitk::NDITrackingDevice*>(m_TrackingDevice.GetPointer());
   try
   {
     currentDevice->OpenConnection();
     mitk::ProgressBar::GetInstance()->Progress();
     currentDevice->StartTracking();
   }
   catch(mitk::Exception& e)
   {
     QString message = QString("Warning, can not auto-detect tools! (") + QString(e.GetDescription()) + QString(")");
     //MessageBox(message.toStdString()); //TODO: give message to the user here!
 
     MITK_WARN << message.toStdString();
     mitk::ProgressBar::GetInstance()->Progress(4);
     emit AutoDetectToolsFinished(false,message.toStdString().c_str());
     return;
   }
 
   for (int i=0; i<currentDevice->GetToolCount(); i++)
   {
     //create a navigation tool with sphere as surface
     std::stringstream toolname;
     toolname << "AutoDetectedTool" << i;
     mitk::NavigationTool::Pointer newTool = mitk::NavigationTool::New();
     newTool->SetSerialNumber(dynamic_cast<mitk::NDIPassiveTool*>(currentDevice->GetTool(i))->GetSerialNumber());
     newTool->SetIdentifier(toolname.str());
     newTool->SetTrackingDeviceType(mitk::NDIAurora);
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     mitk::Surface::Pointer mySphere = mitk::Surface::New();
     vtkSphereSource *vtkData = vtkSphereSource::New();
     vtkData->SetRadius(3.0f);
     vtkData->SetCenter(0.0, 0.0, 0.0);
     vtkData->Update();
     mySphere->SetVtkPolyData(vtkData->GetOutput());
     vtkData->Delete();
     newNode->SetData(mySphere);
     newNode->SetName(toolname.str());
     newTool->SetDataNode(newNode);
     autoDetectedStorage->AddTool(newTool);
   }
 
   m_NavigationToolStorage = autoDetectedStorage;
 
   currentDevice->StopTracking();
   mitk::ProgressBar::GetInstance()->Progress();
   currentDevice->CloseConnection();
 
   emit AutoDetectToolsFinished(true,"");
   mitk::ProgressBar::GetInstance()->Progress(4);
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::ConnectDevice()
 {
   std::string message = "";
   mitk::ProgressBar::GetInstance()->AddStepsToDo(10);
 
   //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;
   mitk::ProgressBar::GetInstance()->Progress();
 
   //Create Navigation Data Source with the factory class
   mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory = mitk::TrackingDeviceSourceConfigurator::New(m_NavigationToolStorage,trackingDevice);
   m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource(m_ToolVisualizationFilter);
   mitk::ProgressBar::GetInstance()->Progress();
 
   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 << "Number of tools: " << m_TrackingDeviceSource->GetNumberOfOutputs();
   mitk::ProgressBar::GetInstance()->Progress();
 
   //The tools are maybe reordered after initialization, e.g. in case of auto-detected tools of NDI Aurora
   mitk::NavigationToolStorage::Pointer toolsInNewOrder = myTrackingDeviceSourceFactory->GetUpdatedNavigationToolStorage();
   if ((toolsInNewOrder.IsNotNull()) && (toolsInNewOrder->GetToolCount() > 0))
   {
     //so delete the old tools in wrong order and add them in the right order
     //we cannot simply replace the tool storage because the new storage is
     //not correctly initialized with the right data storage
     m_NavigationToolStorage->DeleteAllTools();
     for (int i=0; i < toolsInNewOrder->GetToolCount(); i++) {m_NavigationToolStorage->AddTool(toolsInNewOrder->GetTool(i));}
   }
   mitk::ProgressBar::GetInstance()->Progress();
 
   //connect to device
   try
   {
     m_TrackingDeviceSource->Connect();
     mitk::ProgressBar::GetInstance()->Progress();
     //Microservice registration:
     m_TrackingDeviceSource->RegisterAsMicroservice();
     m_NavigationToolStorage->UnRegisterMicroservice();
     m_NavigationToolStorage->RegisterAsMicroservice(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::ProgressBar::GetInstance()->Progress(10);
 }
 
 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;
   }
   emit StartTrackingFinished(true,errorMessage);
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::StopTracking()
 {
   try
   {
     m_TrackingDeviceSource->StopTracking();
   }
   catch(mitk::Exception& e)
   {
     emit StopTrackingFinished(false, e.GetDescription());
   }
   emit StopTrackingFinished(true, "");
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::DisconnectDevice()
 {
   try
   {
     if (m_TrackingDeviceSource->IsTracking()) {m_TrackingDeviceSource->StopTracking();}
     m_TrackingDeviceSource->Disconnect();
     m_TrackingDeviceSource->UnRegisterMicroservice();
     m_NavigationToolStorage->UnLockStorage();
   }
   catch(mitk::Exception& e)
   {
     emit DisconnectDeviceFinished(false, e.GetDescription());
   }
   emit DisconnectDeviceFinished(true, "");
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
index 7abaa1e9e3..b4804243c0 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
@@ -1,258 +1,257 @@
 /*===================================================================
 
 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 QmitkMITKIGTTrackingToolboxView_h
 #define QmitkMITKIGTTrackingToolboxView_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkFunctionality.h>
 
 #include "ui_QmitkMITKIGTTrackingToolboxViewControls.h"
 
 //mitk headers
 #include <mitkNavigationToolStorage.h>
 #include <mitkTrackingDeviceSource.h>
 #include <mitkNavigationDataObjectVisualizationFilter.h>
 #include <mitkNavigationDataRecorder.h>
 
 //QT headers
 #include <QTimer>
 
 class QmitkMITKIGTTrackingToolboxViewWorker;
 
 /*!
   \brief QmitkMITKIGTTrackingToolboxView
 
    This is the view of the bundle IGT Tracking Toolbox. The IGT Tracking Toolbox can be used to access tracking devices with MITK-IGT. The Tracking Toolbox can be used to log tracking data in     XML or CSV format for measurement purposes. The Tracking Toolbox further allows for visualization of tools with given surfaces in combination with the NaviagtionToolManager.
 
   \sa QmitkFunctionality
   \ingroup Functionalities
 */
 class QmitkMITKIGTTrackingToolboxView : public QmitkFunctionality
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkMITKIGTTrackingToolboxView();
     virtual ~QmitkMITKIGTTrackingToolboxView();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
 
     virtual void StdMultiWidgetNotAvailable();
 
   protected slots:
 
     /** @brief changes name of the filename when switching fileextension by radio button */
     void OnToggleFileExtension();
     /** @brief This slot is called if the user wants to load a new tool file. A new window opens where the user can choose a file. If the chosen file is
                corrupt or not valid the user gets an error message. If the file was loaded successfully the tools are show in the tool status widget. */
     void OnLoadTools();
 
     /** @brief This slot connects to the device. In status "connected" configuration of the device is disabled. */
     void OnConnect();
 
     /** @brief This slot disconnects from the device. */
     void OnDisconnect();
 
     /** @brief This slot tries to start tracking with the current device. If start tracking fails the user gets an error message and tracking stays off.*/
     void OnStartTracking();
 
     /** @brief This slot stops tracking. If tracking is not strated it does nothing.*/
     void OnStopTracking();
 
     /** @brief This slot is called if the user want's to choose a file name for logging. A new windows to navigate through the file system and choose
                a file opens.*/
     void OnChooseFileClicked();
 
     /** @brief This slot starts logging. Logging is only possible if a device is tracking. If not the logging mechanism start when the start tracking
                is called.*/
     void StartLogging();
 
     /** @brief This slot stops logging. If logging is not running it does nothing.*/
     void StopLogging();
 
     /** @brief This slot enables / disables UI elements depending on the tracking device after a device is changed.*/
     void OnTrackingDeviceChanged();
 
     /** @brief This slot selects the Tracking Volume appropriate for a given model */
     void OnTrackingVolumeChanged(QString qstr);
 
     /** @brief Shows or hides the tracking volume according to the checkboxe's state */
     void OnShowTrackingVolumeChanged();
 
     /** @brief This slot auto detects tools of a NDI Aurora tracking device. If tools where found they will be stored internally as a tool storage.
         The user is also asked if he wants to save this tool storage to load it later. Only call it if a Aurora device was configured because other
         devices don't support auto detection.*/
     void OnAutoDetectTools();
 
     /** @brief Slot for tracking timer. The timer updates the IGT pipline and also the logging filter if logging is activated.*/
     void UpdateTrackingTimer();
 
     /** @brief Resets the Tracking Tools: this means all tools are removed. */
     void OnResetTools();
 
     /** @brief Opens a dialog where a new navigation tool can be created. */
     void OnAddSingleTool();
 
     /** @brief This slot is called if the user finishes the creation of a new tool. */
     void OnAddSingleToolFinished();
 
     /** @brief This slot is called if the user cancels the creation of a new tool. */
     void OnAddSingleToolCanceled();
 
   protected slots:
 
    //help slots for enable/disable buttons
    void DisableLoggingButtons();
    void EnableLoggingButtons();
    void DisableOptionsButtons();
    void EnableOptionsButtons();
    void EnableTrackingConfigurationButtons();
    void DisableTrackingConfigurationButtons();
    void EnableTrackingControls();
    void DisableTrackingControls();
 
    //slots for worker thread
    void OnAutoDetectToolsFinished(bool success, QString errorMessage);
    void OnConnectFinished(bool success, QString errorMessage);
    void OnStartTrackingFinished(bool success, QString errorMessage);
    void OnStopTrackingFinished(bool success, QString errorMessage);
    void OnDisconnectFinished(bool success, QString errorMessage);
 
   protected:
 
     Ui::QmitkMITKIGTTrackingToolboxViewControls* m_Controls;
 
     QmitkStdMultiWidget* m_MultiWidget;
 
     bool m_tracking;    ///> bool which is true if tracking is running, false if not
     bool m_logging;     ///> bool which is true if logging is running, false if not
     int m_loggedFrames; ///> stores the current number of logged frames if logging is on
 
     mitk::NavigationToolStorage::Pointer m_toolStorage;  ///>stores the loaded tools
     mitk::DataNode::Pointer m_TrackingVolumeNode;        ///>holds the data node of the tracking volume if volume is visualized
     bool lastTrackingVolumeState;                        ///>temporary holds the state of the tracking volume (activated/not activated) during some methods
 
     QString m_ToolStorageFilename; ///>stores the filename of the current tool storage
 
     /** @brief Shows a message box with the text given as parameter. */
     void MessageBox(std::string s);
 
     /** @brief reinits the view globally. */
     void GlobalReinit();
 
    //members for the filter pipeline
    mitk::TrackingDeviceSource::Pointer m_TrackingDeviceSource; ///> member for the source of the IGT pipeline
    mitk::TrackingDeviceData m_TrackingDeviceData; ///> stores the tracking device data as long as this is not handled by the tracking device configuration widget
    mitk::NavigationDataObjectVisualizationFilter::Pointer m_ToolVisualizationFilter; ///> holds the tool visualization filter (second filter of the IGT pipeline)
    mitk::NavigationDataRecorder::Pointer m_loggingFilter; ///> holds the logging filter if logging is on (third filter of the IGT pipeline)
 
    /** @brief This timer updates the IGT pipline and also the logging filter if logging is activated.*/
    QTimer* m_TrackingTimer;
 
    /** Replaces the current navigation tool storage which is stored in m_toolStorage.
     *  Basically handles the microservice stuff: unregisteres the old storage, then
     *  replaces the storage and registers the new one.
     */
    void ReplaceCurrentToolStorage(mitk::NavigationToolStorage::Pointer newStorage, std::string newStorageName);
 
    /**
     * \brief Stores the properties of some QWidgets (and the tool storage file name) to QSettings.
     */
    void StoreUISettings();
 
    /**
     * \brief Loads the properties of some QWidgets (and the tool storage file name) from QSettings.
     */
    void LoadUISettings();
-
    //members for worker thread
    QThread* m_WorkerThread;
    QmitkMITKIGTTrackingToolboxViewWorker* m_Worker;
 };
 
 
 /**
  * Worker thread class for this view.
  */
 class QmitkMITKIGTTrackingToolboxViewWorker : public QObject
 {
   Q_OBJECT
 
 public:
   enum WorkerMethod{
     eAutoDetectTools = 0,
     eConnectDevice = 1,
     eStartTracking = 2,
     eStopTracking = 3,
     eDisconnectDevice = 4
   };
 
   void SetWorkerMethod(WorkerMethod w);
   void SetTrackingDevice(mitk::TrackingDevice::Pointer t);
   void SetDataStorage(mitk::DataStorage::Pointer d);
   void SetInverseMode(bool mode);
   void SetTrackingDeviceData(mitk::TrackingDeviceData d);
   void SetNavigationToolStorage(mitk::NavigationToolStorage::Pointer n);
 
   itkGetMacro(NavigationToolStorage,mitk::NavigationToolStorage::Pointer);
 
   itkGetMacro(TrackingDeviceSource,mitk::TrackingDeviceSource::Pointer);
   itkGetMacro(TrackingDeviceData,mitk::TrackingDeviceData);
   itkGetMacro(ToolVisualizationFilter,mitk::NavigationDataObjectVisualizationFilter::Pointer);
 
   public slots:
     void ThreadFunc();
 
   signals:
     void AutoDetectToolsFinished(bool success, QString errorMessage);
     void ConnectDeviceFinished(bool success, QString errorMessage);
     void StartTrackingFinished(bool success, QString errorMessage);
     void StopTrackingFinished(bool success, QString errorMessage);
     void DisconnectDeviceFinished(bool success, QString errorMessage);
 
 
   protected:
 
     mitk::TrackingDevice::Pointer m_TrackingDevice;
     WorkerMethod m_WorkerMethod;
     mitk::DataStorage::Pointer m_DataStorage;
     mitk::NavigationToolStorage::Pointer m_NavigationToolStorage;
 
     //members for the filter pipeline which is created in the worker thread during ConnectDevice()
     mitk::TrackingDeviceSource::Pointer m_TrackingDeviceSource; ///> member for the source of the IGT pipeline
     mitk::TrackingDeviceData m_TrackingDeviceData; ///> stores the tracking device data as long as this is not handled by the tracking device configuration widget
     mitk::NavigationDataObjectVisualizationFilter::Pointer m_ToolVisualizationFilter; ///> holds the tool visualization filter (second filter of the IGT pipeline)
     bool m_InverseMode;
 
     void AutoDetectTools();
     void ConnectDevice();
     void StartTracking();
     void StopTracking();
     void DisconnectDevice();
 };
 
 
 
 #endif // _QMITKMITKIGTTRACKINGTOOLBOXVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/mitkPluginActivator.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/mitkPluginActivator.cpp
index e5ccf3f4ed..dac2744b3f 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/mitkPluginActivator.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/mitkPluginActivator.cpp
@@ -1,52 +1,52 @@
 /*===================================================================
 
 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 "mitkPluginActivator.h"
 
 
 #include <QtPlugin>
 
 #include "QmitkMITKIGTNavigationToolManagerView.h"
 #include "QmitkMITKIGTTrackingToolboxView.h"
 #include "QmitkNavigationDataPlayerView.h"
 
-#include <mitkPersistenceService.h> //Workaround for bug in persistence module (see bug 16643 for details)
+//#include <mitkPersistenceService.h> //Workaround for bug in persistence module (see bug 16643 for details)
                                     //CAN BE REMOVED WHEN THE BUG IS FIXED
 
 namespace mitk {
 
 void PluginActivator::start(ctkPluginContext* context)
 {
-  //mitk::PersistenceService::LoadModule(); //Workaround for bug in persistence module (see bug 16643 for details)
+ // mitk::PersistenceService::LoadModule(); //Workaround for bug in persistence module (see bug 16643 for details)
                                           //CAN BE REMOVED WHEN THE BUG IS FIXED
 
 
   BERRY_REGISTER_EXTENSION_CLASS(QmitkMITKIGTNavigationToolManagerView, context)
   BERRY_REGISTER_EXTENSION_CLASS( QmitkMITKIGTTrackingToolboxView , context)
   BERRY_REGISTER_EXTENSION_CLASS( QmitkNavigationDataPlayerView , context)
 
 
 }
 
 void PluginActivator::stop(ctkPluginContext* context)
 {
   Q_UNUSED(context)
 }
 
 }
 
 Q_EXPORT_PLUGIN2(org_mitk_gui_qt_igttracking, mitk::PluginActivator)
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
index 95bbe072d1..47acbec684 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
+++ b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
@@ -1,369 +1,344 @@
 /*===================================================================
 
 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>
 
 //Mitk
 #include <mitkDataNode.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkIRenderingManager.h>
+#include <mitkImageGenerator.h>
 
 // Qmitk
 #include "UltrasoundSupport.h"
 #include <QTimer>
 
 // Qt
 #include <QMessageBox>
 
 // Ultrasound
 #include "mitkUSDevice.h"
 #include "QmitkUSAbstractCustomWidget.h"
 
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include "usServiceReference.h"
 #include "internal/org_mitk_gui_qt_ultrasound_Activator.h"
 
 const std::string UltrasoundSupport::VIEW_ID = "org.mitk.views.ultrasoundsupport";
 
 void UltrasoundSupport::SetFocus()
 {
 }
 
 void UltrasoundSupport::CreateQtPartControl( QWidget *parent )
 {
   m_Timer = new QTimer(this);
 
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
 
   connect( m_Controls.m_DeviceManagerWidget, SIGNAL(NewDeviceButtonClicked()), this, SLOT(OnClickedAddNewDevice()) ); // Change Widget Visibilities
   connect( m_Controls.m_DeviceManagerWidget, SIGNAL(NewDeviceButtonClicked()), this->m_Controls.m_NewVideoDeviceWidget, SLOT(CreateNewDevice()) ); // Init NewDeviceWidget
+  connect( m_Controls.m_ActiveVideoDevices, SIGNAL(ServiceSelectionChanged(us::ServiceReferenceU)), this, SLOT(OnChangedActiveDevice()) );
+  connect( m_Controls.m_ShowImageStream, SIGNAL(clicked()), this, SLOT(OnChangedActiveDevice()) );
   connect( m_Controls.m_NewVideoDeviceWidget, SIGNAL(Finished()), this, SLOT(OnNewDeviceWidgetDone()) ); // After NewDeviceWidget finished editing
-  connect( m_Controls.m_BtnView, SIGNAL(clicked()), this, SLOT(OnClickedViewDevice()) );
   connect( m_Controls.m_FrameRate, SIGNAL(valueChanged(int)), this, SLOT(OnChangedFramerateLimit(int)) );
   connect( m_Controls.m_FreezeButton, SIGNAL(clicked()), this, SLOT(OnClickedFreezeButton()) );
   connect( m_Timer, SIGNAL(timeout()), this, SLOT(DisplayImage()));
   connect( m_Controls.m_ActiveVideoDevices, SIGNAL( ServiceSelectionChanged(us::ServiceReferenceU) ), this, SLOT(OnActiveDeviceSelectionChanged(us::ServiceReferenceU)) );
 
   // Initializations
   m_Controls.m_NewVideoDeviceWidget->setVisible(false);
   std::string filter = "(&(" + us::ServiceConstants::OBJECTCLASS() + "="
       + "org.mitk.services.UltrasoundDevice)("
       + mitk::USDevice::GetPropertyKeys().US_PROPKEY_ISACTIVE + "=true))";
   m_Controls.m_ActiveVideoDevices->Initialize<mitk::USDevice>(
         mitk::USDevice::GetPropertyKeys().US_PROPKEY_LABEL ,filter);
-
   m_Controls.m_ActiveVideoDevices->SetAutomaticallySelectFirstEntry(true);
 
-  m_Node = this->GetDataStorage()->GetNamedNode("US Image Stream");
+  // Create Node for US Stream
   if (m_Node.IsNull())
   {
-    // Create Node for US Stream
     m_Node = mitk::DataNode::New();
-    m_Node->SetName("US Image Stream");
-    this->GetDataStorage()->Add(m_Node);
+    m_Node->SetName("US Support Viewing Stream");
+    //create a dummy image (gray values 0..255) for correct initialization of level window, etc.
+    mitk::Image::Pointer dummyImage = mitk::ImageGenerator::GenerateRandomImage<float>(100, 100, 1, 1, 1, 1, 1, 255,0);
+    m_Node->SetData(dummyImage);
   }
 
   m_Controls.tabWidget->setTabEnabled(1, false);
 }
 
 void UltrasoundSupport::OnClickedAddNewDevice()
 {
   m_Controls.m_NewVideoDeviceWidget->setVisible(true);
   m_Controls.m_DeviceManagerWidget->setVisible(false);
   m_Controls.m_Headline->setText("Add New Video Device:");
   m_Controls.m_WidgetActiveDevices->setVisible(false);
 }
 
 void UltrasoundSupport::DisplayImage()
 {
+  //Update device
   m_Device->Modified();
   m_Device->Update();
 
+  //Update data node
   mitk::Image::Pointer curOutput = m_Device->GetOutput();
+  m_Node->SetData(curOutput);
 
-  if ( m_ImageAlreadySetToNode && ( curOutput.GetPointer() != m_Node->GetData() ) )
-  {
-    MITK_INFO << "Data Node of the ultrasound image stream was changed by another plugin. Stop viewing.";
-    this->StopViewing();
-    return;
-  }
-
-  if (! m_ImageAlreadySetToNode && curOutput.IsNotNull() && curOutput->IsInitialized())
+  //Only update the view if the image is shown
+  if(m_Controls.m_ShowImageStream->isChecked())
   {
-    m_Node->SetData(curOutput);
-    m_ImageAlreadySetToNode = true;
-  }
-
-  this->RequestRenderWindowUpdate();
-
-  if ( curOutput->GetDimension() > 1
-    && (curOutput->GetDimension(0) != m_CurrentImageWidth
-    || curOutput->GetDimension(1) != m_CurrentImageHeight) )
-  {
-    // make a reinit on the ultrasound image
-    mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
-    if ( renderWindow != NULL && curOutput->GetTimeGeometry()->IsValid() )
+    this->RequestRenderWindowUpdate();
+    if ( curOutput->GetDimension() > 1
+      && (curOutput->GetDimension(0) != m_CurrentImageWidth
+      || curOutput->GetDimension(1) != m_CurrentImageHeight) )
     {
-      renderWindow->GetRenderingManager()->InitializeViews(
-        curOutput->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
-      renderWindow->GetRenderingManager()->RequestUpdateAll();
+      // make a reinit on the ultrasound image
+      mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
+      if ( renderWindow != NULL && curOutput->GetTimeGeometry()->IsValid() )
+      {
+        renderWindow->GetRenderingManager()->InitializeViews(
+          curOutput->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+        renderWindow->GetRenderingManager()->RequestUpdateAll();
+      }
+
+      m_CurrentImageWidth = curOutput->GetDimension(0);
+      m_CurrentImageHeight = curOutput->GetDimension(1);
     }
-
-    m_CurrentImageWidth = curOutput->GetDimension(0);
-    m_CurrentImageHeight = curOutput->GetDimension(1);
   }
 
+  //Update frame counter
   m_FrameCounter ++;
   if (m_FrameCounter == 10)
   {
     int nMilliseconds = m_Clock.restart();
     int fps = 10000.0f / (nMilliseconds );
     m_Controls.m_FramerateLabel->setText("Current Framerate: "+ QString::number(fps) +" FPS");
     m_FrameCounter = 0;
   }
 }
 
-void UltrasoundSupport::OnClickedViewDevice()
-{
-  m_FrameCounter = 0;
-  // We use the activity state of the timer to determine whether we are currently viewing images
-  if ( ! m_Timer->isActive() ) // Activate Imaging
-  {
-    this->StartViewing();
-  }
-  else //deactivate imaging
-  {
-    this->StopViewing();
-  }
-}
-
 void UltrasoundSupport::OnChangedFramerateLimit(int value)
 {
   m_Timer->setInterval(1000 / value);
 }
 
 void UltrasoundSupport::OnClickedFreezeButton()
 {
   if ( m_Device.IsNull() )
   {
     MITK_WARN("UltrasoundSupport") << "Freeze button clicked though no device is selected.";
     return;
   }
 
   if ( m_Device->GetIsFreezed() )
   {
     m_Device->SetIsFreezed(false);
     m_Controls.m_FreezeButton->setText("Freeze");
   }
   else
   {
     m_Device->SetIsFreezed(true);
     m_Controls.m_FreezeButton->setText("Start Viewing Again");
   }
 }
 
-void UltrasoundSupport::OnNewDeviceWidgetDone()
-{
-  m_Controls.m_NewVideoDeviceWidget->setVisible(false);
-  m_Controls.m_DeviceManagerWidget->setVisible(true);
-  m_Controls.m_Headline->setText("Ultrasound Devices:");
-  m_Controls.m_WidgetActiveDevices->setVisible(true);
-}
-
-void UltrasoundSupport::StartViewing()
+void UltrasoundSupport::OnChangedActiveDevice()
 {
-  m_ImageAlreadySetToNode = false;
-
-  m_Controls.tabWidget->setTabEnabled(1, true);
-  m_Controls.tabWidget->setCurrentIndex(1);
-
-  //get device & set data node
-  m_Device = m_Controls.m_ActiveVideoDevices->GetSelectedService<mitk::USDevice>();
-  if (m_Device.IsNull())
+//clean up and stop timer
+m_Timer->stop();
+this->RemoveControlWidgets();
+this->GetDataStorage()->Remove(m_Node);
+m_Node->ReleaseData();
+
+//get current device, abort if it is invalid
+m_Device = m_Controls.m_ActiveVideoDevices->GetSelectedService<mitk::USDevice>();
+if (m_Device.IsNull())
   {
-    m_Timer->stop();
+    MITK_WARN << "Selected device is not valid, aborting";
+    m_Controls.tabWidget->setTabEnabled(1, false);
     return;
   }
 
-  //start timer
-  int interval = (1000 / m_Controls.m_FrameRate->value());
-  m_Timer->setInterval(interval);
-  m_Timer->start();
+//create the widgets for this device and enable the widget tab
+this->CreateControlWidgets();
+m_Controls.tabWidget->setTabEnabled(1, true);
 
-  //change UI elements
-  m_Controls.m_BtnView->setText("Stop Viewing");
+//show node if the option is enabled
+if(m_Controls.m_ShowImageStream->isChecked())
+  {this->GetDataStorage()->Add(m_Node);}
 
-  this->CreateControlWidgets();
+//start timer
+int interval = (1000 / m_Controls.m_FrameRate->value());
+m_Timer->setInterval(interval);
+m_Timer->start();
 }
 
-void UltrasoundSupport::StopViewing()
+void UltrasoundSupport::OnNewDeviceWidgetDone()
 {
-  m_Controls.tabWidget->setTabEnabled(1, false);
-
-  this->RemoveControlWidgets();
-
-  //stop timer & release data
-  m_Timer->stop();
-  m_Node->ReleaseData();
-  this->RequestRenderWindowUpdate();
-
-  //change UI elements
-  m_Controls.m_BtnView->setText("Start Viewing");
+  m_Controls.m_NewVideoDeviceWidget->setVisible(false);
+  m_Controls.m_DeviceManagerWidget->setVisible(true);
+  m_Controls.m_Headline->setText("Ultrasound Devices:");
+  m_Controls.m_WidgetActiveDevices->setVisible(true);
 }
 
 void UltrasoundSupport::CreateControlWidgets()
 {
   m_ControlProbesWidget = new QmitkUSControlsProbesWidget(m_Device->GetControlInterfaceProbes(), m_Controls.m_ToolBoxControlWidgets);
   m_Controls.probesWidgetContainer->addWidget(m_ControlProbesWidget);
 
   // create b mode widget for current device
   m_ControlBModeWidget = new QmitkUSControlsBModeWidget(m_Device->GetControlInterfaceBMode(), m_Controls.m_ToolBoxControlWidgets);
   m_Controls.m_ToolBoxControlWidgets->addItem(m_ControlBModeWidget, "B Mode Controls");
   if ( ! m_Device->GetControlInterfaceBMode() )
   {
     m_Controls.m_ToolBoxControlWidgets->setItemEnabled(m_Controls.m_ToolBoxControlWidgets->count()-1, false);
   }
 
   // create doppler widget for current device
   m_ControlDopplerWidget = new QmitkUSControlsDopplerWidget(m_Device->GetControlInterfaceDoppler(), m_Controls.m_ToolBoxControlWidgets);
   m_Controls.m_ToolBoxControlWidgets->addItem(m_ControlDopplerWidget, "Doppler Controls");
   if ( ! m_Device->GetControlInterfaceDoppler() )
   {
     m_Controls.m_ToolBoxControlWidgets->setItemEnabled(m_Controls.m_ToolBoxControlWidgets->count()-1, false);
   }
 
   ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
   if ( pluginContext )
   {
     std::string filter = "(ork.mitk.services.UltrasoundCustomWidget.deviceClass=" + m_Device->GetDeviceClass() + ")";
 
     QString interfaceName ( us_service_interface_iid<QmitkUSAbstractCustomWidget>() );
     m_CustomWidgetServiceReference = pluginContext->getServiceReferences(interfaceName, QString::fromStdString(filter));
 
     if (m_CustomWidgetServiceReference.size() > 0)
     {
       m_ControlCustomWidget = pluginContext->getService<QmitkUSAbstractCustomWidget>
         (m_CustomWidgetServiceReference.at(0))->CloneForQt(m_Controls.tab2);
       m_ControlCustomWidget->SetDevice(m_Device);
       m_Controls.m_ToolBoxControlWidgets->addItem(m_ControlCustomWidget, "Custom Controls");
     }
     else
     {
       m_Controls.m_ToolBoxControlWidgets->addItem(new QWidget(m_Controls.m_ToolBoxControlWidgets), "Custom Controls");
       m_Controls.m_ToolBoxControlWidgets->setItemEnabled(m_Controls.m_ToolBoxControlWidgets->count()-1, false);
     }
   }
 
   // select first enabled control widget
   for ( int n = 0; n < m_Controls.m_ToolBoxControlWidgets->count(); ++n)
   {
     if ( m_Controls.m_ToolBoxControlWidgets->isItemEnabled(n) )
     {
       m_Controls.m_ToolBoxControlWidgets->setCurrentIndex(n);
       break;
     }
   }
 }
 
 void UltrasoundSupport::RemoveControlWidgets()
 {
+  if(!m_ControlProbesWidget) {return;} //widgets do not exist... nothing to do
+
   // remove all control widgets from the tool box widget
   while (m_Controls.m_ToolBoxControlWidgets->count() > 0)
   {
     m_Controls.m_ToolBoxControlWidgets->removeItem(0);
   }
 
   // remove probes widget (which is not part of the tool box widget)
   m_Controls.probesWidgetContainer->removeWidget(m_ControlProbesWidget);
   delete m_ControlProbesWidget;
   m_ControlProbesWidget = 0;
 
   delete m_ControlBModeWidget;
   m_ControlBModeWidget = 0;
 
   delete m_ControlDopplerWidget;
   m_ControlDopplerWidget = 0;
 
   // delete custom widget if it is present
   if ( m_ControlCustomWidget )
   {
     ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
     delete m_ControlCustomWidget; m_ControlCustomWidget = 0;
 
     if ( m_CustomWidgetServiceReference.size() > 0 )
     {
       pluginContext->ungetService(m_CustomWidgetServiceReference.at(0));
     }
   }
 }
 
+
 void UltrasoundSupport::OnDeciveServiceEvent(const ctkServiceEvent event)
 {
   if ( m_Device.IsNull() || event.getType() != us::ServiceEvent::MODIFIED ) { return; }
 
   ctkServiceReference service = event.getServiceReference();
 
   if ( m_Device->GetManufacturer() != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_MANUFACTURER)).toString().toStdString()
     && m_Device->GetName() != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_NAME)).toString().toStdString() )
   {
     return;
   }
 
   if ( ! m_Device->GetIsActive() && m_Timer->isActive() )
   {
-    this->StopViewing();
+    m_Timer->stop();
   }
 
   if ( m_CurrentDynamicRange != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DYNAMIC_RANGE)).toDouble() )
   {
     m_CurrentDynamicRange = service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DYNAMIC_RANGE)).toDouble();
 
     // update level window for the current dynamic range
     mitk::LevelWindow levelWindow;
     m_Node->GetLevelWindow(levelWindow);
     levelWindow.SetAuto(m_Image, true, true);
     m_Node->SetLevelWindow(levelWindow);
   }
 }
 
 void UltrasoundSupport::OnActiveDeviceSelectionChanged(us::ServiceReferenceU reference)
 {
   m_Controls.m_BtnView->setEnabled(reference);
 }
 
 UltrasoundSupport::UltrasoundSupport()
 : m_ControlCustomWidget(0), m_ControlBModeWidget(0),
   m_ControlProbesWidget(0), m_ImageAlreadySetToNode(false),
   m_CurrentImageWidth(0), m_CurrentImageHeight(0)
 {
   ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
 
   if ( pluginContext )
   {
     // to be notified about service event of an USDevice
     pluginContext->connectServiceListener(this, "OnDeciveServiceEvent",
       QString::fromStdString("(" + us::ServiceConstants::OBJECTCLASS() + "=" + us_service_interface_iid<mitk::USDevice>() + ")"));
   }
 }
 
 UltrasoundSupport::~UltrasoundSupport()
 {
 }
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.h b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.h
index 1fbfbcb915..b91a327b3f 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.h
+++ b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.h
@@ -1,130 +1,127 @@
 /*===================================================================
 
 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 UltrasoundSupport_h
 #define UltrasoundSupport_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_UltrasoundSupportControls.h"
 #include "QmitkUSAbstractCustomWidget.h"
 #include "QmitkUSControlsBModeWidget.h"
 #include "QmitkUSControlsDopplerWidget.h"
 #include "QmitkUSControlsProbesWidget.h"
 
 #include <QTime>
 
 #include <ctkServiceEvent.h>
 
 /*!
 \brief UltrasoundSupport
 This plugin provides functionality to manage Ultrasound devices, create video devices and to view device images.
 
 \sa QmitkFunctionality
 \ingroup ${plugin_target}_internal
 */
 class UltrasoundSupport : public QmitkAbstractView
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   virtual void SetFocus();
 
   static const std::string VIEW_ID;
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   UltrasoundSupport();
   virtual ~UltrasoundSupport();
 
   public slots:
     /*
     * \brief This is called when the newDeviceWidget is closed
     */
     void OnNewDeviceWidgetDone();
 
     protected slots:
 
       void OnClickedAddNewDevice();
 
-      void OnClickedViewDevice();
-
       void OnChangedFramerateLimit(int);
 
+      void OnChangedActiveDevice();
+
       void OnClickedFreezeButton();
 
       void OnDeciveServiceEvent(const ctkServiceEvent event);
 
       /*
        *\brief Called, when the selection in the list of the active devices changes.
        */
       void OnActiveDeviceSelectionChanged(us::ServiceReferenceU reference);
 
       /*
       * \brief This is the main imaging loop that is called regularily during the imaging process
       */
       void DisplayImage();
 
 protected:
 
-  void StartViewing();
-  void StopViewing();
-
   void CreateControlWidgets();
   void RemoveControlWidgets();
 
   int m_FrameCounter;
 
   /*
   * \brief This timer triggers periodic updates to the pipeline
   */
   QTimer* m_Timer;
 
   QTime   m_Clock;
 
   /*
   * \brief The device that is currently used to aquire images
   */
   mitk::USDevice::Pointer m_Device;
 
   /*
   * \brief The node that we feed images into
   */
   mitk::DataNode::Pointer m_Node;
 
   mitk::Image::Pointer m_Image;
 
   Ui::UltrasoundSupportControls m_Controls;
 
   QmitkUSAbstractCustomWidget*  m_ControlCustomWidget;
   QmitkUSControlsBModeWidget*   m_ControlBModeWidget;
   QmitkUSControlsDopplerWidget* m_ControlDopplerWidget;
   QmitkUSControlsProbesWidget*  m_ControlProbesWidget;
 
   QList<ctkServiceReference>    m_CustomWidgetServiceReference;
 
   bool m_ImageAlreadySetToNode;
   unsigned int m_CurrentImageWidth;
   unsigned int m_CurrentImageHeight;
   double m_CurrentDynamicRange;
 };
 
 #endif // UltrasoundSupport_h
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupportControls.ui b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupportControls.ui
index 8c2394e387..42f1163706 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupportControls.ui
+++ b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupportControls.ui
@@ -1,270 +1,260 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>UltrasoundSupportControls</class>
  <widget class="QWidget" name="UltrasoundSupportControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>410</width>
-    <height>172</height>
+    <height>241</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_3">
    <property name="margin">
     <number>2</number>
    </property>
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <property name="documentMode">
       <bool>true</bool>
      </property>
      <property name="tabsClosable">
       <bool>false</bool>
      </property>
      <property name="movable">
       <bool>false</bool>
      </property>
      <widget class="QWidget" name="tab">
       <attribute name="title">
        <string>Device Management</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_2">
        <property name="margin">
         <number>0</number>
        </property>
        <item>
         <widget class="QWidget" name="m_WidgetDevices" native="true">
          <layout class="QVBoxLayout" name="verticalLayout_4">
           <item>
            <widget class="QWidget" name="m_WidgetAvailableDevices" native="true">
             <layout class="QVBoxLayout" name="verticalLayout_5">
              <item>
               <widget class="QLabel" name="m_Headline">
                <property name="font">
                 <font>
                  <pointsize>12</pointsize>
                  <weight>75</weight>
                  <bold>true</bold>
                 </font>
                </property>
                <property name="text">
                 <string>Ultrasound Devices:</string>
                </property>
               </widget>
              </item>
              <item>
               <widget class="QmitkUSNewVideoDeviceWidget" name="m_NewVideoDeviceWidget" native="true"/>
              </item>
              <item>
               <widget class="QmitkUSDeviceManagerWidget" name="m_DeviceManagerWidget" native="true"/>
              </item>
             </layout>
            </widget>
           </item>
           <item>
            <widget class="QWidget" name="m_WidgetActiveDevices" native="true">
             <layout class="QVBoxLayout" name="verticalLayout">
              <item>
               <widget class="QLabel" name="m_HeadlineActive">
                <property name="font">
                 <font>
                  <pointsize>10</pointsize>
                  <weight>75</weight>
                  <bold>true</bold>
                 </font>
                </property>
                <property name="text">
                 <string>Active Ultrasound Devices:</string>
                </property>
               </widget>
              </item>
              <item>
               <widget class="QmitkServiceListWidget" name="m_ActiveVideoDevices" native="true">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
               </widget>
              </item>
              <item>
               <layout class="QHBoxLayout" name="horizontalLayout_2">
                <item>
-                <widget class="QPushButton" name="m_BtnView">
-                 <property name="enabled">
-                  <bool>false</bool>
-                 </property>
-                 <property name="minimumSize">
-                  <size>
-                   <width>120</width>
-                   <height>0</height>
-                  </size>
-                 </property>
+                <widget class="QCheckBox" name="m_ShowImageStream">
                  <property name="text">
-                  <string>Start Viewing</string>
+                  <string>Show Image Stream</string>
                  </property>
-                 <property name="icon">
-                  <iconset resource="../../../../Modules/USUI/resources/USUI.qrc">
-                   <normaloff>:/USUI/accept.png</normaloff>:/USUI/accept.png</iconset>
+                 <property name="checked">
+                  <bool>true</bool>
                  </property>
                 </widget>
                </item>
               </layout>
              </item>
             </layout>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab2">
       <property name="enabled">
        <bool>false</bool>
       </property>
       <attribute name="title">
        <string>US Imaging</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_6">
        <property name="margin">
         <number>2</number>
        </property>
        <item>
         <layout class="QVBoxLayout" name="probesWidgetContainer"/>
        </item>
        <item>
         <widget class="QToolBox" name="m_ToolBoxControlWidgets"/>
        </item>
        <item>
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item>
         <widget class="Line" name="line_2">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QPushButton" name="m_FreezeButton">
          <property name="text">
           <string>Freeze</string>
          </property>
          <property name="icon">
           <iconset resource="../../../../Modules/USUI/resources/USUI.qrc">
            <normaloff>:/USUI/system-lock-screen.png</normaloff>:/USUI/system-lock-screen.png</iconset>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="label_3">
          <property name="text">
           <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:8pt; font-weight:600;&quot;&gt;Framrate Settings:&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="m_FramerateLabel">
          <property name="text">
           <string>Current Framerate: 0 FPS</string>
          </property>
         </widget>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout">
          <item>
           <widget class="QLabel" name="label_2">
            <property name="text">
             <string>Framerate Limit:</string>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QSpinBox" name="m_FrameRate">
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>50</number>
            </property>
            <property name="value">
             <number>30</number>
            </property>
           </widget>
          </item>
         </layout>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>QmitkUSDeviceManagerWidget</class>
    <extends>QWidget</extends>
    <header>QmitkUSDeviceManagerWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkUSNewVideoDeviceWidget</class>
    <extends>QWidget</extends>
    <header>QmitkUSNewVideoDeviceWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkServiceListWidget</class>
    <extends>QWidget</extends>
    <header>QmitkServiceListWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources>
   <include location="../../../../Modules/USUI/resources/USUI.qrc"/>
  </resources>
  <connections/>
 </ui>