diff --git a/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.cpp b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.cpp
new file mode 100644
index 0000000000..b5ca3695ea
--- /dev/null
+++ b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.cpp
@@ -0,0 +1,70 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+#include <QmitkIGTCommonHelper.h>
+#include <QSettings>
+#include <QFileInfo>
+
+const std::string QmitkIGTCommonHelper::VIEW_ID = "org.mitk.views.igtcommonhelper";
+
+void QmitkIGTCommonHelper::SetLastFileSavePath(const QString &str)
+{
+  QSettings settings;
+  settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
+  settings.setValue("LastFileSavePath",QVariant(str));
+  settings.endGroup();
+}
+
+void QmitkIGTCommonHelper::SetLastFileSavePathByFileName(const QString &str)
+{
+  QFileInfo file(str);
+  SetLastFileSavePath(file.absolutePath());
+}
+
+const QString QmitkIGTCommonHelper::GetLastFileSavePath()
+{
+  QString path = "";
+  QSettings settings;
+  settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
+  path = settings.value("LastFileSavePath",QString("")).toString();
+  settings.endGroup();
+
+  return path;
+}
+
+void QmitkIGTCommonHelper::SetLastFileLoadPath(const QString &str)
+{
+  QSettings settings;
+  settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
+  settings.setValue("LastFileLoadPath",QVariant(str));
+  settings.endGroup();
+}
+
+void QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(const QString &str)
+{
+  QFileInfo file(str);
+  SetLastFileLoadPath(file.absolutePath());
+}
+
+const QString QmitkIGTCommonHelper::GetLastFileLoadPath()
+{
+  QString path = "";
+  QSettings settings;
+  settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
+  path = settings.value("LastFileLoadPath",QString("")).toString();
+  settings.endGroup();
+
+  return path;
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.h b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.h
new file mode 100644
index 0000000000..486569833b
--- /dev/null
+++ b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.h
@@ -0,0 +1,47 @@
+/*===================================================================
+
+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 QmitkIGTCommonHelper_H
+#define QmitkIGTCommonHelper_H
+
+#include "MitkIGTUIExports.h"
+#include <QString>
+
+ /** Documentation:
+  *   \brief Simple and fast access to a pre-configured TrackingDeviceSource.
+  *
+  *   \ingroup IGTUI
+  */
+class MITKIGTUI_EXPORT QmitkIGTCommonHelper
+{
+
+public:
+
+  static const std::string VIEW_ID;
+
+  static void SetLastFileSavePath(const QString& str);
+
+  static void SetLastFileSavePathByFileName(const QString& str);
+
+  static const QString GetLastFileSavePath();
+
+  static void SetLastFileLoadPath(const QString& str);
+
+  static void SetLastFileLoadPathByFileName(const QString& str);
+
+  static const QString GetLastFileLoadPath();
+};
+#endif
+
diff --git a/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp b/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp
index 49ff862922..48596f3d74 100644
--- a/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp
@@ -1,213 +1,215 @@
 /*===================================================================
 
 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 "QmitkIGTConnectionWidget.h"
 #include "QmitkTrackingDeviceConfigurationWidget.h"
 
 #include "mitkClaronTrackingDevice.h"
 #include "mitkNDITrackingDevice.h"
 #include "mitkOptitrackTrackingDevice.h"
 
 #include "mitkNavigationToolStorageDeserializer.h"
 #include "mitkTrackingDeviceSourceConfigurator.h"
+#include "QmitkIGTCommonHelper.h"
 
 #include <QFileDialog>
 #include <QMessageBox>
 
 const std::string QmitkIGTConnectionWidget::VIEW_ID = "org.mitk.views.igtconnectionwidget";
 
 QmitkIGTConnectionWidget::QmitkIGTConnectionWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f)
 {
   m_Controls = NULL;
   CreateQtPartControl(this);
   CreateConnections();
   m_TrackingDevice = NULL;
   m_TrackingDeviceSource = NULL;
   m_NavigationToolStorage = NULL;
   m_DataStorage = NULL;
   m_ErrorMessage = "";
 }
 
 
 QmitkIGTConnectionWidget::~QmitkIGTConnectionWidget()
 {
 }
 
 void QmitkIGTConnectionWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
   // create GUI widgets
   m_Controls = new Ui::QmitkIGTConnectionWidgetControls;
   m_Controls->setupUi(parent);
   }
 }
 
 void QmitkIGTConnectionWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->connectButton), SIGNAL(clicked()), this, SLOT(OnConnect()) );
   }
 }
 
 void QmitkIGTConnectionWidget::OnConnect()
 {
   if (m_Controls->connectButton->isChecked()) // Load tools and connect tracking device
   {
     m_Controls->connectButton->setChecked(false);
     // create TrackingDevice
     m_TrackingDevice = m_Controls->trackingDeviceConfigurationWidget->GetTrackingDevice();
     if (m_TrackingDevice.IsNotNull())
     {
-      QString fileName = QFileDialog::getOpenFileName(NULL,tr("Open Navigation tool storage"), "/", tr("Toolfile (*.tfl)"));
+      QString fileName = QFileDialog::getOpenFileName(NULL,tr("Open Navigation tool storage"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("Toolfile (*.tfl)"));
+      QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(fileName);
       if (LoadToolfile(fileName))
       {
         // Create TrackingDeviceSource and add tools
         mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory =
           mitk::TrackingDeviceSourceConfigurator::New(this->m_NavigationToolStorage,m_TrackingDevice);
         m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource();
         m_TrackingDeviceSource->Connect();
         m_TrackingDeviceSource->StartTracking();
         // change button text
         m_Controls->connectButton->setText("Disconnect");
         m_Controls->connectButton->setChecked(true);
         // disable configuration widget
         m_Controls->trackingDeviceConfigurationWidget->setEnabled(false);
         // emit connected signal
         emit TrackingDeviceConnected();
       }
       else
       {
         QString error(m_ErrorMessage.c_str());
         QMessageBox::warning(NULL,"Warning",error);
         // reset button to unchecked
         m_Controls->connectButton->setChecked(false);
         // remove tool nodes from DataStorage
         this->RemoveToolNodes();
         // reset NavigationToolStorage
         m_NavigationToolStorage = NULL;
       }
     }
     else
     {
       // reset button to unchecked
       m_Controls->connectButton->setChecked(false);
       MITK_ERROR<<"Could not create TrackingDevice";
     }
   }
   else // Disconnect tracking device
   {
     // disconnect TrackingDeviceSource
     if (m_TrackingDeviceSource.IsNotNull())
     {
       m_TrackingDeviceSource->StopTracking();
       m_TrackingDeviceSource->Disconnect();
     }
     // remove tool nodes from DataStorage
     this->RemoveToolNodes();
     // reset members
     m_NavigationToolStorage = NULL;
     m_TrackingDevice = NULL;
     m_TrackingDeviceSource = NULL;
     // change button text
     m_Controls->connectButton->setText("Connect");
     // enable configuration widget
     m_Controls->trackingDeviceConfigurationWidget->setEnabled(true);
     // emit disconnected signal
     emit TrackingDeviceDisconnected();
   }
 }
 
 bool QmitkIGTConnectionWidget::LoadToolfile(QString qFilename)
 {
   if (m_DataStorage.IsNotNull())
   {
     std::string filename = qFilename.toStdString();
     mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(this->m_DataStorage);
     mitk::NavigationToolStorage::Pointer tempStorage = myDeserializer->Deserialize(filename);
     m_NavigationToolStorage = tempStorage;
 
     if (tempStorage.IsNull())
     {
       m_ErrorMessage = myDeserializer->GetErrorMessage();
       return false;
     }
 
     // check if there are tools in the storage
     mitk::TrackingDeviceType lastDevice;
     if (tempStorage->GetToolCount()>0)
     {
       lastDevice = tempStorage->GetTool(0)->GetTrackingDeviceType();
     }
     else
     {
       m_ErrorMessage = "Error: Didn't find a tool in the storage. Do you want to navigate without even an instrument?";
       return false;
     }
     //check if all tools are from the same device
     for (int i=1; i<tempStorage->GetToolCount(); i++)
     {
       if (lastDevice!=tempStorage->GetTool(i)->GetTrackingDeviceType())
       {
         m_ErrorMessage = "Error: Toolfile contains tools of different tracking devices which is not acceptable for this application.";
         return false;
       }
       else lastDevice = tempStorage->GetTool(i)->GetTrackingDeviceType();
     }
     // check if tracking device typ of tools corresponds with chosen tracking device
     if (m_TrackingDevice->GetType()!=tempStorage->GetTool(0)->GetTrackingDeviceType())
     {
       m_ErrorMessage = "Tools are not compliant with this tracking device. Please use correct toolfile for specified device.";
       return false;
     }
     m_NavigationToolStorage = tempStorage;
     return true;
   }
   else
   {
     m_ErrorMessage = "Error: No DataStorage available! Make sure the widget is initialized with a DataStorage";
     return false;
   }
 }
 
 void QmitkIGTConnectionWidget::RemoveToolNodes()
 {
   for (int i=0; i<m_NavigationToolStorage->GetToolCount(); i++)
   {
     mitk::DataNode::Pointer currentNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
     if (currentNode.IsNotNull())
     {
       m_DataStorage->Remove(currentNode);
     }
   }
 }
 
 mitk::TrackingDeviceSource::Pointer QmitkIGTConnectionWidget::GetTrackingDeviceSource()
 {
   return m_TrackingDeviceSource;
 }
 
 void QmitkIGTConnectionWidget::SetDataStorage( mitk::DataStorage::Pointer dataStorage )
 {
   m_DataStorage = dataStorage;
 }
 
 mitk::NavigationToolStorage::Pointer QmitkIGTConnectionWidget::GetNavigationToolStorage()
 {
   return m_NavigationToolStorage;
 }
diff --git a/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
index 5f8fbf1aa1..1357f5c542 100644
--- a/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
@@ -1,573 +1,575 @@
 /*===================================================================
 
 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 "QmitkIGTPlayerWidget.h"
 
 //mitk headers
 #include "mitkTrackingTypes.h"
 #include <mitkSurface.h>
 #include <mitkNavigationToolReader.h>
 #include <mitkNavigationToolWriter.h>
 #include <mitkNavigationToolStorage.h>
 #include <mitkNavigationToolStorageDeserializer.h>
 #include <mitkNavigationToolStorageSerializer.h>
 #include <mitkIGTException.h>
 #include <mitkIOUtil.h>
+#include <QmitkIGTCommonHelper.h>
 
 //qt headers
 #include <qfiledialog.h>
 #include <qmessagebox.h>
 #include <qtimer.h>
 
 QmitkIGTPlayerWidget::QmitkIGTPlayerWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f),
   m_RealTimePlayer(mitk::NavigationDataPlayer::New()),
   m_SequentialPlayer(mitk::NavigationDataSequentialPlayer::New()),
   m_StartTime(-1.0),
   m_CurrentSequentialPointNumber(0),
   m_Controls(new Ui::QmitkIGTPlayerWidgetControls)
 {
   m_Controls->setupUi(this);
   m_PlayingTimer = new QTimer(this); // initialize update timer
 
   CreateConnections();
 
   m_Controls->samplePositionHorizontalSlider->setVisible(false);
 
   this->ResetLCDNumbers(); // reset lcd numbers at start
 }
 
 QmitkIGTPlayerWidget::~QmitkIGTPlayerWidget()
 {
   m_PlayingTimer->stop();
 
   delete m_Controls;
 }
 
 void QmitkIGTPlayerWidget::CreateConnections()
 {
   connect( (QObject*)(m_Controls->playPushButton), SIGNAL(clicked(bool)), this, SLOT(OnPlayButtonClicked(bool)) ); // play button
   connect( (QObject*)(m_PlayingTimer), SIGNAL(timeout()), this, SLOT(OnPlaying()) ); // update timer
   connect( (QObject*) (m_Controls->beginPushButton), SIGNAL(clicked()), this, SLOT(OnGoToBegin()) ); // reset player and go to begin
   connect( (QObject*) (m_Controls->stopPushButton), SIGNAL(clicked()), this, SLOT(OnGoToEnd()) ); // reset player
   // pass this widgets protected combobox signal to public signal
   connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
   // pass this widgets protected checkbox signal to public signal
   connect( m_Controls->splineModeCheckBox, SIGNAL(toggled(bool)), this, SIGNAL(SignalSplineModeToggled(bool)) );
   //connect( m_Controls->sequencialModeCheckBox, SIGNAL(toggled(bool)), this, SLOT(OnSequencialModeToggled(bool)) );
 
   connect( m_Controls->samplePositionHorizontalSlider, SIGNAL(sliderPressed()), this, SLOT(OnSliderPressed()) );
   connect( m_Controls->samplePositionHorizontalSlider, SIGNAL(sliderReleased()), this, SLOT(OnSliderReleased()) );
 
   connect( m_Controls->m_OpenFileButton, SIGNAL(clicked()), this, SLOT(OnOpenFileButtonPressed()) );
 }
 
 bool QmitkIGTPlayerWidget::IsTrajectoryInSplineMode()
 {
   return m_Controls->splineModeCheckBox->isChecked();
 }
 
 bool QmitkIGTPlayerWidget::CheckInputFileValid()
 {
   QFile file(m_CmpFilename);
 
   // check if file exists
   if(!file.exists())
   {
     QMessageBox::warning(NULL, "IGTPlayer: Error", "No valid input file was loaded. Please load input file first!");
     return false;
   }
 
   return true;
 }
 
 unsigned int QmitkIGTPlayerWidget::GetNumberOfTools()
 {
   unsigned int result = 0;
 
   if(this->GetCurrentPlaybackMode() == RealTimeMode)
   {
     if(m_RealTimePlayer.IsNotNull())
       result = m_RealTimePlayer->GetNumberOfOutputs();
   }
 
   else if(this->GetCurrentPlaybackMode() == SequentialMode)
   {
     if(m_SequentialPlayer.IsNotNull())
       result = m_SequentialPlayer->GetNumberOfOutputs();
   }
 
   // at the moment this works only if player is initialized
   return result;
 }
 
 void QmitkIGTPlayerWidget::SetUpdateRate(unsigned int msecs)
 {
   m_PlayingTimer->setInterval((int) msecs); // set update timer update rate
 }
 
 void QmitkIGTPlayerWidget::OnPlayButtonClicked(bool checked)
 {
   if ( ! checked )
   {
     if ( this->GetCurrentPlaybackMode() == RealTimeMode )
     {
       m_RealTimePlayer->StopPlaying();
     }
     else if ( this->GetCurrentPlaybackMode() == SequentialMode )
     {
       //      m_SequentialPlayer->
     }
   }
 
   if(CheckInputFileValid())  // no playing possible without valid input file
   {
     switch ( this->GetCurrentPlaybackMode() )
     {
     case RealTimeMode:
       {
         break;
       }
     case SequentialMode:
       {
         break;
       }
     }
 
     PlaybackMode currentMode = this->GetCurrentPlaybackMode();
     bool isRealTimeMode = currentMode == RealTimeMode;
     bool isSequentialMode = currentMode == SequentialMode;
 
     if(checked) // play
     {
       if( (isRealTimeMode && m_RealTimePlayer.IsNull()) || (isSequentialMode && m_SequentialPlayer.IsNull()))  // start play
       {
         mitk::NavigationDataSet::Pointer navigationDataSet;
         try
         {
           navigationDataSet = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::LoadBaseData(m_CmpFilename.toStdString()).GetPointer());
         }
         catch(mitk::IGTException)
         {
           std::string errormessage = "Error during start playing. Invalid or wrong file?";
           QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
           m_Controls->playPushButton->setChecked(false);
           m_RealTimePlayer = NULL;
           return;
         }
 
         if(isRealTimeMode)
         {
           m_RealTimePlayer = mitk::NavigationDataPlayer::New();
           m_RealTimePlayer->SetNavigationDataSet(navigationDataSet);
           try
           {
             m_RealTimePlayer->StartPlaying();
           }
           catch(mitk::IGTException)
           {
             std::string errormessage = "Error during start playing. Invalid or wrong file?";
             QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
             m_Controls->playPushButton->setChecked(false);
             m_RealTimePlayer = NULL;
             return;
           }
         }
         else if(isSequentialMode)
         {
           m_SequentialPlayer = mitk::NavigationDataSequentialPlayer::New();
           try
           {
             m_SequentialPlayer->SetNavigationDataSet(navigationDataSet);
           }
           catch(mitk::IGTException)
           {
             std::string errormessage = "Error during start playing. Invalid or wrong file type?";
             QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
             m_Controls->playPushButton->setChecked(false);
             m_RealTimePlayer = NULL;
             return;
           }
 
           m_Controls->samplePositionHorizontalSlider->setMinimum(0);
 
           m_Controls->samplePositionHorizontalSlider->setMaximum(m_SequentialPlayer->GetNumberOfSnapshots());
 
           m_Controls->samplePositionHorizontalSlider->setEnabled(true);
         }
 
         m_PlayingTimer->start(100);
 
         emit SignalPlayingStarted();
       }
       else // resume play
       {
         if(isRealTimeMode)
           m_RealTimePlayer->Resume();
 
         m_PlayingTimer->start(100);
         emit SignalPlayingResumed();
       }
     }
 
     else // pause
     {
       if(isRealTimeMode)
         m_RealTimePlayer->Pause();
 
       m_PlayingTimer->stop();
       emit SignalPlayingPaused();
     }
   }
 
   else
   {
     m_Controls->playPushButton->setChecked(false); // uncheck play button if file unvalid
   }
 }
 
 QmitkIGTPlayerWidget::PlaybackMode QmitkIGTPlayerWidget::GetCurrentPlaybackMode()
 {
   /*if(m_Controls->sequencialModeCheckBox->isChecked())
   return SequentialMode;
   else*/
   return RealTimeMode;
 }
 
 QTimer*  QmitkIGTPlayerWidget::GetPlayingTimer()
 {
   return m_PlayingTimer;
 }
 
 void QmitkIGTPlayerWidget::OnStopPlaying()
 {
   this->StopPlaying();
 }
 
 void QmitkIGTPlayerWidget::StopPlaying()
 {
   m_PlayingTimer->stop();
   emit SignalPlayingStopped();
 
   if(m_RealTimePlayer.IsNotNull())
     m_RealTimePlayer->StopPlaying();
 
   m_StartTime = -1;  // set starttime back
   m_CurrentSequentialPointNumber = 0;
   m_Controls->samplePositionHorizontalSlider->setSliderPosition(m_CurrentSequentialPointNumber);
   m_Controls->sampleLCDNumber->display(static_cast<int>(m_CurrentSequentialPointNumber));
 
   this->ResetLCDNumbers();
   m_Controls->playPushButton->setChecked(false); // set play button unchecked
 }
 
 void QmitkIGTPlayerWidget::OnPlaying()
 {
   switch ( this->GetCurrentPlaybackMode() )
   {
   case RealTimeMode:
     {
       if ( m_RealTimePlayer.IsNull() ) { return; }
 
       if ( m_StartTime < 0 )
       {
         // get playback start time
         m_StartTime = m_RealTimePlayer->GetOutput()->GetTimeStamp();
       }
 
       if( ! m_RealTimePlayer->IsAtEnd() )
       {
         m_RealTimePlayer->Update(); // update player
 
         int msc = (int) (m_RealTimePlayer->GetOutput()->GetTimeStamp() - m_StartTime);
 
         // calculation for playing time display
         int ms = msc % 1000;
         msc = (msc - ms) / 1000;
         int s = msc % 60;
         int min = (msc-s) / 60;
 
         // set lcd numbers
         m_Controls->msecLCDNumber->display(ms);
         m_Controls->secLCDNumber->display(s);
         m_Controls->minLCDNumber->display(min);
 
         emit SignalPlayerUpdated(); // player successfully updated
       }
       else
       {
         this->StopPlaying(); // if player is at EOF
       }
 
       break;
     }
   case SequentialMode:
     {
       if ( m_SequentialPlayer.IsNull() ) { return; }
 
       if ( m_CurrentSequentialPointNumber < m_SequentialPlayer->GetNumberOfSnapshots() )
       {
         m_SequentialPlayer->Update(); // update sequential player
 
         m_Controls->samplePositionHorizontalSlider->setSliderPosition(m_CurrentSequentialPointNumber++); // refresh slider position
         m_Controls->sampleLCDNumber->display(static_cast<int>(m_CurrentSequentialPointNumber));
 
         //for debugging purposes
         //std::cout << "Sample: " << m_CurrentSequentialPointNumber << " X: " << m_SequentialPlayer->GetOutput()->GetPosition()[0] << " Y: " << m_SequentialPlayer->GetOutput()->GetPosition()[1] << " Y: " << m_SequentialPlayer->GetOutput()->GetPosition()[2] << std::endl;
 
         emit SignalPlayerUpdated(); // player successfully updated
       }
       else
       {
         this->StopPlaying(); // if player is at EOF
       }
 
       break;
     }
   }
 }
 
 const std::vector<mitk::NavigationData::Pointer> QmitkIGTPlayerWidget::GetNavigationDatas()
 {
   std::vector<mitk::NavigationData::Pointer> navDatas;
 
   if(this->GetCurrentPlaybackMode() == RealTimeMode && m_RealTimePlayer.IsNotNull())
   {
     for(unsigned int i=0; i < m_RealTimePlayer->GetNumberOfOutputs(); ++i)
     {
       navDatas.push_back(m_RealTimePlayer->GetOutput(i)); // push back current navigation data for each tool
     }
   }
 
   else if(this->GetCurrentPlaybackMode() == SequentialMode && m_SequentialPlayer.IsNotNull())
   {
     for(unsigned int i=0; i < m_SequentialPlayer->GetNumberOfOutputs(); ++i)
     {
       navDatas.push_back(m_SequentialPlayer->GetOutput(i)); // push back current navigation data for each tool
     }
   }
 
   return navDatas;
 }
 
 const mitk::PointSet::Pointer QmitkIGTPlayerWidget::GetNavigationDatasPointSet()
 {
   mitk::PointSet::Pointer result = mitk::PointSet::New();
 
   mitk::PointSet::PointType pointType;
 
   PlaybackMode currentMode = this->GetCurrentPlaybackMode();
   bool isRealTimeMode = currentMode == RealTimeMode;
   bool isSequentialMode = currentMode == SequentialMode;
 
   if( (isRealTimeMode && m_RealTimePlayer.IsNotNull()) || (isSequentialMode && m_SequentialPlayer.IsNotNull()))
   {
     int numberOfOutputs = 0;
 
     if(isRealTimeMode)
       numberOfOutputs = m_RealTimePlayer->GetNumberOfOutputs();
     else if(isSequentialMode)
       numberOfOutputs = m_SequentialPlayer->GetNumberOfOutputs();
 
     for(unsigned int i=0; i < m_RealTimePlayer->GetNumberOfOutputs(); ++i)
     {
       mitk::NavigationData::PositionType position;
 
       if(isRealTimeMode)
         position = m_RealTimePlayer->GetOutput(i)->GetPosition();
       else if(isSequentialMode)
         position = m_SequentialPlayer->GetOutput(i)->GetPosition();
 
       pointType[0] = position[0];
       pointType[1] = position[1];
       pointType[2] = position[2];
 
       result->InsertPoint(i,pointType);  // insert current ND as Pointtype in PointSet for return
     }
   }
 
   return result;
 }
 
 const mitk::PointSet::PointType QmitkIGTPlayerWidget::GetNavigationDataPoint(unsigned int index)
 {
   if( index > this->GetNumberOfTools() || index < 0 )
     throw std::out_of_range("Tool Index out of range!");
 
   PlaybackMode currentMode = this->GetCurrentPlaybackMode();
   bool isRealTimeMode = currentMode == RealTimeMode;
   bool isSequentialMode = currentMode == SequentialMode;
 
   // create return PointType from current ND for tool index
   mitk::PointSet::PointType result;
 
   if( (isRealTimeMode && m_RealTimePlayer.IsNotNull()) || (isSequentialMode && m_SequentialPlayer.IsNotNull()))
   {
     mitk::NavigationData::PositionType position;
 
     if(isRealTimeMode)
       position = m_RealTimePlayer->GetOutput(index)->GetPosition();
     else if(isSequentialMode)
       position = m_SequentialPlayer->GetOutput(index)->GetPosition();
 
     result[0] = position[0];
     result[1] = position[1];
     result[2] = position[2];
   }
 
   return result;
 }
 
 /*void QmitkIGTPlayerWidget::SetRealTimePlayer( mitk::NavigationDataPlayer::Pointer player )
 {
 if(player.IsNotNull())
 m_RealTimePlayer = player;
 }
 
 void QmitkIGTPlayerWidget::SetSequentialPlayer( mitk::NavigationDataSequentialPlayer::Pointer player )
 {
 if(player.IsNotNull())
 m_SequentialPlayer = player;
 }*/
 
 void QmitkIGTPlayerWidget::OnOpenFileButtonPressed()
 {
-  QString filename = QFileDialog::getOpenFileName(this, "Load tracking data", QDir::currentPath(),"XML files (*.xml)");
+  QString filename = QFileDialog::getOpenFileName(this, "Load tracking data", QmitkIGTCommonHelper::GetLastFileLoadPath(),"XML files (*.xml)");
   QFile file(filename);
 
+  QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(filename);
   // if something went wrong or user pressed cancel in the save dialog
   if ( filename.isEmpty()  || ! file.exists() )
   {
     QMessageBox::warning(NULL, "Warning", QString("Please enter valid path. Using previous path again."));
     return;
   }
 
   m_CmpFilename = filename;
 
   this->OnGoToEnd(); /// stops playing and resets lcd numbers
 
   m_Controls->m_ActiveFileLabel->setText(m_CmpFilename);
 
   emit SignalInputFileChanged();
 
   mitk::NavigationDataSet::Pointer navigationDataSet = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::LoadBaseData(m_CmpFilename.toStdString()).GetPointer());
   m_RealTimePlayer->SetNavigationDataSet(navigationDataSet);
   m_SequentialPlayer->SetNavigationDataSet(navigationDataSet);
 
   m_Controls->m_PlayerControlsGroupBox->setEnabled(true);
 }
 
 void QmitkIGTPlayerWidget::OnGoToEnd()
 {
   this->StopPlaying();
 
   // reset lcd numbers
   this->ResetLCDNumbers();
 }
 
 void QmitkIGTPlayerWidget::OnGoToBegin()
 {
   // stop player manual so no PlayingStopped()
   m_PlayingTimer->stop();
 
   if(this->GetCurrentPlaybackMode() == RealTimeMode && m_RealTimePlayer.IsNotNull())
   {
     m_RealTimePlayer->StopPlaying();
     m_RealTimePlayer = NULL;  // set player to NULL so it can be initialized again if playback is called afterwards
   }
 
   m_StartTime = -1;  // set starttime back
 
   //reset view elements
   m_Controls->playPushButton->setChecked(false);
   this->ResetLCDNumbers();
 }
 
 void QmitkIGTPlayerWidget::ResetLCDNumbers()
 {
   m_Controls->minLCDNumber->display(QString("00"));
   m_Controls->secLCDNumber->display(QString("00"));
   m_Controls->msecLCDNumber->display(QString("000"));
 }
 
 void QmitkIGTPlayerWidget::SetTrajectoryNames(const QStringList toolNames)
 {
   QComboBox* cBox = m_Controls->trajectorySelectComboBox;
 
   if(cBox->count() > 0)
     this->ClearTrajectorySelectCombobox();
 
   // before making changed to QComboBox it is recommended to disconnet it's SIGNALS and SLOTS
   disconnect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
 
   if(!toolNames.isEmpty())
     m_Controls->trajectorySelectComboBox->insertItems(0, toolNames); // adding current tool names to combobox
 
   // reconnect after performed changes
   connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
 }
 
 int QmitkIGTPlayerWidget::GetResolution()
 {
   return m_Controls->resolutionSpinBox->value();  // return currently selected trajectory resolution
 }
 
 void QmitkIGTPlayerWidget::ClearTrajectorySelectCombobox()
 {
   // before making changed to QComboBox it is recommended to disconnet it's SIGNALS and SLOTS
   disconnect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
 
   m_Controls->trajectorySelectComboBox->clear();
 
   // reconnect after performed changes
   connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
 }
 
 void QmitkIGTPlayerWidget::OnSequencialModeToggled(bool toggled)
 {
   this->StopPlaying(); // stop playing when mode is changed
 
   if(toggled)
   {
     m_Controls->samplePositionHorizontalSlider->setEnabled(true); // enable slider if sequential mode
   }
   else if(!toggled)
   {
     m_Controls->samplePositionHorizontalSlider->setSliderPosition(0); // set back and disable slider
     m_Controls->samplePositionHorizontalSlider->setDisabled(true);
   }
 }
 
 void QmitkIGTPlayerWidget::OnSliderReleased()
 {
   int currentSliderValue = m_Controls->samplePositionHorizontalSlider->value(); // current slider value selected through user movement
 
   if(currentSliderValue > m_CurrentSequentialPointNumber) // at the moment only forward scrolling is possible
   {
     unsigned int snapshotNumber = currentSliderValue;
     m_SequentialPlayer->GoToSnapshot(snapshotNumber); // move player to selected snapshot
     m_CurrentSequentialPointNumber = currentSliderValue;
     m_Controls->sampleLCDNumber->display(currentSliderValue); // update lcdnumber in widget
   }
   else
     m_Controls->samplePositionHorizontalSlider->setValue(m_CurrentSequentialPointNumber);
 }
 
 void QmitkIGTPlayerWidget::OnSliderPressed()
 {
   if(m_Controls->playPushButton->isChecked())  // check if widget is playing
     m_Controls->playPushButton->click(); // perform click to pause the play
 }
diff --git a/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp
index cfc52b776e..9422e1eeac 100644
--- a/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp
@@ -1,168 +1,171 @@
 /*===================================================================
 
 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 "QmitkMicronTrackerWidget.h"
 
 #include <QFileDialog>
 #include <QScrollBar>
 
 #include <mitkClaronTrackingDevice.h>
 
 #include <itksys/SystemTools.hxx>
 #include <Poco/Path.h>
 #include <QSettings>
 
+#include <QmitkIGTCommonHelper.h>
+
 const std::string QmitkMicronTrackerWidget::VIEW_ID = "org.mitk.views.NDIMicronTrackerWidget";
 
 QmitkMicronTrackerWidget::QmitkMicronTrackerWidget(QWidget* parent, Qt::WindowFlags f)
   : QmitkAbstractTrackingDeviceWidget(parent, f)
   , m_Controls(nullptr)
 {
 }
 
 void QmitkMicronTrackerWidget::Initialize()
 {
   InitializeSuperclassWidget();
   CreateQtPartControl(this);
   CreateConnections();
   m_MTCalibrationFile = "";
 }
 
 QmitkMicronTrackerWidget::~QmitkMicronTrackerWidget()
 {
   delete m_Controls;
 }
 
 void QmitkMicronTrackerWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkMicronTrackerWidget;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkMicronTrackerWidget::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject*)(m_Controls->m_testConnectionMicronTracker), SIGNAL(clicked()), this, SLOT(TestConnection()));
     connect((QObject*)(m_Controls->m_SetMTCalibrationFile), SIGNAL(clicked()), this, SLOT(SetMTCalibrationFileClicked()));
   }
 }
 
 void QmitkMicronTrackerWidget::ResetOutput()
 {
   m_Controls->m_outputTextMicronTracker->setHtml("<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>");
 }
 
 void QmitkMicronTrackerWidget::AddOutput(std::string s)
 {
   m_Controls->m_outputTextMicronTracker->setHtml(QString(s.c_str()));
   m_Controls->m_outputTextMicronTracker->verticalScrollBar()->setValue(m_Controls->m_outputTextMicronTracker->verticalScrollBar()->maximum());
 }
 
 mitk::TrackingDevice::Pointer QmitkMicronTrackerWidget::ConstructTrackingDevice()
 {
   mitk::ClaronTrackingDevice::Pointer newDevice = mitk::ClaronTrackingDevice::New();
   if (this->m_MTCalibrationFile.empty()) //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()));
   }
   if (!this->m_MTCalibrationFile.empty())
   {
     //extract path from calibration file and set the calibration dir of the device
     std::string path = itksys::SystemTools::GetFilenamePath(m_MTCalibrationFile);
     newDevice->SetCalibrationDir(path);
   }
   else
     AddOutput("<br>Warning: Calibration file is not set!");
   return static_cast<mitk::TrackingDevice::Pointer>(newDevice);
 }
 
 void QmitkMicronTrackerWidget::StoreUISettings()
 {
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
   if (this->GetPersistenceService()) // now save the settings using the persistence service
   {
     mitk::PropertyList::Pointer propList = this->GetPersistenceService()->GetPropertyList(id);
     propList->Set("MTCalibrationFile", m_MTCalibrationFile);
   }
   else // QSettings as a fallback if the persistence service is not available
   {
     QSettings settings;
     settings.beginGroup(QString::fromStdString(id));
     settings.setValue("mTCalibrationFile", QVariant(QString::fromStdString(m_MTCalibrationFile)));
     settings.endGroup();
   }
 }
 
 void QmitkMicronTrackerWidget::LoadUISettings()
 {
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
 
   if (this->GetPersistenceService())
   {
     mitk::PropertyList::Pointer propList = this->GetPersistenceService()->GetPropertyList(id);
     if (propList.IsNull())
     {
       MITK_ERROR << "Property list for this UI (" << id << ") is not available, could not load UI settings!"; return;
     }
 
     propList->Get("MTCalibrationFile", m_MTCalibrationFile);
   }
   else
   {
     // QSettings as a fallback if the persistence service is not available
     QSettings settings;
     settings.beginGroup(QString::fromStdString(id));
     m_MTCalibrationFile = settings.value("mTCalibrationFile", "").toString().toStdString();
 
     settings.endGroup();
   }
   m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString::fromStdString(m_MTCalibrationFile));
 }
 
 bool QmitkMicronTrackerWidget::IsDeviceInstalled()
 {
   return mitk::ClaronTrackingDevice::New()->IsDeviceInstalled();
 }
 
 void QmitkMicronTrackerWidget::SetMTCalibrationFileClicked()
 {
-  std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Calibration File"), "/", "*.*").toLatin1().data();
+  std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*").toLatin1().data();
   if (filename == "") { return; }
   else
   {
+    QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
     m_MTCalibrationFile = filename;
     Poco::Path myPath = Poco::Path(m_MTCalibrationFile.c_str());
     m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
   }
 }
 
 QmitkMicronTrackerWidget* QmitkMicronTrackerWidget::Clone(QWidget* parent) const
 {
   QmitkMicronTrackerWidget* clonedWidget = new QmitkMicronTrackerWidget(parent);
   clonedWidget->Initialize();
   clonedWidget->m_MTCalibrationFile = m_MTCalibrationFile;
   m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString::fromStdString(m_MTCalibrationFile));
 
   return clonedWidget;
 }
diff --git a/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.cpp
index fc45ba998f..d86f6f7f2d 100644
--- a/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.cpp
@@ -1,886 +1,893 @@
 /*===================================================================
 
 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 "QmitkNDIConfigurationWidget.h"
 #include <QTableWidget>
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QInputDialog>
 #include <QDir>
 #include <QFileInfo>
 
 #include <mitkNavigationToolWriter.h>
 #include <mitkNavigationToolReader.h>
 #include <mitkIGTException.h>
 #include <mitkIOUtil.h>
 
+#include <QmitkIGTCommonHelper.h>
 #include "QmitkCustomVariants.h"
 
 //#include <QtConcurrentMap>
 #include "QmitkNDIToolDelegate.h"
 
 #include "mitkNDIAuroraTypeInformation.h"
 #include "mitkNDIPolarisTypeInformation.h"
 
 /* VIEW MANAGEMENT */
 QmitkNDIConfigurationWidget::QmitkNDIConfigurationWidget(QWidget* parent)
 : QWidget(parent), m_Controls(NULL), m_Tracker(NULL), m_Source(NULL),
 m_Delegate(NULL), m_SROMCellDefaultText("<click to load SROM file>"), m_RepresentatonCellDefaultText("<click to select representation>")
 {
   this->CreateQtPartControl(this);
 }
 
 
 QmitkNDIConfigurationWidget::~QmitkNDIConfigurationWidget()
 {
   m_Controls = NULL;
   m_Tracker = NULL;
   m_Source = NULL;
 }
 
 
 void QmitkNDIConfigurationWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNDIConfigurationWidget;
     m_Controls->setupUi(parent);
     QStringList comPorts;
 #ifdef WIN32
     comPorts << "COM1" << "COM2" << "COM3" << "COM4" << "COM5" << "COM6" << "COM7" << "COM8" << "COM9";
 #else
     comPorts << "/dev/ttyS1" << "/dev/ttyS2" << "/dev/ttyS3" << "/dev/ttyS4" << "/dev/ttyS5" << "/dev/ttyUSB0" << "/dev/ttyUSB1" << "/dev/ttyUSB2" << "/dev/ttyUSB3";
 #endif
     m_Controls->m_ComPortSelector->addItems(comPorts);
     m_Delegate = new QmitkNDIToolDelegate(m_Controls->m_ToolTable);
     m_Delegate->SetDataStorage(NULL);  //needs to be set later using the setter methods
     m_Delegate->SetPredicate(NULL);
     m_Delegate->SetTypes(QStringList());
     m_Controls->m_ToolTable->setItemDelegate(m_Delegate);
     this->CreateConnections();
     this->HidePolarisOptionsGroupbox(true);
     this->HideAuroraOptionsGroupbox(true);
   }
 }
 
 
 void QmitkNDIConfigurationWidget::CreateConnections()
 {
   connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
   connect(m_Controls->m_DiscoverToolsBtn, SIGNAL(clicked()), this, SLOT(OnDiscoverTools()));
   connect(m_Controls->m_AddToolBtn, SIGNAL(clicked()), this, SLOT(OnAddPassiveTool()));
   connect(m_Controls->m_DisoverDevicesBtn, SIGNAL(clicked()), this, SLOT(OnDiscoverDevices()));
   connect(m_Controls->m_ToolTable->model(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(UpdateTrackerFromToolTable(const QModelIndex &, const QModelIndex &)));
   connect(m_Controls->m_DisoverDevicesBtnInfo, SIGNAL(clicked()), this, SLOT(OnDisoverDevicesBtnInfo()));
 
   connect(m_Controls->m_SaveToolPushButton, SIGNAL(clicked()), this, SLOT(OnSaveTool()) );
   connect(m_Controls->m_LoadToolPushButton, SIGNAL(clicked()), this, SLOT(OnLoadTool()) );
 
  }
 
 
 void QmitkNDIConfigurationWidget::OnConnect()
 {
   if (m_Tracker.IsNotNull())
   {
     m_Tracker->CloseConnection();
     m_Tracker = NULL;
   }
   this->CreateTracker();
 
   this->SetupTracker();
   bool okay = false;
   try
     {
     okay = m_Tracker->OpenConnection();
     }
   catch(mitk::IGTException &e)
     {
     QMessageBox::warning(NULL, "Error", QString("Connection failed, error message: ") + e.GetDescription());
     m_Tracker->CloseConnection();
     this->m_Tracker = NULL;
 
     }
   if (okay)
   {
     // show/hide options according to connected device
     if(m_Tracker->GetType() == mitk::NDIPolarisTypeInformation::GetTrackingDeviceName())
     {
       this->HideAuroraOptionsGroupbox(true);
       this->HidePolarisOptionsGroupbox(false);
     }
     else if (m_Tracker->GetType() == mitk::NDIAuroraTypeInformation::GetTrackingDeviceName())
     {
       this->HidePolarisOptionsGroupbox(true);
       this->HideAuroraOptionsGroupbox(false);
     }
 
     this->UpdateWidgets();
     this->UpdateToolTable();
 
     connect(m_Controls->m_ToolTable, SIGNAL(cellChanged(int,int)), this, SLOT(OnTableCellChanged(int,int)));
 
     emit ToolsAdded(this->GetToolNamesList());
     emit Connected();
   }
   else
   {
     QMessageBox::warning(NULL, "Error", QString("Connection failed due to an unknown reason!"));
     m_Tracker->CloseConnection();
     this->m_Tracker = NULL;
   }
 }
 
 
 void QmitkNDIConfigurationWidget::OnDisconnect()
 {
   if (m_Tracker.IsNull())
     return;
   m_Tracker->CloseConnection();
   m_Tracker = NULL;
 
   disconnect(m_Controls->m_ToolTable, SIGNAL(cellChanged(int,int)), this, SLOT(OnTableCellChanged(int,int)));
   m_Controls->m_ToolSelectionComboBox->clear();
 
   this->UpdateToolTable();
   this->UpdateWidgets();
   emit ToolsAdded(this->GetToolNamesList());
   emit Disconnected();
 
   this->HidePolarisOptionsGroupbox(true);
   this->HideAuroraOptionsGroupbox(true);
 }
 
 
 void QmitkNDIConfigurationWidget::UpdateWidgets()
 {
   m_Controls->m_DeviceStatus->setText(this->GetStatusText());
   if (m_Tracker.IsNull())  // not connected to tracker
   {
     m_Controls->m_Connect->setText("Connect");
     m_Controls->m_lConnection->setText("III. Enable connection to  device  ");
 
     disconnect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnDisconnect()));
     connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
     m_Controls->m_DiscoverToolsBtn->setDisabled(true);
     m_Controls->m_AddToolBtn->setDisabled(true);
     return;
   }
 
   if (m_Tracker->GetState() == mitk::TrackingDevice::Setup)
   {
     m_Controls->m_Connect->setText("Connect");
     m_Controls->m_lConnection->setText("III. Enable connection to  device  ");
     disconnect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnDisconnect()));
     connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
     m_Controls->m_DiscoverToolsBtn->setDisabled(true);
     m_Controls->m_AddToolBtn->setDisabled(true);
     return;
   }
   if ((m_Tracker->GetState() == mitk::TrackingDevice::Ready) || (m_Tracker->GetState() == mitk::TrackingDevice::Tracking))
   {
     m_Controls->m_Connect->setText("Disconnect");
     m_Controls->m_lConnection->setText("III. Disable connection to  device ");
     disconnect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
     connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnDisconnect()));
     m_Controls->m_DiscoverToolsBtn->setEnabled(true);
     m_Controls->m_AddToolBtn->setEnabled(true);
   }
 }
 
 
 QString QmitkNDIConfigurationWidget::GetStatusText()
 {
   if (m_Tracker.IsNull())
     return QString("Not connected");
 
   QString devName = QString::fromStdString(m_Tracker->GetType());
 
   if (m_Tracker->GetState() == mitk::TrackingDevice::Ready)
     return QString("Connected to %1 on %2. Device is ready.").arg(devName).arg(m_Tracker->GetDeviceName());
   if (m_Tracker->GetState() == mitk::TrackingDevice::Tracking)
     return QString("%1 is tracking.").arg(devName);
   return QString("");
 }
 
 
 void QmitkNDIConfigurationWidget::OnDiscoverTools()
 {
   if (m_Tracker.IsNull())
   {
     QMessageBox::warning(NULL, "Error", QString("Connection failed. No tracking device found."));
     return;
   }
   m_Tracker->DiscoverWiredTools();
   this->UpdateToolTable();
   emit ToolsAdded(this->GetToolNamesList());
 }
 
 
 void QmitkNDIConfigurationWidget::OnAddPassiveTool()
 {
   if (m_Tracker.IsNull())
     this->CreateTracker();
 
-  QStringList filenames = QFileDialog::getOpenFileNames(this, "Select NDI SROM file", QDir::currentPath(),"NDI SROM files (*.rom)");
+  QStringList filenames = QFileDialog::getOpenFileNames(this, "Select NDI SROM file", QmitkIGTCommonHelper::GetLastFileLoadPath(),"NDI SROM files (*.rom)");
   if (filenames.isEmpty())
   {
     this->m_Tracker = NULL;
     return;
   }
+
+  QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(filenames.at(0));
+
   foreach(QString fileName, filenames)
   {
     //QString toolName = QInputDialog::getText(this, "Enter a name for the tool", "Name of the tool: ", QLineEdit::Normal, QFileInfo(filename).baseName(), &ok);
     //if (ok == false || toolName.isEmpty())
     //  return;
     m_Tracker->AddTool(QFileInfo(fileName).baseName().toLatin1(), fileName.toLatin1());
     m_Tracker->Modified();
   }
   emit ToolsAdded(this->GetToolNamesList());
   this->UpdateToolTable();
 }
 
 
 void QmitkNDIConfigurationWidget::CreateTracker()
 {
   m_Tracker = mitk::NDITrackingDevice::New();
 }
 
 
 void QmitkNDIConfigurationWidget::SetupTracker()
 {
   if (m_Tracker.IsNull())
     return;
   m_Tracker->SetDeviceName(this->GetDeviceName());
   m_Tracker->SetBaudRate(mitk::SerialCommunication::BaudRate115200);
 }
 
 
 std::string QmitkNDIConfigurationWidget::GetDeviceName() const
 {
   if (m_Controls == NULL)
     return NULL;
   QString deviceName = m_Controls->m_ComPortSelector->currentText();
 #if WIN32
   deviceName.prepend("\\\\.\\"); // always prepend "\\.\ to all COM ports, to be able to connect to ports > 9"
 #endif
   return deviceName.toStdString();
 }
 
 
 void QmitkNDIConfigurationWidget::SetDeviceName( const char* dev )
 {
   if (m_Controls == NULL)
     return;
   m_Controls->m_ComPortSelector->setCurrentIndex(m_Controls->m_ComPortSelector->findText(dev));
 }
 
 
 void QmitkNDIConfigurationWidget::UpdateToolTable()
 {
   //disconnect(m_Controls->m_ToolTable, SIGNAL(itemChanged(QTableWidgetItem*)), this, SLOT(OnTableItemChanged(QTableWidgetItem*))); // stop listening to table changes
   disconnect(m_Controls->m_ToolTable->model(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(UpdateTrackerFromToolTable(const QModelIndex &, const QModelIndex &)));
   disconnect(m_Controls->m_ToolTable, SIGNAL( clicked ( const QModelIndex & )), this, SLOT ( OnTableItemClicked( const QModelIndex & )));
 
   m_Controls->m_ToolTable->clearContents();
   m_Controls->m_ToolTable->setRowCount(0);
   if (m_Tracker.IsNull() || (m_Controls == NULL))
     return;
 
   m_Controls->m_ToolSelectionComboBox->clear();
 
   m_Controls->m_ToolTable->setRowCount(m_Tracker->GetToolCount());
   for (unsigned int i = 0; i < m_Tracker->GetToolCount(); ++i)
   {
     mitk::TrackingTool* t = m_Tracker->GetTool(i);
     if (t == NULL)
     {
       m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::IndexCol, new QTableWidgetItem("INVALID"));                   // Index
       continue;
     }
 
     m_Controls->m_ToolSelectionComboBox->addItem(m_Tracker->GetTool(i)->GetToolName());
 
     m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::IndexCol, new QTableWidgetItem(QString::number(i)));            // Index
     m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::NameCol, new QTableWidgetItem(t->GetToolName()));               // Name
     if (dynamic_cast<mitk::NDIPassiveTool*>(t)->GetSROMDataLength() > 0)
       m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::SROMCol, new QTableWidgetItem("SROM file loaded"));           // SROM file
     else
       m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::SROMCol, new QTableWidgetItem(m_SROMCellDefaultText));        // SROM file
     m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::TypeCol, new QTableWidgetItem("<click to set type>"));          // Type
     if (t->IsEnabled())
       m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::StatusCol, new QTableWidgetItem("Enabled"));                  // Status
     else
       m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::StatusCol, new QTableWidgetItem("Disabled"));                 // Status
     m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::NodeCol, new QTableWidgetItem("<click to select node>"));       // Node
 
     m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::RepCol, new QTableWidgetItem(m_RepresentatonCellDefaultText));       // Representation
 
 
     /* set read-only/editable flags */
     m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::IndexCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled);                        // Index
     m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::NodeCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable   | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled);  // Name
     m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::SROMCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable   | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled);  // SROM file
     m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::TypeCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable   | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled);  // Type
     m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::StatusCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled);                       // Status
     m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::NodeCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable   | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled);  // Node
 
     m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::RepCol)->setFlags(Qt::NoItemFlags);  // Representation surface file
   }
   m_Controls->m_ToolTable->resizeColumnsToContents();
   //connect(m_Controls->m_ToolTable, SIGNAL(itemChanged(QTableWidgetItem*)), this, SLOT(OnTableItemChanged(QTableWidgetItem*))); // listen to table changes again
   connect(m_Controls->m_ToolTable->model(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(UpdateTrackerFromToolTable(const QModelIndex &, const QModelIndex &)));
   connect(m_Controls->m_ToolTable, SIGNAL( clicked ( const QModelIndex & )), this, SLOT ( OnTableItemClicked( const QModelIndex & )));
 
 }
 
 
 void QmitkNDIConfigurationWidget::OnDiscoverDevices()
 {
   PortDeviceMap portsAndDevices;
   QString status = "Scanning ";
 #ifdef WIN32
   QString devName;
   for (unsigned int i = 1; i < 40; ++i)
   {
     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"
     portsAndDevices[devName];
     status += QString("COM%1").arg(i) + ", ";
   }
 #else //linux/posix systems
   for(unsigned int i = 1; i < 6; ++i)
   {
     QString devName = QString("/dev/ttyS%1").arg(i);
     portsAndDevices[devName];
     status += devName + ", ";
   }
   for(unsigned int i = 0; i <7; ++i)
   {
     QString devName = QString("/dev/ttyUSB%1").arg(i);
     portsAndDevices[devName];
     status += devName + ", ";
   }
 #endif
 
   status.chop(2); // remove last ", "
   status += " for NDI tracking devices...";
   m_Controls->m_DeviceStatus->setText(status);
   ScanPortsForNDITrackingDevices(portsAndDevices);
   m_Controls->m_ComPortSelector->clear();
   QString result = "The following tracking devices were found:<BR/>\n";
   for (PortDeviceMap::const_iterator it = portsAndDevices.begin(); it != portsAndDevices.end(); ++it)
   {
     QString tmpComPort = it.key();
     if (tmpComPort.startsWith("\\"))
     {
       tmpComPort.remove(0,4); // remove "\\.\" for nice ui visualisation
     }
     result += tmpComPort + ": ";
 
     if (mitk::NDIPolarisTypeInformation::GetTrackingDeviceName() == it.value() || mitk::NDIAuroraTypeInformation::GetTrackingDeviceName() == it.value())
     {
       result += QString::fromStdString(it.value());
       result += "<BR/>\n";
       m_Controls->m_ComPortSelector->addItem(tmpComPort);
     }
     else
     {
       result += "No NDI tracking device found<BR/>\n";
     }
   }
   //QMessageBox::information(NULL, "Tracking Device Discovery", result);
   m_Controls->m_DeviceStatus->setText(result);
 }
 
 
 mitk::TrackingDeviceType QmitkNDIConfigurationWidget::ScanPort(QString port)
 {
   mitk::NDITrackingDevice::Pointer tracker = mitk::NDITrackingDevice::New();
   tracker->SetDeviceName(port.toStdString());
   return tracker->TestConnection();
 }
 
 
 void QmitkNDIConfigurationWidget::ScanPortsForNDITrackingDevices( PortDeviceMap& portsAndDevices )
 {
   // Iterative scanning:
   for (PortDeviceMap::iterator it = portsAndDevices.begin(); it != portsAndDevices.end(); ++it)
     it.value() = this->ScanPort(it.key());
 
   // \Todo: use parallel scanning
   //QtConcurrent::blockingMap( portsAndDevices.begin(), portsAndDevices.end(), ScanPort );
   //MITK_INFO << portsAndDevices;
 }
 
 
 QStringList QmitkNDIConfigurationWidget::GetToolNamesList()
 {
   QStringList toolNames;
   if (m_Tracker.IsNull())
     return toolNames;
   for (unsigned int i = 0; i < m_Tracker->GetToolCount(); ++i)
   {
     mitk::TrackingTool* t = m_Tracker->GetTool(i);
     if (t == NULL)
       continue;
     toolNames << t->GetToolName();
   }
   return toolNames;
 }
 
 
 mitk::NDITrackingDevice* QmitkNDIConfigurationWidget::GetTracker() const
 {
   return m_Tracker.GetPointer();
 }
 
 
 void QmitkNDIConfigurationWidget::SetToolTypes(const QStringList& types)
 {
   m_Delegate->SetTypes(types);
 }
 
 
 void QmitkNDIConfigurationWidget::SetDataStorage(mitk::DataStorage* ds)
 {
   m_Delegate->SetDataStorage(ds);
 }
 
 
 void QmitkNDIConfigurationWidget::SetPredicate(mitk::NodePredicateBase::Pointer p)
 {
   m_Delegate->SetPredicate(p);
 }
 
 
 void QmitkNDIConfigurationWidget::SetTagPropertyName( const std::string& name )
 {
   m_Delegate->SetTagPropertyName(name);
 }
 
 
 void QmitkNDIConfigurationWidget::SetTagProperty( mitk::BaseProperty::Pointer prop )
 {
   m_Delegate->SetTagProperty(prop);
 }
 
 
 void QmitkNDIConfigurationWidget::OnTableItemClicked(const QModelIndex & topLeft )
 {
   QString filename;
   QTableWidgetItem* filenameItem;
 
   switch (topLeft.column())
   {
   case QmitkNDIToolDelegate::RepCol:
 
-    filename = QFileDialog::getOpenFileName(this, "Select Surface File", QDir::currentPath(),"STL files (*.stl)");
+    filename = QFileDialog::getOpenFileName(this, "Select Surface File", QmitkIGTCommonHelper::GetLastFileLoadPath(),"STL files (*.stl)");
+    QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(filename);
 
     filenameItem = new QTableWidgetItem(filename);
     m_Controls->m_ToolTable->setItem( topLeft.row(), topLeft.column(), filenameItem );
 
     if(QFileInfo(filename).exists())
     {
       mitk::Surface::Pointer surface = this->LoadSurfaceFromSTLFile(filename);
 
       if(surface.IsNotNull())
         emit RepresentationChanged( topLeft.row(), surface);
     }
     break;
    default:
     break;
   }
 }
 
 
 void QmitkNDIConfigurationWidget::UpdateTrackerFromToolTable(const QModelIndex & topLeft, const QModelIndex & /*bottomRight*/)
 {
   //Colums ID doesn't have to be processed.
   if (topLeft.column()<1)
     return;
 
   if (m_Tracker.IsNull())
     return;
 
   if (topLeft.row() >= (int) m_Tracker->GetToolCount())
     return;
 
   QAbstractItemModel* model = m_Controls->m_ToolTable->model();
 
   //define topleft contains row and column; row 0 is tool 0; column is index =0, Name =1, SROMFileName = 2; Type = 3; Status = 4; Node (?) = 5
   //only update the changed item
   mitk::NDIPassiveTool* tool = dynamic_cast<mitk::NDIPassiveTool*> (m_Tracker->GetTool(topLeft.row()));
     if (tool == NULL)
       return;
 
   switch (topLeft.column())
   {
   case QmitkNDIToolDelegate::IndexCol: //index
     break;
   case QmitkNDIToolDelegate::NameCol: //name
     tool->SetToolName(model->data(model->index(topLeft.row(), 1)).toString().toLatin1());
     emit ToolsChanged();
     break;
   case QmitkNDIToolDelegate::SROMCol: //SROM File Name
     {
       QString romfile = model->data(model->index(topLeft.row(), QmitkNDIToolDelegate::SROMCol)).toString();
       if (QFileInfo(romfile).exists())
         tool->LoadSROMFile(romfile.toLatin1());
       m_Tracker->UpdateTool(tool);
       break;
     }
 
     //TODO: Add Node Status and Type here as well
   default:
     break;
   }
 
 }
 
 
 const QString QmitkNDIConfigurationWidget::GetToolType( unsigned int index ) const
 {
   if (m_Controls == NULL)
     return QString("");
 
   QAbstractItemModel* model = m_Controls->m_ToolTable->model();
   QModelIndex modelIndex = model->index(index, QmitkNDIToolDelegate::TypeCol);
   if (modelIndex.isValid() == false)
     return QString("");
 
   return model->data(modelIndex).toString();
 }
 
 
 const QString QmitkNDIConfigurationWidget::GetToolName( unsigned int index ) const
 {
   if (m_Controls == NULL)
     return QString("");
 
   QAbstractItemModel* model = m_Controls->m_ToolTable->model();
   QModelIndex modelIndex = model->index(index, QmitkNDIToolDelegate::NameCol);
   if (modelIndex.isValid() == false)
     return QString("");
 
   return model->data(modelIndex).toString();
 }
 
 
 QMap<QString, unsigned int> QmitkNDIConfigurationWidget::GetToolAndTypes() const
 {
   QMap<QString, unsigned int> map;
   if (m_Controls == NULL)
     return map;
   QAbstractItemModel* model = m_Controls->m_ToolTable->model();
   for (int i = 0; i < model->rowCount(); ++i)
   {
     QModelIndex indexIndex = model->index(i, QmitkNDIToolDelegate::IndexCol);
     QModelIndex typeIndex = model->index(i, QmitkNDIToolDelegate::TypeCol);
     if ((indexIndex.isValid() == false) || (typeIndex.isValid() == false))
       continue;
     map.insert(model->data(typeIndex).toString(), model->data(indexIndex).toUInt());
   }
   return map;
 }
 
 
 QList<unsigned int> QmitkNDIConfigurationWidget::GetToolsByToolType( QString toolType ) const
 {
   QList<unsigned int> list;
   if (m_Controls == NULL)
       return list;
   QAbstractItemModel* model = m_Controls->m_ToolTable->model();
   for (int i = 0; i < model->rowCount(); ++i)
   {
     QModelIndex indexIndex = model->index(i, QmitkNDIToolDelegate::IndexCol);
     QModelIndex typeIndex = model->index(i, QmitkNDIToolDelegate::TypeCol);
     if ((indexIndex.isValid() == false) || (typeIndex.isValid() == false))
       continue;
     if (model->data(typeIndex).toString() == toolType)
       list.append(model->data(indexIndex).toUInt());
   }
   return list;
 }
 
 
 mitk::DataNode* QmitkNDIConfigurationWidget::GetNode( unsigned int index ) const
 {
 
   if (m_Controls == NULL)
     return NULL;
   QAbstractItemModel* model = m_Controls->m_ToolTable->model();
   QVariant data = model->data(model->index(index, QmitkNDIToolDelegate::NodeCol), QmitkNDIToolDelegate::OrganNodeRole);
   return data.value<mitk::DataNode*>();
 }
 
 void QmitkNDIConfigurationWidget::HidePolarisOptionsGroupbox( bool on )
 {
   m_Controls->m_gbPolarisOptions->setHidden(on);
 }
 
 void QmitkNDIConfigurationWidget::HideAuroraOptionsGroupbox( bool on )
 {
   m_Controls->m_gbAuroraOptions->setHidden(on);
 }
 
 void QmitkNDIConfigurationWidget::ShowToolRepresentationColumn()
 {
   int cols = m_Controls->m_ToolTable->columnCount();
 
   //checking if representation column is inserted at right index
   if(cols != QmitkNDIToolDelegate::RepCol)
   {
     //throw std::exception("Representation Column is not inserted at it's designated index!");
     return;
   }
 
 
   m_Controls->m_ToolTable->insertColumn(cols); // insert new column at end of table
 
 
   m_Controls->m_ToolTable->setHorizontalHeaderItem(QmitkNDIToolDelegate::RepCol, new QTableWidgetItem(QString("Representation"))); // inser column header for new colum
   //m_Controls->m_ToolTable->setEditTriggers(QAbstractItemView::EditTrigger::NoEditTriggers);
 
   int rows = m_Controls->m_ToolTable->rowCount();
 
  // make all representation colum items not editable
   for(int i=0; i < rows; ++i)
   {
     m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::RepCol, new QTableWidgetItem("<click to select representation>"));       // Representation
     m_Controls->m_ToolTable->item(i,QmitkNDIToolDelegate::RepCol)->setFlags(Qt::NoItemFlags);
    }
 
    //connect(m_Controls->m_ToolTable, SIGNAL( clicked ( const QModelIndex & )), this, SLOT ( OnTableItemClicked( const QModelIndex & )));
 
 }
 
 void QmitkNDIConfigurationWidget::OnDisoverDevicesBtnInfo()
 {
   QMessageBox *infoBox = new QMessageBox(this);
   infoBox->setText("Click \"Scan Ports\" to get a list of all connected NDI tracking devices. This will clear the selection menu below and add the ports for discovered NDI tracking devices. Use this function, if a port is not listed.");
   infoBox->exec();
   delete infoBox;
 }
 
 
 void QmitkNDIConfigurationWidget::OnTableCellChanged(int row, int column)
 {
 
   if(m_Tracker.IsNull())
     return;
 
   QString toolName;
 
   switch (column)
   {
   case QmitkNDIToolDelegate::NameCol:
     toolName = m_Controls->m_ToolTable->item(row,column)->text();
     m_Controls->m_ToolSelectionComboBox->setItemText(row, toolName);
 
     emit SignalToolNameChanged(row, toolName);
 
   break;
 
   default:
   break;
   }
 
 }
 
 
 void QmitkNDIConfigurationWidget::OnSaveTool()
 {
   if(m_Tracker.IsNull() || m_Tracker->GetToolCount() <= 0)
     return;
 
   int currId = m_Controls->m_ToolSelectionComboBox->currentIndex();
   QString filename = QFileDialog::getSaveFileName(NULL, "Save NDI-Tool", QString(QString(m_Tracker->GetTool(currId)->GetToolName())),"NDI Tracking Tool file(*.ntf)");
 
   mitk::TrackingTool* selectedTool = m_Tracker->GetTool(currId);
 
   if(filename.isEmpty())
     return;
 
   mitk::NavigationTool::Pointer navTool = mitk::NavigationTool::New();
 
 
   mitk::NavigationToolWriter::Pointer toolWriter = mitk::NavigationToolWriter::New();
   try {
     toolWriter->DoWrite(filename.toStdString(), this->GenerateNavigationTool(selectedTool));
   }
   catch( ... )
   {
     QMessageBox::warning(NULL, "Saving Tool Error", QString("An error occured! Could not save tool!\n\n"));
     MBI_ERROR<<"Could not save tool surface!";
     MBI_ERROR<< toolWriter->GetErrorMessage();
 
     QFile maybeCorruptFile(filename);
 
     if(maybeCorruptFile.exists())
       maybeCorruptFile.remove();
   }
 
   emit SignalSavedTool(currId, filename);
 }
 
 
 void QmitkNDIConfigurationWidget::OnLoadTool()
 {
   if(m_Tracker.IsNull() || m_Tracker->GetToolCount() <= 0)
     return;
 
-  QString filename = QFileDialog::getOpenFileName(NULL, "Load NDI-Tools", QDir::currentPath(),"NDI Tracking Tool file(*.ntf)");
+  QString filename = QFileDialog::getOpenFileName(NULL, "Load NDI-Tools", QmitkIGTCommonHelper::GetLastFileLoadPath(),"NDI Tracking Tool file(*.ntf)");
   int currId = m_Controls->m_ToolSelectionComboBox->currentIndex();
 
   if(filename.isEmpty())
     return;
 
+  QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(filename);
+
   mitk::DataNode::Pointer toolNode;
   mitk::NavigationToolReader::Pointer toolReader = mitk::NavigationToolReader::New();
   mitk::NavigationTool::Pointer navTool;
 
   try {
     navTool = toolReader->DoRead(filename.toStdString());
   }
   catch( ... )
   {
     QMessageBox::warning(NULL, "Loading Tool Error", QString("An error occured! Could not load tool!\n\n"));
     MBI_ERROR<<"Could not load tool surface!";
     MBI_ERROR<< toolReader->GetErrorMessage();
   }
 
   int currSelectedToolID = m_Controls->m_ToolSelectionComboBox->currentIndex();
 
   // name
   m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::NameCol)->setText(navTool->GetToolName().c_str());
   dynamic_cast<mitk::NDIPassiveTool*>(m_Tracker->GetTool(currSelectedToolID))->SetToolName(navTool->GetToolName().c_str()); // also setting name to tool directly
 
   //calibration file (.srom) filename
   m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::SROMCol)->setText(navTool->GetCalibrationFile().c_str());
 
   //type
   if(navTool->GetType() == mitk::NavigationTool::Instrument)
     m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->setText("Instrument");
   else if(navTool->GetType() == mitk::NavigationTool::Fiducial)
     m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->setText("Fiducial");
   else if(navTool->GetType() == mitk::NavigationTool::Skinmarker)
     m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->setText("Skinmarker");
   else
     m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->setText("Unknown");
 
 
   //representation
   m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::SROMCol)->setText(m_RepresentatonCellDefaultText);
 
   emit SignalLoadTool(currId, navTool->GetDataNode());
 }
 
 
 mitk::NavigationTool::Pointer QmitkNDIConfigurationWidget::GenerateNavigationTool(mitk::TrackingTool* tool)
 {
   mitk::NavigationTool::Pointer navTool = mitk::NavigationTool::New();
   mitk::NDIPassiveTool::Pointer passiveTool = dynamic_cast<mitk::NDIPassiveTool*>(tool);
 
   if(passiveTool.IsNull())
     throw std::runtime_error("Could not cast TrackingTool to PassiveTool");
 
   int currSelectedToolID = m_Controls->m_ToolSelectionComboBox->currentIndex();
 
   QString sromFileName = m_Controls->m_ToolTable->item(currSelectedToolID, QmitkNDIToolDelegate::SROMCol)->text();
   QString surfaceFileName = m_Controls->m_ToolTable->item(currSelectedToolID, QmitkNDIToolDelegate::RepCol)->text();
 
   //calibration file (.srom) filename
   QFile sromFile(sromFileName);
   if(sromFile.exists())
     navTool->SetCalibrationFile(sromFileName.toStdString());
 
   //serial number
   navTool->SetSerialNumber(passiveTool->GetSerialNumber());
 
   // name and surface as dataNode
   mitk::DataNode::Pointer node = mitk::DataNode::New();
 
   mitk::Surface::Pointer toolSurface;
 
   try{
    toolSurface = this->LoadSurfaceFromSTLFile(surfaceFileName);
   }
   catch( ... )
   {
     QMessageBox::warning(NULL, "Loading Surface Error", QString("An error occured! Could not load surface from .stl file!\n\n"));
     MBI_ERROR<<"Could not load .stl tool surface!";
   }
 
 
   if(toolSurface.IsNotNull())
   {
     node->SetData(toolSurface);
     node->SetName(tool->GetToolName());
   }
 
   navTool->SetDataNode(node);
 
   // type
   mitk::NavigationTool::NavigationToolType type;
   QString currentToolType = m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->text();
 
   if(currentToolType.compare("Instrument") == 0)
     type = mitk::NavigationTool::Instrument;
   else if(currentToolType.compare("Fiducial") == 0)
     type = mitk::NavigationTool::Fiducial;
   else if(currentToolType.compare("Skinmarker") == 0)
     type = mitk::NavigationTool::Skinmarker;
   else
     type = mitk::NavigationTool::Unknown;
 
   navTool->SetType(type);
 
   return navTool;
 }
 
 
 mitk::Surface::Pointer QmitkNDIConfigurationWidget::LoadSurfaceFromSTLFile(QString surfaceFilename)
 {
   mitk::Surface::Pointer toolSurface;
 
   QFile surfaceFile(surfaceFilename);
   if(surfaceFile.exists())
   {
     try{
       toolSurface = mitk::IOUtil::LoadSurface(surfaceFilename.toStdString().c_str());
     }
     catch(std::exception& e )
     {
       MBI_ERROR<<"Could not load surface for tool!";
       MBI_ERROR<< e.what();
       throw e;
     }
   }
 
   return toolSurface;
 }
 
 void QmitkNDIConfigurationWidget::EnableAddToolsButton(bool enable) {
   m_Controls->m_AddToolBtn->setEnabled(enable);
 }
 
 void QmitkNDIConfigurationWidget::EnableDiscoverNewToolsButton(bool enable) {
   m_Controls->m_DiscoverToolsBtn->setEnabled(enable);
 }
diff --git a/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp
index 156ea72622..a594650739 100644
--- a/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp
@@ -1,120 +1,122 @@
 /*===================================================================
 
 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 "QmitkNPOptitrackWidget.h"
 
 #include "mitkOptitrackTrackingDevice.h"
 #include "mitkNPOptitrackTrackingTypeInformation.h"
+#include "QmitkIGTCommonHelper.h"
 
 #include <QFileDialog>
 #include <QScrollBar>
 #include <Poco/Path.h>
 
 const std::string QmitkNPOptitrackWidget::VIEW_ID = "org.mitk.views.NPOptitrackWidget";
 
 QmitkNPOptitrackWidget::QmitkNPOptitrackWidget(QWidget* parent, Qt::WindowFlags f)
   : QmitkAbstractTrackingDeviceWidget(parent, f)
   , m_Controls(nullptr)
 {
 }
 
 void QmitkNPOptitrackWidget::Initialize()
 {
   InitializeSuperclassWidget();
   CreateQtPartControl(this);
   CreateConnections();
 }
 
 QmitkNPOptitrackWidget::~QmitkNPOptitrackWidget()
 {
   delete m_Controls;
 }
 
 void QmitkNPOptitrackWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNPOptitrackWidget;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkNPOptitrackWidget::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject*)(m_Controls->m_testConnectionOptitrack), SIGNAL(clicked()), this, SLOT(TestConnection()));
     connect((QObject*)(m_Controls->m_SetOptitrackCalibrationFile), SIGNAL(clicked()), this, SLOT(SetOptitrackCalibrationFileClicked()));
   }
 }
 
 void QmitkNPOptitrackWidget::ResetOutput()
 {
   m_Controls->m_outputTextOptitrack->setHtml("<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>");
 }
 
 void QmitkNPOptitrackWidget::AddOutput(std::string s)
 {
   m_Controls->m_outputTextOptitrack->setHtml(QString(s.c_str()));
   m_Controls->m_outputTextOptitrack->verticalScrollBar()->setValue(m_Controls->m_outputTextOptitrack->verticalScrollBar()->maximum());
 }
 
 mitk::TrackingDevice::Pointer QmitkNPOptitrackWidget::ConstructTrackingDevice()
 {
   // Create the Tracking Device
   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());
 
   tempTrackingDevice->SetType(mitk::NPOptitrackTrackingTypeInformation::GetTrackingDeviceName());
   return static_cast<mitk::TrackingDevice::Pointer>(tempTrackingDevice);
 }
 
 bool QmitkNPOptitrackWidget::IsDeviceInstalled()
 {
   return mitk::OptitrackTrackingDevice::New()->IsDeviceInstalled();
 }
 
 void QmitkNPOptitrackWidget::SetOptitrackCalibrationFileClicked()
 {
-  std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Calibration File"), "/", "*.*").toLatin1().data();
+  std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*").toLatin1().data();
   if (filename == "") { return; }
   else
   {
+    QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
     m_OptitrackCalibrationFile = filename;
     Poco::Path myPath = Poco::Path(m_OptitrackCalibrationFile.c_str());
     m_Controls->m_OptitrackCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
   }
 }
 
 QmitkNPOptitrackWidget* QmitkNPOptitrackWidget::Clone(QWidget* parent) const
 {
   QmitkNPOptitrackWidget* clonedWidget = new QmitkNPOptitrackWidget(parent);
   clonedWidget->Initialize();
   clonedWidget->m_OptitrackCalibrationFile = this->m_OptitrackCalibrationFile;
   clonedWidget->m_Controls->m_OptitrackCalibrationFile->setText(m_Controls->m_OptitrackCalibrationFile->text());
 
   clonedWidget->m_Controls->m_OptitrackExp->setValue(m_Controls->m_OptitrackExp->value());
   clonedWidget->m_Controls->m_OptitrackLed->setValue(m_Controls->m_OptitrackLed->value());
   clonedWidget->m_Controls->m_OptitrackThr->setValue(m_Controls->m_OptitrackThr->value());
   return clonedWidget;
 }
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
index ced1b89512..b2e6943286 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
@@ -1,336 +1,340 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkNavigationToolCreationWidget.h"
 
 //mitk headers
 #include <mitkTrackingTypes.h>
 #include <mitkSurface.h>
 #include <mitkNavigationData.h>
 #include <mitkRenderingManager.h>
 #include "mitkTrackingDeviceTypeCollection.h"
 
 //qt headers
 #include <qfiledialog.h>
 #include <qmessagebox.h>
 #include <QDialog>
 #include <mitkIOUtil.h>
+#include <QmitkIGTCommonHelper.h>
 
 //poco headers
 #include <Poco/Path.h>
 
 // vtk
 #include <vtkSphereSource.h>
 #include <vtkConeSource.h>
 
 const std::string QmitkNavigationToolCreationWidget::VIEW_ID = "org.mitk.views.navigationtoolcreationwizardwidget";
 
 QmitkNavigationToolCreationWidget::QmitkNavigationToolCreationWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f)
 {
   m_Controls = NULL;
   m_AdvancedWidget = new QmitkNavigationToolCreationAdvancedWidget(this);
   m_AdvancedWidget->setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
   m_AdvancedWidget->setWindowTitle("Tool Creation Advanced Options");
   m_AdvancedWidget->setModal(false);
   CreateQtPartControl(this);
   CreateConnections();
 
 RefreshTrackingDeviceCollection();
 }
 
 QmitkNavigationToolCreationWidget::~QmitkNavigationToolCreationWidget()
 {
   m_Controls->m_CalibrationLandmarksList->SetPointSetNode(NULL);
   m_Controls->m_RegistrationLandmarksList->SetPointSetNode(NULL);
   delete m_AdvancedWidget;
 }
 
 void QmitkNavigationToolCreationWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNavigationToolCreationWidgetControls;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkNavigationToolCreationWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_cancel), SIGNAL(clicked()), this, SLOT(OnCancel()) );
     connect( (QObject*)(m_Controls->m_finished), SIGNAL(clicked()), this, SLOT(OnFinished()) );
     connect( (QObject*)(m_Controls->m_LoadSurface), SIGNAL(clicked()), this, SLOT(OnLoadSurface()) );
     connect( (QObject*)(m_Controls->m_LoadCalibrationFile), SIGNAL(clicked()), this, SLOT(OnLoadCalibrationFile()) );
     connect( (QObject*)(m_Controls->m_ShowAdvancedOptionsPB), SIGNAL(toggled(bool)), this, SLOT(OnShowAdvancedOptions(bool)) );
     connect( (QObject*)(m_AdvancedWidget), SIGNAL(DialogCloseRequested()), this, SLOT(OnProcessDialogCloseRequest()) );
     connect( (QObject*)(m_AdvancedWidget), SIGNAL(RetrieveDataForManualToolTipManipulation()), this, SLOT(OnRetrieveDataForManualTooltipManipulation()) );
 
     connect( m_Controls->m_Surface_Use_Other, SIGNAL(toggled(bool)), this, SLOT(OnSurfaceUseOtherToggled(bool)));
   }
 }
 
 void QmitkNavigationToolCreationWidget::Initialize(mitk::DataStorage* dataStorage, const std::string& supposedIdentifier, const std::string& supposedName)
 {
   m_DataStorage = dataStorage;
 
   //initialize UI components
   m_Controls->m_SurfaceChooser->SetDataStorage(m_DataStorage);
   m_Controls->m_SurfaceChooser->SetAutoSelectNewItems(true);
   m_Controls->m_SurfaceChooser->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
 
   //set default data
   m_Controls->m_ToolNameEdit->setText(supposedName.c_str());
   m_Controls->m_CalibrationFileName->setText("none");
   m_Controls->m_Surface_Use_Sphere->setChecked(true);
   m_AdvancedWidget->SetDataStorage(m_DataStorage);
   m_Controls->m_IdentifierEdit->setText(supposedIdentifier.c_str());
   this->InitializeUIToolLandmarkLists();
   m_Controls->m_CalibrationLandmarksList->EnableEditButton(false);
   m_Controls->m_RegistrationLandmarksList->EnableEditButton(false);
 }
 
 void QmitkNavigationToolCreationWidget::SetTrackingDeviceType(mitk::TrackingDeviceType type, bool changeable)
 {
   int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(type));
 
   if (index >= 0)
   {
     m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
   }
 }
 
 
 mitk::NavigationTool::Pointer QmitkNavigationToolCreationWidget::GetCreatedTool()
 {
   return m_CreatedTool;
 }
 
 //##################################################################################
 //############################## slots                  ############################
 //##################################################################################
 
 void QmitkNavigationToolCreationWidget::OnFinished()
 {
   //here we create a new tool
   m_CreatedTool = mitk::NavigationTool::New();
 
   //create DataNode...
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   if(m_Controls->m_Surface_Use_Sphere->isChecked())
   {
     //create small sphere and use it as surface
     mitk::Surface::Pointer mySphere = mitk::Surface::New();
     vtkConeSource *vtkData = vtkConeSource::New();
     vtkData->SetAngle(5.0);
     vtkData->SetResolution(50);
     vtkData->SetHeight(6.0f);
     vtkData->SetRadius(2.0f);
     vtkData->SetCenter(0.0, 0.0, 0.0);
     vtkData->Update();
     mySphere->SetVtkPolyData(vtkData->GetOutput());
     vtkData->Delete();
     newNode->SetData(mySphere);
   }
   else
   {
     newNode->SetData(m_Controls->m_SurfaceChooser->GetSelectedNode()->GetData());
   }
   newNode->SetName(m_Controls->m_ToolNameEdit->text().toLatin1());
 
   m_CreatedTool->SetDataNode(newNode);
 
   //fill NavigationTool object
   m_CreatedTool->SetCalibrationFile(m_Controls->m_CalibrationFileName->text().toLatin1().data());
   m_CreatedTool->SetIdentifier(m_Controls->m_IdentifierEdit->text().toLatin1().data());
   m_CreatedTool->SetSerialNumber(m_Controls->m_SerialNumberEdit->text().toLatin1().data());
 
 //Tracking Device
 m_CreatedTool->SetTrackingDeviceType(m_Controls->m_TrackingDeviceTypeChooser->currentText().toStdString());
 
   //ToolType
   if (m_Controls->m_ToolTypeChooser->currentText()=="Instrument") m_CreatedTool->SetType(mitk::NavigationTool::Instrument);
   else if (m_Controls->m_ToolTypeChooser->currentText()=="Fiducial") m_CreatedTool->SetType(mitk::NavigationTool::Fiducial);
   else if (m_Controls->m_ToolTypeChooser->currentText()=="Skinmarker") m_CreatedTool->SetType(mitk::NavigationTool::Skinmarker);
   else m_CreatedTool->SetType(mitk::NavigationTool::Unknown);
 
   //Tool Tip
   mitk::NavigationData::Pointer tempND = mitk::NavigationData::New(m_AdvancedWidget->GetManipulatedToolTip());
   m_CreatedTool->SetToolTipOrientation(tempND->GetOrientation());
   m_CreatedTool->SetToolTipPosition(tempND->GetPosition());
 
   //Tool Landmarks
   mitk::PointSet::Pointer toolCalLandmarks, toolRegLandmarks;
   GetUIToolLandmarksLists(toolCalLandmarks,toolRegLandmarks);
   m_CreatedTool->SetToolCalibrationLandmarks(toolCalLandmarks);
   m_CreatedTool->SetToolRegistrationLandmarks(toolRegLandmarks);
 
   emit NavigationToolFinished();
 }
 
 void QmitkNavigationToolCreationWidget::OnCancel()
 {
   m_CreatedTool = NULL;
 
   emit Canceled();
 }
 
 void QmitkNavigationToolCreationWidget::OnLoadSurface()
 {
-  std::string filename = QFileDialog::getOpenFileName(NULL,tr("Open Surface"), "/", tr("STL (*.stl)")).toLatin1().data();
+  std::string filename = QFileDialog::getOpenFileName(NULL,tr("Open Surface"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("STL (*.stl)")).toLatin1().data();
+  QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
   try
   {
     mitk::IOUtil::Load(filename.c_str(), *m_DataStorage);
   }
   catch (mitk::Exception &e)
   {
     MITK_ERROR << "Exception occured: " << e.what();
   }
 }
 
 void QmitkNavigationToolCreationWidget::OnLoadCalibrationFile()
 {
-  m_Controls->m_CalibrationFileName->setText(QFileDialog::getOpenFileName(NULL,tr("Open Calibration File"), "/", "*.*"));
+  QString fileName = QFileDialog::getOpenFileName(NULL,tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*");
+  QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(fileName);
+  m_Controls->m_CalibrationFileName->setText(fileName);
 }
 
 void QmitkNavigationToolCreationWidget::SetDefaultData(mitk::NavigationTool::Pointer DefaultTool)
 {
 m_Controls->m_ToolNameEdit->setText(QString(DefaultTool->GetDataNode()->GetName().c_str()));
 m_Controls->m_IdentifierEdit->setText(QString(DefaultTool->GetIdentifier().c_str()));
 m_Controls->m_SerialNumberEdit->setText(QString(DefaultTool->GetSerialNumber().c_str()));
 m_AdvancedWidget->SetDefaultTooltip( DefaultTool->GetToolTipTransform() );
 int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(DefaultTool->GetTrackingDeviceType()));
 
 if (index >= 0)
 {
   m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
 }
 
 m_Controls->m_CalibrationFileName->setText(QString(DefaultTool->GetCalibrationFile().c_str()));
 m_Controls->m_Surface_Use_Other->setChecked(true);
 switch(DefaultTool->GetType())
 {
 case mitk::NavigationTool::Instrument:
 m_Controls->m_ToolTypeChooser->setCurrentIndex(0); break;
 case mitk::NavigationTool::Fiducial:
 m_Controls->m_ToolTypeChooser->setCurrentIndex(1); break;
 case mitk::NavigationTool::Skinmarker:
 m_Controls->m_ToolTypeChooser->setCurrentIndex(2); break;
 case mitk::NavigationTool::Unknown:
 m_Controls->m_ToolTypeChooser->setCurrentIndex(3); break;
 }
 
   m_Controls->m_SurfaceChooser->SetSelectedNode(DefaultTool->GetDataNode());
   FillUIToolLandmarkLists(DefaultTool->GetToolCalibrationLandmarks(),DefaultTool->GetToolRegistrationLandmarks());
 }
 
 
 //##################################################################################
 //############################## internal help methods #############################
 //##################################################################################
 void QmitkNavigationToolCreationWidget::MessageBox(std::string s)
 {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
 }
 
 void QmitkNavigationToolCreationWidget::OnShowAdvancedOptions(bool state)
 {
   if(state)
   {
     m_AdvancedWidget->show();
     m_AdvancedWidget->SetDefaultTooltip(m_AdvancedWidget->GetManipulatedToolTip()); //use the last one, if there is one
     m_AdvancedWidget->ReInitialize();
 
     // reinit the views with the new nodes
     mitk::DataStorage::SetOfObjects::ConstPointer rs = m_DataStorage->GetAll();
     mitk::TimeGeometry::Pointer bounds = m_DataStorage->ComputeBoundingGeometry3D(rs, "visible");    // initialize the views to the bounding geometry
     mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
   }
   else
   {
     m_AdvancedWidget->hide();
   }
 }
 
 void QmitkNavigationToolCreationWidget::OnProcessDialogCloseRequest()
 {
   m_AdvancedWidget->hide();
   m_Controls->m_ShowAdvancedOptionsPB->setChecked(false);
 }
 
 void QmitkNavigationToolCreationWidget::OnRetrieveDataForManualTooltipManipulation()
 {
   if(m_Controls->m_Surface_Use_Sphere->isChecked())
   {
     m_AdvancedWidget->SetToolTipSurface(true);
   }
   else
   {
     m_AdvancedWidget->SetToolTipSurface(false,
                                         dynamic_cast<mitk::DataNode*>(m_Controls->m_SurfaceChooser->GetSelectedNode().GetPointer()));
   }
 }
 
 void QmitkNavigationToolCreationWidget::OnSurfaceUseOtherToggled(bool checked)
 {
   m_Controls->m_LoadSurface->setEnabled(checked);
 }
 
 void QmitkNavigationToolCreationWidget::FillUIToolLandmarkLists(mitk::PointSet::Pointer calLandmarks, mitk::PointSet::Pointer regLandmarks)
 {
   m_calLandmarkNode->SetData(calLandmarks);
   m_regLandmarkNode->SetData(regLandmarks);
   m_Controls->m_CalibrationLandmarksList->SetPointSetNode(m_calLandmarkNode);
   m_Controls->m_RegistrationLandmarksList->SetPointSetNode(m_regLandmarkNode);
 }
 
 void QmitkNavigationToolCreationWidget::GetUIToolLandmarksLists(mitk::PointSet::Pointer& calLandmarks, mitk::PointSet::Pointer& regLandmarks)
 {
   calLandmarks = dynamic_cast<mitk::PointSet*>(m_calLandmarkNode->GetData());
   regLandmarks = dynamic_cast<mitk::PointSet*>(m_regLandmarkNode->GetData());
 }
 
 void QmitkNavigationToolCreationWidget::InitializeUIToolLandmarkLists()
 {
   m_calLandmarkNode = mitk::DataNode::New();
   m_regLandmarkNode = mitk::DataNode::New();
   FillUIToolLandmarkLists(mitk::PointSet::New(),mitk::PointSet::New());
 }
 
 void QmitkNavigationToolCreationWidget::RefreshTrackingDeviceCollection()
 {
   us::ModuleContext* context = us::GetModuleContext();
   std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > refs = context->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();
   if (refs.empty())
   {
     MITK_WARN << "No tracking device service found!";
     return;
   }
   mitk::TrackingDeviceTypeCollection* _DeviceTypeCollection = context->GetService<mitk::TrackingDeviceTypeCollection>(refs.front());
 
   for (auto name : _DeviceTypeCollection->GetTrackingDeviceTypeNames())
   {
     //if the device is not included yet, add name to comboBox and widget to stackedWidget
     if (m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(name)) == -1)
     {
       m_Controls->m_TrackingDeviceTypeChooser->addItem(QString::fromStdString(name));
     }
   }
 }
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
index a0e0f9d703..d8a7bd19c8 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
@@ -1,396 +1,418 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkNavigationToolManagementWidget.h"
 
 //mitk headers
 #include "mitkTrackingTypes.h"
 #include <mitkSurface.h>
 #include <mitkNavigationToolReader.h>
 #include <mitkNavigationToolWriter.h>
 #include <mitkNavigationToolStorage.h>
 #include <mitkNavigationToolStorageDeserializer.h>
 #include <mitkNavigationToolStorageSerializer.h>
+#include <QmitkIGTCommonHelper.h>
 
 //qt headers
 #include <qfiledialog.h>
 #include <qinputdialog.h>
 #include <qmessagebox.h>
+#include <qsettings.h>
 
 //poco headers
 #include <Poco/Path.h>
 
 const std::string QmitkNavigationToolManagementWidget::VIEW_ID = "org.mitk.views.navigationtoolmanagementwidget";
 
 QmitkNavigationToolManagementWidget::QmitkNavigationToolManagementWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f)
 {
   m_Controls = NULL;
   CreateQtPartControl(this);
   CreateConnections();
 }
 
 QmitkNavigationToolManagementWidget::~QmitkNavigationToolManagementWidget()
 {
 }
 
 void QmitkNavigationToolManagementWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNavigationToolManagementWidgetControls;
     m_Controls->setupUi(parent);
   }
 
   //Disable StorageControls in the beginning, because there is no storage to edit
   DisableStorageControls();
 }
 
 void QmitkNavigationToolManagementWidget::OnLoadTool()
 {
   if (m_NavigationToolStorage->isLocked())
   {
     MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
     return;
   }
   mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New();
-  std::string filename = QFileDialog::getOpenFileName(NULL, tr("Add Navigation Tool"), "/", "*.IGTTool").toLatin1().data();
+  std::string filename = QFileDialog::getOpenFileName(NULL,tr("Add Navigation Tool"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.IGTTool").toLatin1().data();
+  QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
   if (filename == "") return;
   mitk::NavigationTool::Pointer readTool = myReader->DoRead(filename);
   if (readTool.IsNull()) MessageBox("Error: " + myReader->GetErrorMessage());
   else
   {
     if (!m_NavigationToolStorage->AddTool(readTool))
     {
       MessageBox("Error: Can't add tool!");
       m_DataStorage->Remove(readTool->GetDataNode());
     }
     UpdateToolTable();
     m_NavigationToolStorage->UpdateMicroservice();
   }
 }
 
 void QmitkNavigationToolManagementWidget::OnSaveTool()
 {
   //if no item is selected, show error message:
   if (m_Controls->m_ToolList->currentItem() == NULL) { MessageBox("Error: Please select tool first!"); return; }
 
-  mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
-  std::string filename = QFileDialog::getSaveFileName(NULL, tr("Save Navigation Tool"), "/", "*.IGTTool").toLatin1().data();
-  filename.append(".IGTTool");
-  if (filename == "") return;
-  if (!myWriter->DoWrite(filename, m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row())))
-    MessageBox("Error: " + myWriter->GetErrorMessage());
+    mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
+    std::string filename = QFileDialog::getSaveFileName(NULL,tr("Save Navigation Tool"), QmitkIGTCommonHelper::GetLastFileSavePath(), "*.IGTTool").toLatin1().data();
+    QmitkIGTCommonHelper::SetLastFileSavePathByFileName(QString::fromStdString(filename));
+    filename.append(".IGTTool");
+    if (filename == "") return;
+    if (!myWriter->DoWrite(filename,m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row())))
+      MessageBox("Error: "+ myWriter->GetErrorMessage());
 }
 
 void QmitkNavigationToolManagementWidget::CreateConnections()
 {
   if (m_Controls)
   {
     //main widget page:
     connect((QObject*)(m_Controls->m_AddTool), SIGNAL(clicked()), this, SLOT(OnAddTool()));
     connect((QObject*)(m_Controls->m_DeleteTool), SIGNAL(clicked()), this, SLOT(OnDeleteTool()));
     connect((QObject*)(m_Controls->m_EditTool), SIGNAL(clicked()), this, SLOT(OnEditTool()));
     connect((QObject*)(m_Controls->m_MoveToolUp), SIGNAL(clicked()), this, SLOT(OnMoveToolUp()));
     connect((QObject*)(m_Controls->m_MoveToolDown), SIGNAL(clicked()), this, SLOT(OnMoveToolDown()));
     connect((QObject*)(m_Controls->m_LoadStorage), SIGNAL(clicked()), this, SLOT(OnLoadStorage()));
     connect((QObject*)(m_Controls->m_SaveStorage), SIGNAL(clicked()), this, SLOT(OnSaveStorage()));
     connect((QObject*)(m_Controls->m_LoadTool), SIGNAL(clicked()), this, SLOT(OnLoadTool()));
     connect((QObject*)(m_Controls->m_SaveTool), SIGNAL(clicked()), this, SLOT(OnSaveTool()));
     connect((QObject*)(m_Controls->m_CreateNewStorage), SIGNAL(clicked()), this, SLOT(OnCreateStorage()));
 
     //widget page "add tool":
     connect((QObject*)(m_Controls->m_ToolCreationWidget), SIGNAL(Canceled()), this, SLOT(OnAddToolCancel()));
     connect((QObject*)(m_Controls->m_ToolCreationWidget), SIGNAL(NavigationToolFinished()), this, SLOT(OnAddToolSave()));
   }
 }
 
 void QmitkNavigationToolManagementWidget::Initialize(mitk::DataStorage* dataStorage)
 {
   m_DataStorage = dataStorage;
   m_Controls->m_ToolCreationWidget->Initialize(m_DataStorage, "Tool0");
 }
 
 void QmitkNavigationToolManagementWidget::LoadStorage(mitk::NavigationToolStorage::Pointer storageToLoad)
 {
   if (storageToLoad.IsNotNull())
   {
     m_NavigationToolStorage = storageToLoad;
     m_Controls->m_StorageName->setText(m_NavigationToolStorage->GetName().c_str());
     EnableStorageControls();
   }
   else
   {
     m_NavigationToolStorage = NULL;
     DisableStorageControls();
   }
   UpdateToolTable();
   m_NavigationToolStorage->UpdateMicroservice();
 }
 
 //##################################################################################
 //############################## slots: main widget ################################
 //##################################################################################
 
 void QmitkNavigationToolManagementWidget::OnMoveToolUp()
 {
   if (m_NavigationToolStorage.IsNotNull())
   {
     int toolIndex = m_Controls->m_ToolList->currentIndex().row();
     if (toolIndex >= 0)
     {
       mitk::NavigationTool::Pointer currentNavigationTool = m_NavigationToolStorage->GetTool(toolIndex);
       if (currentNavigationTool.IsNotNull())
       {
         std::string currentIdentifier = currentNavigationTool->GetIdentifier();
         int NewNumber = m_Controls->m_ToolList->currentIndex().row() - 1;
         if (NewNumber < 0) { MITK_WARN << "Cannot move tool up because it is on the top!"; }
         else { m_NavigationToolStorage->AssignToolNumber(currentIdentifier, NewNumber); }
         UpdateToolTable();
         m_NavigationToolStorage->UpdateMicroservice();
       }
     }
   }
 }
 
 void QmitkNavigationToolManagementWidget::OnMoveToolDown()
 {
   if (m_NavigationToolStorage.IsNotNull())
   {
     int toolIndex = m_Controls->m_ToolList->currentIndex().row();
     if (toolIndex >= 0)
     {
       mitk::NavigationTool::Pointer currentNavigationTool = m_NavigationToolStorage->GetTool(toolIndex);
       if (currentNavigationTool.IsNotNull())
       {
         std::string currentIdentifier = currentNavigationTool->GetIdentifier();
         int NewNumber = m_Controls->m_ToolList->currentIndex().row() + 1;
         if (NewNumber >= m_NavigationToolStorage->GetToolCount()) { MITK_WARN << "Cannot move tool down because it is the last tool in this storage!"; }
         else { m_NavigationToolStorage->AssignToolNumber(currentIdentifier, NewNumber); }
         UpdateToolTable();
         m_NavigationToolStorage->UpdateMicroservice();
       }
     }
   }
 }
 
 void QmitkNavigationToolManagementWidget::OnAddTool()
 {
   if (m_NavigationToolStorage->isLocked())
   {
     MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
     return;
   }
   QString defaultIdentifier = "NavigationTool#" + QString::number(m_NavigationToolStorage->GetToolCount());
   QString defaultName = "NavigationTool" + QString::number(m_NavigationToolStorage->GetToolCount());
   m_Controls->m_ToolCreationWidget->Initialize(m_DataStorage, defaultIdentifier.toStdString(), defaultName.toStdString());
   m_edit = false;
   m_Controls->m_MainWidgets->setCurrentIndex(1);
   m_NavigationToolStorage->UpdateMicroservice();
 }
 
 void QmitkNavigationToolManagementWidget::OnDeleteTool()
 {
   //first: some checks
   if (m_NavigationToolStorage->isLocked())
   {
     MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
     return;
   }
   else if (m_Controls->m_ToolList->currentItem() == NULL) //if no item is selected, show error message:
   {
     MessageBox("Error: Please select tool first!");
     return;
   }
 
   m_DataStorage->Remove(m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row())->GetDataNode());
   m_NavigationToolStorage->DeleteTool(m_Controls->m_ToolList->currentIndex().row());
   UpdateToolTable();
   m_NavigationToolStorage->UpdateMicroservice();
 }
 
 void QmitkNavigationToolManagementWidget::OnEditTool()
 {
   if (m_NavigationToolStorage->isLocked())
   {
     MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
     return;
   }
   else if (m_Controls->m_ToolList->currentItem() == NULL) //if no item is selected, show error message:
   {
     MessageBox("Error: Please select tool first!");
     return;
   }
   mitk::NavigationTool::Pointer selectedTool = m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row());
   m_Controls->m_ToolCreationWidget->SetDefaultData(selectedTool);
   m_NavigationToolStorage->SetName("test");
   m_edit = true;
   m_Controls->m_MainWidgets->setCurrentIndex(1);
   m_NavigationToolStorage->UpdateMicroservice();
 }
 
 void QmitkNavigationToolManagementWidget::OnCreateStorage()
 {
   QString storageName = QInputDialog::getText(NULL, "Storage Name", "Name of the new tool storage:");
   if (storageName.isNull()) return;
   m_NavigationToolStorage = mitk::NavigationToolStorage::New(this->m_DataStorage);
   m_NavigationToolStorage->SetName(storageName.toStdString());
   m_Controls->m_StorageName->setText(m_NavigationToolStorage->GetName().c_str());
   EnableStorageControls();
   emit NewStorageAdded(m_NavigationToolStorage, storageName.toStdString());
 }
 
 void QmitkNavigationToolManagementWidget::OnLoadStorage()
 {
   mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(m_DataStorage);
   std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Navigation Tool Storage"), "/", tr("IGT Tool Storage (*.IGTToolStorage)")).toStdString();
   if (filename == "") return;
 
   try
   {
-    mitk::NavigationToolStorage::Pointer tempStorage = myDeserializer->Deserialize(filename);
+    mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(m_DataStorage);
+    std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Navigation Tool Storage"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("IGT Tool Storage (*.IGTToolStorage)")).toStdString();
+    if (filename == "") return;
+
+    QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
 
-    if (tempStorage.IsNull()) MessageBox("Error" + myDeserializer->GetErrorMessage());
-    else
+    try
+    {
+      mitk::NavigationToolStorage::Pointer tempStorage = myDeserializer->Deserialize(filename);
+
+      if (tempStorage.IsNull()) MessageBox("Error" + myDeserializer->GetErrorMessage());
+      else
+      {
+        Poco::Path myPath = Poco::Path(filename.c_str());
+        tempStorage->SetName(myPath.getFileName()); //set the filename as name for the storage, so the user can identify it
+        this->LoadStorage(tempStorage);
+        emit NewStorageAdded(m_NavigationToolStorage,myPath.getFileName());
+        m_NavigationToolStorage->UpdateMicroservice();
+      }
+    }
+    catch (const mitk::Exception& exception)
     {
-      Poco::Path myPath = Poco::Path(filename.c_str());
-      tempStorage->SetName(myPath.getFileName()); //set the filename as name for the storage, so the user can identify it
-      this->LoadStorage(tempStorage);
-      emit NewStorageAdded(m_NavigationToolStorage, myPath.getFileName());
+      MessageBox(exception.GetDescription());
     }
   }
   catch (const mitk::Exception& exception)
   {
     MessageBox(exception.GetDescription());
   }
   m_NavigationToolStorage->UpdateMicroservice();
 }
 
 void QmitkNavigationToolManagementWidget::OnSaveStorage()
-{
-  //read in filename
-  QString filename = QFileDialog::getSaveFileName(NULL, tr("Save Navigation Tool Storage"), "/", tr("IGT Tool Storage (*.IGTToolStorage)"));
-  if (filename.isEmpty()) return; //canceled by the user
+  {
+    QFileDialog *fileDialog = new QFileDialog;
+    fileDialog->setDefaultSuffix("IGTToolStorage");
+    QString suffix = "IGT Tool Storage (*.IGTToolStorage)";
+    QString filename  = fileDialog->getSaveFileName(NULL, tr("Save Navigation Tool Storage"), QmitkIGTCommonHelper::GetLastFileSavePath(), suffix, &suffix);
 
-  // add file extension if it wasn't added by the file dialog
-  if (filename.right(15) != ".IGTToolStorage") { filename += ".IGTToolStorage"; }
+    if (filename.isEmpty()) return; //canceled by the user
 
+    // check file suffix
+    QFileInfo file(filename);
+    if(file.suffix().isEmpty()) filename += ".IGTToolStorage";
   //serialize tool storage
   mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
   if (!mySerializer->Serialize(filename.toStdString(), m_NavigationToolStorage))
   {
     MessageBox("Error: " + mySerializer->GetErrorMessage());
     return;
+    QmitkIGTCommonHelper::SetLastFileSavePath(file.absolutePath());
   }
   Poco::Path myPath = Poco::Path(filename.toStdString());
   m_Controls->m_StorageName->setText(QString::fromStdString(myPath.getFileName()));
 }
 
 //##################################################################################
 //############################## slots: add tool widget ############################
 //##################################################################################
 
 void QmitkNavigationToolManagementWidget::OnAddToolSave()
 {
   mitk::NavigationTool::Pointer newTool = m_Controls->m_ToolCreationWidget->GetCreatedTool();
 
   if (m_edit) //here we edit a existing tool
   {
     mitk::NavigationTool::Pointer editedTool = m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row());
     editedTool->Graft(newTool);
   }
   else //here we create a new tool
   {
     m_NavigationToolStorage->AddTool(newTool);
   }
 
   UpdateToolTable();
 
   m_Controls->m_MainWidgets->setCurrentIndex(0);
   m_NavigationToolStorage->UpdateMicroservice();
 }
 
 void QmitkNavigationToolManagementWidget::OnAddToolCancel()
 {
   m_Controls->m_MainWidgets->setCurrentIndex(0);
 }
 
 //##################################################################################
 //############################## private help methods ##############################
 //##################################################################################
 void QmitkNavigationToolManagementWidget::UpdateToolTable()
 {
   m_Controls->m_ToolList->clear();
   if (m_NavigationToolStorage.IsNull()) return;
   for (int i = 0; i < m_NavigationToolStorage->GetToolCount(); i++)
   {
     QString currentTool = "Tool" + QString::number(i) + ": " + QString(m_NavigationToolStorage->GetTool(i)->GetDataNode()->GetName().c_str()) + " ";
 
     currentTool += "(" + QString::fromStdString(m_NavigationToolStorage->GetTool(i)->GetTrackingDeviceType()) + "/";
 
     switch (m_NavigationToolStorage->GetTool(i)->GetType())
     {
     case mitk::NavigationTool::Instrument:
       currentTool += "Instrument)"; break;
     case mitk::NavigationTool::Fiducial:
       currentTool += "Fiducial)"; break;
     case mitk::NavigationTool::Skinmarker:
       currentTool += "Skinmarker)"; break;
     default:
       currentTool += "Unknown)";
     }
     m_Controls->m_ToolList->addItem(currentTool);
   }
 }
 
 void QmitkNavigationToolManagementWidget::MessageBox(std::string s)
 {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
 }
 
 void QmitkNavigationToolManagementWidget::DisableStorageControls()
 {
   m_Controls->m_StorageName->setText("<none>");
   m_Controls->m_AddTool->setEnabled(false);
   m_Controls->m_LoadTool->setEnabled(false);
   m_Controls->m_MoveToolUp->setEnabled(false);
   m_Controls->m_MoveToolDown->setEnabled(false);
   m_Controls->m_selectedLabel->setEnabled(false);
   m_Controls->m_DeleteTool->setEnabled(false);
   m_Controls->m_EditTool->setEnabled(false);
   m_Controls->m_SaveTool->setEnabled(false);
   m_Controls->m_ToolList->setEnabled(false);
   m_Controls->m_SaveStorage->setEnabled(false);
   m_Controls->m_ToolLabel->setEnabled(false);
 }
 
 void QmitkNavigationToolManagementWidget::EnableStorageControls()
 {
   m_Controls->m_AddTool->setEnabled(true);
   m_Controls->m_LoadTool->setEnabled(true);
   m_Controls->m_MoveToolUp->setEnabled(true);
   m_Controls->m_MoveToolDown->setEnabled(true);
   m_Controls->m_selectedLabel->setEnabled(true);
   m_Controls->m_DeleteTool->setEnabled(true);
   m_Controls->m_EditTool->setEnabled(true);
   m_Controls->m_SaveTool->setEnabled(true);
   m_Controls->m_ToolList->setEnabled(true);
   m_Controls->m_SaveStorage->setEnabled(true);
   m_Controls->m_ToolLabel->setEnabled(true);
 }
\ No newline at end of file
diff --git a/Modules/IGTUI/files.cmake b/Modules/IGTUI/files.cmake
index 9678e39cb4..df2e5e6088 100644
--- a/Modules/IGTUI/files.cmake
+++ b/Modules/IGTUI/files.cmake
@@ -1,114 +1,116 @@
 set(CPP_FILES
   Qmitk/QmitkTrackingDeviceWidget.cpp
   Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
   Qmitk/QmitkNDIConfigurationWidget.cpp
   Qmitk/QmitkFiducialRegistrationWidget.cpp
   Qmitk/QmitkNDIToolDelegate.cpp
   Qmitk/QmitkNavigationToolManagementWidget.cpp
   Qmitk/QmitkIGTLoggerWidget.cpp
   Qmitk/QmitkUpdateTimerWidget.cpp
   Qmitk/QmitkToolDistanceWidget.cpp
   Qmitk/QmitkToolTrackingStatusWidget.cpp
   Qmitk/QmitkTrackingSourcesCheckBoxPanelWidget.cpp
   Qmitk/QmitkIGTPlayerWidget.cpp
   Qmitk/QmitkIGTConnectionWidget.cpp
   Qmitk/QmitkToolSelectionWidget.cpp
   Qmitk/QmitkNavigationToolCreationWidget.cpp
   Qmitk/QmitkNavigationToolCreationAdvancedWidget.cpp
   Qmitk/QmitkNavigationDataSourceSelectionWidget.cpp
   Qmitk/QmitkInteractiveTransformationWidget.cpp
   Qmitk/QmitkNavigationToolStorageSelectionWidget.cpp
 
   Qmitk/QmitkNavigationDataPlayerControlWidget.cpp
   Qmitk/QmitkNavigationDataSequentialPlayerControlWidget.cpp
 
   Qmitk/QmitkNDIAuroraWidget.cpp
   Qmitk/QmitkNDIPolarisWidget.cpp
   Qmitk/QmitkMicronTrackerWidget.cpp
   Qmitk/QmitkNPOptitrackWidget.cpp
   Qmitk/QmitkVirtualTrackerWidget.cpp
   Qmitk/QmitkOpenIGTLinkWidget.cpp
 
   Qmitk/mitkTrackingDeviceWidgetCollection.cpp
   Qmitk/QmitkTrackingDeviceConfigurationWidgetScanPortsWorker.cpp
   Qmitk/QmitkTrackingDeviceConfigurationWidgetConnectionWorker.cpp
   Qmitk/QmitkNDIAbstractDeviceWidget.cpp
   Qmitk/QmitkAbstractTrackingDeviceWidget.cpp
+  Qmitk/QmitkIGTCommonHelper.cpp
 )
 
 set(UI_FILES
   Qmitk/QmitkNavigationToolManagementWidgetControls.ui
   Qmitk/QmitkTrackingDeviceConfigurationWidgetControls.ui
   Qmitk/QmitkNDIConfigurationWidget.ui
   Qmitk/QmitkFiducialRegistrationWidget.ui
   Qmitk/QmitkIGTLoggerWidgetControls.ui
   Qmitk/QmitkUpdateTimerWidgetControls.ui
   Qmitk/QmitkToolDistanceWidgetControls.ui
   Qmitk/QmitkToolTrackingStatusWidgetControls.ui
   Qmitk/QmitkTrackingSourcesCheckBoxPanelWidgetControls.ui
   Qmitk/QmitkIGTPlayerWidgetControls.ui
   Qmitk/QmitkIGTConnectionWidgetControls.ui
   Qmitk/QmitkToolSelectionWidgetControls.ui
   Qmitk/QmitkNavigationToolCreationWidget.ui
   Qmitk/QmitkNavigationToolCreationAdvancedWidgetControls.ui
   Qmitk/QmitkNavigationDataSourceSelectionWidgetControls.ui
   Qmitk/QmitkInteractiveTransformationWidgetControls.ui
   Qmitk/QmitkNavigationToolStorageSelectionWidgetControls.ui
 
   Qmitk/QmitkNavigationDataPlayerControlWidget.ui
   Qmitk/QmitkNavigationDataSequentialPlayerControlWidget.ui
 
   Qmitk/QmitkNDIAuroraWidget.ui
   Qmitk/QmitkNDIPolarisWidget.ui
   Qmitk/QmitkMicronTrackerWidget.ui
   Qmitk/QmitkNPOptitrackWidget.ui
   Qmitk/QmitkVirtualTrackerWidget.ui
   Qmitk/QmitkOpenIGTLinkWidget.ui
 )
 
 set(MOC_H_FILES
   Qmitk/QmitkNavigationToolManagementWidget.h
   Qmitk/QmitkTrackingDeviceWidget.h
   Qmitk/QmitkTrackingDeviceConfigurationWidget.h
   Qmitk/QmitkNDIConfigurationWidget.h
   Qmitk/QmitkFiducialRegistrationWidget.h
   Qmitk/QmitkNDIToolDelegate.h
   Qmitk/QmitkIGTLoggerWidget.h
   Qmitk/QmitkUpdateTimerWidget.h
   Qmitk/QmitkToolDistanceWidget.h
   Qmitk/QmitkToolTrackingStatusWidget.h
   Qmitk/QmitkTrackingSourcesCheckBoxPanelWidget.h
   Qmitk/QmitkIGTPlayerWidget.h
   Qmitk/QmitkIGTConnectionWidget.h
   Qmitk/QmitkToolSelectionWidget.h
   Qmitk/QmitkNavigationToolCreationWidget.h
   Qmitk/QmitkNavigationToolCreationAdvancedWidget.h
   Qmitk/QmitkNavigationDataSourceSelectionWidget.h
   Qmitk/QmitkInteractiveTransformationWidget.h
   Qmitk/QmitkNavigationToolStorageSelectionWidget.h
 
   Qmitk/QmitkNavigationDataPlayerControlWidget.h
   Qmitk/QmitkNavigationDataSequentialPlayerControlWidget.h
 
   Qmitk/QmitkNDIAuroraWidget.h
   Qmitk/QmitkNDIPolarisWidget.h
   Qmitk/QmitkMicronTrackerWidget.h
   Qmitk/QmitkNPOptitrackWidget.h
   Qmitk/QmitkVirtualTrackerWidget.h
   Qmitk/QmitkOpenIGTLinkWidget.h
 
   Qmitk/QmitkTrackingDeviceConfigurationWidgetScanPortsWorker.h
   Qmitk/QmitkTrackingDeviceConfigurationWidgetConnectionWorker.h
   Qmitk/QmitkNDIAbstractDeviceWidget.h
   Qmitk/QmitkAbstractTrackingDeviceWidget.h
+  Qmitk/QmitkIGTCommonHelper.h
 )
 
 if(MITK_USE_POLHEMUS_TRACKER)
   set(CPP_FILES ${CPP_FILES} Qmitk/QmitkPolhemusTrackerWidget.cpp)
   set(UI_FILES ${UI_FILES} Qmitk/QmitkPolhemusTrackerWidget.ui)
   set(MOC_H_FILES ${MOC_H_FILES} Qmitk/QmitkPolhemusTrackerWidget.h)
 endif(MITK_USE_POLHEMUS_TRACKER)
 
 set(QRC_FILES
   resources/IGTUI.qrc
 )