diff --git a/Applications/Workbench/MitkWorkbench.cpp b/Applications/Workbench/MitkWorkbench.cpp
index c49e561ce9..a4899a10da 100644
--- a/Applications/Workbench/MitkWorkbench.cpp
+++ b/Applications/Workbench/MitkWorkbench.cpp
@@ -1,204 +1,205 @@
 /*===================================================================
 
 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 <application/berryStarter.h>
 #include <Poco/Util/MapConfiguration.h>
 
 #include <QApplication>
 #include <QMessageBox>
 #include <QtSingleApplication>
 #include <QtGlobal>
 #include <QTime>
+#include <QDir>
 #include <QDesktopServices>
 
 #include <usModuleSettings.h>
 
 #include <mitkCommon.h>
 #include <mitkException.h>
 
 class QtSafeApplication : public QtSingleApplication
 {
 
 public:
 
   QtSafeApplication(int& argc, char** argv) : QtSingleApplication(argc, argv)
   {}
 
   /**
    * Reimplement notify to catch unhandled exceptions and open an error message.
    *
    * @param receiver
    * @param event
    * @return
    */
   bool notify(QObject* receiver, QEvent* event)
   {
     QString msg;
     try
     {
       return QApplication::notify(receiver, event);
     }
     catch (mitk::Exception& e)
     {
       msg = QString("MITK Exception:\n\n")
             + QString("Description: ")
             + QString(e.GetDescription()) + QString("\n\n")
             + QString("Filename: ") + QString(e.GetFile()) + QString("\n\n")
             + QString("Line: ") + QString::number(e.GetLine());
     }
     catch (Poco::Exception& e)
     {
       msg = QString::fromStdString(e.displayText());
     }
     catch (std::exception& e)
     {
       msg = e.what();
     }
     catch (...)
     {
       msg = "Unknown exception";
     }
     MITK_ERROR << "An error occurred: " << msg.toStdString();
 
     QMessageBox msgBox;
     msgBox.setText("An error occurred. You should save all data and quit the program to prevent possible data loss.");
     msgBox.setDetailedText(msg);
     msgBox.setIcon(QMessageBox::Critical);
     msgBox.addButton(trUtf8("Exit immediately"), QMessageBox::YesRole);
     msgBox.addButton(trUtf8("Ignore"), QMessageBox::NoRole);
 
     int ret = msgBox.exec();
 
     switch(ret)
       {
       case 0:
         MITK_ERROR << "The program was closed.";
         this->closeAllWindows();
         break;
       case 1:
         MITK_ERROR << "The error was ignored by the user. The program may be in a corrupt state and don't behave like expected!";
         break;
       }
 
     return false;
   }
 
 };
 
 
 int main(int argc, char** argv)
 {
   // Create a QApplication instance first
   QtSafeApplication qSafeApp(argc, argv);
   qSafeApp.setApplicationName("MITK Workbench");
   qSafeApp.setOrganizationName("DKFZ");
 
   // This function checks if an instance is already running
   // and either sends a message to it (containing the command
   // line arguments) or checks if a new instance was forced by
   // providing the BlueBerry.newInstance command line argument.
   // In the latter case, a path to a temporary directory for
   // the new application's storage directory is returned.
   QString storageDir = handleNewAppInstance(&qSafeApp, argc, argv, "BlueBerry.newInstance");
 
   if (storageDir.isEmpty())
   {
     // This is a new instance and no other instance is already running. We specify
     // the storage directory here (this is the same code as in berryInternalPlatform.cpp
     // so that we can re-use the location for the persistent data location of the
     // the CppMicroServices library.
 
     // Append a hash value of the absolute path of the executable to the data location.
     // This allows to start the same application from different build or install trees.
     storageDir = QDesktopServices::storageLocation(QDesktopServices::DataLocation) + '_';
-    storageDir += QString::number(qHash(QCoreApplication::applicationDirPath())) + "/";
+    storageDir += QString::number(qHash(QCoreApplication::applicationDirPath())) + QDir::separator();
   }
-  us::ModuleSettings::SetStoragePath((storageDir + "us/").toStdString());
+  us::ModuleSettings::SetStoragePath((storageDir + QString("us") + QDir::separator()).toStdString());
 
   // These paths replace the .ini file and are tailored for installation
   // packages created with CPack. If a .ini file is presented, it will
   // overwrite the settings in MapConfiguration
   Poco::Path basePath(argv[0]);
   basePath.setFileName("");
 
   Poco::Path provFile(basePath);
   provFile.setFileName("MitkWorkbench.provisioning");
 
   Poco::Path extPath(basePath);
   extPath.pushDirectory("ExtBundles");
 
   std::string pluginDirs = extPath.toString();
 
   Poco::Util::MapConfiguration* extConfig(new Poco::Util::MapConfiguration());
   if (!storageDir.isEmpty())
   {
     extConfig->setString(berry::Platform::ARG_STORAGE_DIR, storageDir.toStdString());
   }
   extConfig->setString(berry::Platform::ARG_PLUGIN_DIRS, pluginDirs);
   extConfig->setString(berry::Platform::ARG_PROVISIONING, provFile.toString());
   extConfig->setString(berry::Platform::ARG_APPLICATION, "org.mitk.qt.extapplication");
 
 #ifdef Q_OS_WIN
 #define CTK_LIB_PREFIX
 #else
 #define CTK_LIB_PREFIX "lib"
 #endif
 
 
   QString libraryPath = "liborg_mitk_gui_qt_ext,";
 
   // Fix for bug 17557:
   // Setting absolute path to liborg_mitk_gui_qt_ext. Otherwise MITK fails to preload
   // the library liborg_mitk_gui_qt_ext which leads to a crash on Mac OS 10.9
 #ifdef Q_OS_MAC
 
   // In case the application is started from an install directory
   QString tempLibraryPath = QCoreApplication::applicationDirPath().append("/plugins/liborg_mitk_gui_qt_ext.dylib");
 
   QFile preloadLibrary (tempLibraryPath);
   if (preloadLibrary.exists())
   {
     tempLibraryPath.append(",");
     libraryPath = tempLibraryPath;
   }
   else
   {
     // In case the application is started from a build tree
     tempLibraryPath = QCoreApplication::applicationDirPath().append("/../../../plugins/liborg_mitk_gui_qt_ext.dylib");
 
     preloadLibrary.setFileName(tempLibraryPath);
     if (preloadLibrary.exists())
     {
       tempLibraryPath.append(",");
       libraryPath = tempLibraryPath;
     }
   }
 #endif
 
   // Preload the org.mitk.gui.qt.ext plug-in (and hence also QmitkExt) to speed
   // up a clean-cache start. This also works around bugs in older gcc and glibc implementations,
   // which have difficulties with multiple dynamic opening and closing of shared libraries with
   // many global static initializers. It also helps if dependent libraries have weird static
   // initialization methods and/or missing de-initialization code.
   extConfig->setString(berry::Platform::ARG_PRELOAD_LIBRARY, libraryPath.toStdString()+CTK_LIB_PREFIX "CTKDICOMCore:0.1");
 
   // Seed the random number generator, once at startup.
   QTime time = QTime::currentTime();
   qsrand((uint)time.msec());
 
   // Run the workbench.
   return berry::Starter::Run(argc, argv, extConfig);
 }
diff --git a/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
index 270e14a7bd..6cd28b9d46 100644
--- a/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
@@ -1,716 +1,716 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkTrackingDeviceConfigurationWidget.h"
 #include <mitkClaronTrackingDevice.h>
 #include <mitkNDITrackingDevice.h>
 #include <mitkOptitrackTrackingDevice.h>
 #include <mitkIGTException.h>
 #include <mitkSerialCommunication.h>
 #include <mitkProgressBar.h>
 #include <qscrollbar.h>
 #include <qmessagebox.h>
 #include <qfiledialog.h>
 #include <mitkIGTException.h>
 #include <QSettings>
 
 #include <itksys/SystemTools.hxx>
 #include <Poco/Path.h>
 
 
 
 const std::string QmitkTrackingDeviceConfigurationWidget::VIEW_ID = "org.mitk.views.trackingdeviceconfigurationwidget";
 
 QmitkTrackingDeviceConfigurationWidget::QmitkTrackingDeviceConfigurationWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f)
 {
   //initialize worker thread
   m_TestConnectionWorker = new QmitkTrackingDeviceConfigurationWidgetConnectionWorker();
   m_ScanPortsWorker = new QmitkTrackingDeviceConfigurationWidgetScanPortsWorker();
   m_ScanPortsWorkerThread = new QThread();
   m_TestConnectionWorkerThread = new QThread();
 
   m_Controls = NULL;
   CreateQtPartControl(this);
   CreateConnections();
   m_MTCalibrationFile = "";
 
   //reset a few things
   ResetOutput();
   AddOutput("<br>NDI Polaris selected");
   this->m_TrackingDeviceConfigurated = false;
 
   m_AdvancedUserControl = true;
 }
 
 void QmitkTrackingDeviceConfigurationWidget::SetGUIStyle(QmitkTrackingDeviceConfigurationWidget::Style style)
 {
 switch(style)
   {
   case QmitkTrackingDeviceConfigurationWidget::SIMPLE:
 
     //move all UI elements to an empty dummy layout
     //m_Controls->dummyLayout->addItem(m_Controls->mainLayout);
     m_Controls->dummyLayout->addWidget(m_Controls->widget_title_label);
     m_Controls->dummyLayout->addWidget(m_Controls->choose_tracking_device_label);
     m_Controls->dummyLayout->addWidget(m_Controls->polaris_label);
     m_Controls->dummyLayout->addWidget(m_Controls->aurora_label);
     //m_Controls->dummyLayout->addWidget(m_Controls->aurora_label);
     m_Controls->dummyLayout->addWidget(m_Controls->microntracker_label);
     m_Controls->dummyLayout->addWidget(m_Controls->m_testConnectionMicronTracker);
     m_Controls->dummyLayout->addWidget(m_Controls->m_outputTextMicronTracker);
     m_Controls->dummyLayout->addWidget(m_Controls->m_outputTextAurora);
     m_Controls->dummyLayout->addWidget(m_Controls->m_testConnectionAurora);
     m_Controls->dummyLayout->addWidget(m_Controls->m_outputTextPolaris);
     m_Controls->dummyLayout->addWidget(m_Controls->m_testConnectionPolaris);
     m_Controls->dummyLayout->addWidget(m_Controls->m_polarisTrackingModeBox);
     m_Controls->dummyLayout->addWidget(m_Controls->m_testConnectionOptitrack);
     m_Controls->dummyLayout->addWidget(m_Controls->m_outputTextOptitrack);
     m_Controls->dummyLayout->addWidget(m_Controls->m_OptitrackExp);
     m_Controls->dummyLayout->addWidget(m_Controls->m_OptitrackThr);
     m_Controls->dummyLayout->addWidget(m_Controls->m_OptitrackLed);
     m_Controls->dummyLayout->addWidget(m_Controls->Optitrack_label);
     m_Controls->dummyLayout->addWidget(m_Controls->m_finishedLine);
     m_Controls->dummyLayout->addWidget(m_Controls->line);
     m_Controls->dummyLayout->addWidget(m_Controls->configuration_finished_label);
     m_Controls->dummyLayout->addItem(m_Controls->horizontalLayout_4);
     m_Controls->mainLayout->removeItem(m_Controls->horizontalLayout_4);
     m_Controls->dummyLayout->addWidget(m_Controls->configuration_finished_label);
     m_Controls->dummyLayout->addItem(m_Controls->verticalSpacer_2);
     m_Controls->verticalLayout_3->removeItem(m_Controls->verticalSpacer_2);
     m_Controls->dummyLayout->addItem(m_Controls->horizontalSpacer_9);
     m_Controls->horizontalLayout_9->removeItem(m_Controls->horizontalSpacer_9);
     m_Controls->dummyLayout->addItem(m_Controls->horizontalSpacer_3);
     m_Controls->horizontalLayout_11->removeItem(m_Controls->horizontalSpacer_3);
     m_Controls->dummyLayout->addItem(m_Controls->verticalSpacer_3);
     m_Controls->verticalLayout_7->removeItem(m_Controls->verticalSpacer_3);
     m_Controls->dummyLayout->addItem(m_Controls->verticalSpacer_4);
     m_Controls->verticalLayout_10->removeItem(m_Controls->verticalSpacer_4);
     m_Controls->dummyLayout->addItem(m_Controls->horizontalSpacer_10);
     m_Controls->verticalLayout_10->removeItem(m_Controls->horizontalSpacer_10);
 
     //set height to min
     m_Controls->m_outputTextPolaris->setMinimumHeight(0);
     m_Controls->m_outputTextPolaris->setMaximumHeight(0);
     m_Controls->m_outputTextMicronTracker->setMinimumHeight(0);
     m_Controls->m_outputTextMicronTracker->setMaximumHeight(0);
     m_Controls->m_outputTextAurora->setMinimumHeight(0);
     m_Controls->m_outputTextAurora->setMaximumHeight(0);
     m_Controls->m_finishedButton->setMinimumHeight(0);
     m_Controls->m_finishedButton->setMaximumHeight(0);
     m_Controls->m_resetButton->setMinimumHeight(0);
     m_Controls->m_resetButton->setMaximumHeight(0);
 
 
     //set the height of the tracking device combo box
     m_Controls->m_trackingDeviceChooser->setMinimumHeight(50);
 
     //move back the used elemets to the main layout
     m_Controls->simpleLayout->addWidget(m_Controls->m_trackingDeviceChooser);
     m_Controls->simpleLayout->addWidget(m_Controls->m_TrackingSystemWidget);
 
     m_Controls->mainWidget->setCurrentIndex(1);
 
     this->setMaximumHeight(150);
 
     this->EnableAdvancedUserControl(false);
 
 
     break;
 
   case QmitkTrackingDeviceConfigurationWidget::ADVANCED:
 
     //default at the moment => start settings are advanced
 
     break;
 
   }
 
 }
 
 QmitkTrackingDeviceConfigurationWidget::~QmitkTrackingDeviceConfigurationWidget()
 {
 StoreUISettings();
 if (m_ScanPortsWorker) delete m_ScanPortsWorker;
 if (m_TestConnectionWorker) delete m_TestConnectionWorker;
 if (m_ScanPortsWorkerThread) delete m_ScanPortsWorkerThread;
 if (m_TestConnectionWorkerThread) delete m_TestConnectionWorkerThread;
 }
 
 void QmitkTrackingDeviceConfigurationWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
   // create GUI widgets
   m_Controls = new Ui::QmitkTrackingDeviceConfigurationWidgetControls;
   m_Controls->setupUi(parent);
   }
 }
 
 void QmitkTrackingDeviceConfigurationWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_trackingDeviceChooser), SIGNAL(currentIndexChanged(int)), this, SLOT(TrackingDeviceChanged()) );
     connect( (QObject*)(m_Controls->m_testConnectionPolaris), SIGNAL(clicked()), this, SLOT(TestConnection()) );
     connect( (QObject*)(m_Controls->m_testConnectionAurora), SIGNAL(clicked()), this, SLOT(TestConnection()) );
     connect( (QObject*)(m_Controls->m_testConnectionMicronTracker), SIGNAL(clicked()), this, SLOT(TestConnection()) );
     connect( (QObject*)(m_Controls->m_testConnectionOptitrack), SIGNAL(clicked()), this, SLOT(TestConnection()) );
     connect( (QObject*)(m_Controls->m_resetButton), SIGNAL(clicked()), this, SLOT(ResetByUser()) );
     connect( (QObject*)(m_Controls->m_finishedButton), SIGNAL(clicked()), this, SLOT(Finished()) );
     connect( (QObject*)(m_Controls->m_AutoScanPolaris), SIGNAL(clicked()), this, SLOT(AutoScanPorts()) );
     connect( (QObject*)(m_Controls->m_AutoScanAurora), SIGNAL(clicked()), this, SLOT(AutoScanPorts()) );
     connect( (QObject*)(m_Controls->m_SetMTCalibrationFile), SIGNAL(clicked()), this, SLOT(SetMTCalibrationFileClicked()) );
     connect( (QObject*)(m_Controls->m_SetOptitrackCalibrationFile), SIGNAL(clicked()), this, SLOT(SetOptitrackCalibrationFileClicked()) );
 
     //slots for the worker thread
     connect(m_ScanPortsWorker, SIGNAL(PortsScanned(int,int,QString,int,int)), this, SLOT(AutoScanPortsFinished(int,int,QString,int,int)) );
     connect(m_TestConnectionWorker, SIGNAL(ConnectionTested(bool,QString)), this, SLOT(TestConnectionFinished(bool,QString)) );
     connect(m_ScanPortsWorkerThread,SIGNAL(started()), m_ScanPortsWorker, SLOT(ScanPortsThreadFunc()) );
     connect(m_TestConnectionWorkerThread,SIGNAL(started()), m_TestConnectionWorker, SLOT(TestConnectionThreadFunc()) );
 
     //move the worker to the thread
     m_ScanPortsWorker->moveToThread(m_ScanPortsWorkerThread);
     m_TestConnectionWorker->moveToThread(m_TestConnectionWorkerThread);
 
     //set a few UI components depending on Windows / Linux
     #ifdef WIN32
     m_Controls->portTypeLabelPolaris->setVisible(false);
     m_Controls->portTypePolaris->setVisible(false);
     m_Controls->portTypeLabelAurora->setVisible(false);
     m_Controls->portTypeAurora->setVisible(false);
     #else
     m_Controls->comPortLabelAurora->setText("Port Nr:");
     m_Controls->m_comPortLabelPolaris->setText("Port Nr:");
     m_Controls->m_portSpinBoxAurora->setPrefix("");
     m_Controls->m_portSpinBoxPolaris->setPrefix("");
     #endif
 
     //disable unused UI component
     m_Controls->m_polarisTrackingModeBox->setVisible(false); //don't delete this component, because it is used in the MBI part of MITK
   }
   LoadUISettings();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::TrackingDeviceChanged()
 {
   //show the correspondig widget
   m_Controls->m_TrackingSystemWidget->setCurrentIndex(m_Controls->m_trackingDeviceChooser->currentIndex());
 
   //the new trackingdevice is not configurated yet
   m_TrackingDeviceConfigurated = false;
 
   //reset output
   ResetOutput();
 
   //print output and do further initializations
   if (m_Controls->m_trackingDeviceChooser->currentIndex()==0)//NDI Polaris
     {
     AddOutput("<br>NDI Polaris selected");
     }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==1)  //NDI Aurora
     {
     AddOutput("<br>NDI Aurora selected");
     }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==2) //ClaronTechnology MicronTracker 2
     {
     AddOutput("<br>Microntracker selected");
     if (!mitk::ClaronTrackingDevice::New()->IsDeviceInstalled())
       {
       AddOutput("<br>ERROR: not installed!");
       }
     else if (this->m_MTCalibrationFile == "") //if configuration file for MicronTracker is empty: load default
       {
       mitk::ClaronTrackingDevice::Pointer tempDevice = mitk::ClaronTrackingDevice::New();
       m_MTCalibrationFile = tempDevice->GetCalibrationDir();
       Poco::Path myPath = Poco::Path(m_MTCalibrationFile.c_str());
       m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
       }
     }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==3)
   {
     AddOutput("<br>Optitrack selected");
     if (!mitk::OptitrackTrackingDevice::New()->IsDeviceInstalled())
       {
       AddOutput("<br>ERROR: not installed!");
       }
   }
 
 emit TrackingDeviceSelectionChanged();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::EnableUserReset(bool enable)
 {
   if (enable) m_Controls->m_resetButton->setVisible(true);
   else m_Controls->m_resetButton->setVisible(false);
 }
 
 void QmitkTrackingDeviceConfigurationWidget::TestConnection()
 {
 this->setEnabled(false);
 //construct a tracking device:
 mitk::TrackingDevice::Pointer testTrackingDevice = ConstructTrackingDevice();
 m_TestConnectionWorker->SetTrackingDevice(testTrackingDevice);
 m_TestConnectionWorkerThread->start();
 emit ProgressStarted();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::TestConnectionFinished(bool connected, QString output)
 {
 m_TestConnectionWorkerThread->quit();
 AddOutput(output.toStdString());
 MITK_INFO << "Test connection: " << connected;
 this->setEnabled(true);
 emit ProgressFinished();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::Finished()
   {
   m_TrackingDevice = ConstructTrackingDevice();
   m_Controls->m_TrackingSystemWidget->setEnabled(false);
   m_Controls->m_trackingDeviceChooser->setEnabled(false);
   m_Controls->choose_tracking_device_label->setEnabled(false);
   m_Controls->configuration_finished_label->setText("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\np, li { white-space: pre-wrap; }\n</style></head><body style=\" font-family:\'MS Shell Dlg 2\'; font-size:8.25pt; font-weight:400; font-style:normal;\">\n<p align=\"right\" style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-size:8pt;\"><span style=\" font-weight:600;\">Configuration finished</span></p></body></html>");
   this->m_TrackingDeviceConfigurated = true;
   emit TrackingDeviceConfigurationFinished();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::Reset()
   {
   m_TrackingDevice = NULL;
   m_Controls->m_TrackingSystemWidget->setEnabled(true);
   m_Controls->m_trackingDeviceChooser->setEnabled(true);
   m_Controls->choose_tracking_device_label->setEnabled(true);
   m_Controls->configuration_finished_label->setText("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\np, li { white-space: pre-wrap; }\n</style></head><body style=\" font-family:\'MS Shell Dlg 2\'; font-size:8.25pt; font-weight:400; font-style:normal;\">\n<p align=\"right\" style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-size:8pt;\"><span style=\" font-weight:600;\">Press \"Finished\" to confirm configuration</span></p></body></html>");
   this->m_TrackingDeviceConfigurated = false;
   emit TrackingDeviceConfigurationReseted();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::ResetByUser()
   {
   Reset();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::AutoScanPorts()
   {
   this->setEnabled(false);
   AddOutput("<br>Scanning...");
   m_ScanPortsWorkerThread->start();
   emit ProgressStarted();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::AutoScanPortsFinished(int PolarisPort, int AuroraPort, QString result, int PortTypePolaris, int PortTypeAurora)
   {
   m_ScanPortsWorkerThread->quit();
   #ifdef WIN32
     if((PortTypePolaris!=-1)||(PortTypeAurora!=-1)) {MITK_WARN << "Port type is specified although this should not be the case for Windows. Ignoring port type.";}
   #else //linux systems
     if (PortTypePolaris!=-1) {m_Controls->portTypePolaris->setCurrentIndex(PortTypePolaris);}
     if (PortTypeAurora!=-1)  {m_Controls->portTypeAurora->setCurrentIndex(PortTypeAurora);}
   #endif
   m_Controls->m_portSpinBoxPolaris->setValue(PolarisPort);
   m_Controls->m_portSpinBoxAurora->setValue(AuroraPort);
   AddOutput(result.toStdString());
   this->setEnabled(true);
   emit ProgressFinished();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::SetMTCalibrationFileClicked()
   {
   std::string filename = QFileDialog::getOpenFileName(NULL,tr("Open Calibration File"), "/", "*.*").toAscii().data();
   if (filename=="") {return;}
   else
     {
     m_MTCalibrationFile = filename;
     Poco::Path myPath = Poco::Path(m_MTCalibrationFile.c_str());
     m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
     }
   }
 
 void QmitkTrackingDeviceConfigurationWidget::SetOptitrackCalibrationFileClicked()
   {
   std::string filename = QFileDialog::getOpenFileName(NULL,tr("Open Calibration File"), "/", "*.*").toAscii().data();
   if (filename=="") {return;}
   else
     {
     m_OptitrackCalibrationFile = filename;
     Poco::Path myPath = Poco::Path(m_OptitrackCalibrationFile.c_str());
     m_Controls->m_OptitrackCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
     }
   }
 //######################### internal help methods #######################################
 void QmitkTrackingDeviceConfigurationWidget::ResetOutput()
   {
   m_output.str("");
   m_output <<"<body style=\" font-family:\'MS Shell Dlg 2\'; font-size:7pt; font-weight:400; font-style:normal;\" bgcolor=black><span style=\"color:#ffffff;\"><u>output:</u>";
   m_Controls->m_outputTextAurora->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextPolaris->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextMicronTracker->setHtml(QString(m_output.str().c_str()));
   }
 void QmitkTrackingDeviceConfigurationWidget::AddOutput(std::string s)
   {
   //print output
   m_output << s;
   m_Controls->m_outputTextAurora->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextPolaris->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextMicronTracker->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextOptitrack->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextPolaris->verticalScrollBar()->setValue(m_Controls->m_outputTextPolaris->verticalScrollBar()->maximum());
   m_Controls->m_outputTextAurora->verticalScrollBar()->setValue(m_Controls->m_outputTextAurora->verticalScrollBar()->maximum());
   m_Controls->m_outputTextMicronTracker->verticalScrollBar()->setValue(m_Controls->m_outputTextMicronTracker->verticalScrollBar()->maximum());
   m_Controls->m_outputTextOptitrack->verticalScrollBar()->setValue(m_Controls->m_outputTextOptitrack->verticalScrollBar()->maximum());
   repaint();
   }
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConstructTrackingDevice()
   {
   mitk::TrackingDevice::Pointer returnValue;
   //#### Step 1: configure tracking device:
   if (m_Controls->m_trackingDeviceChooser->currentIndex()==0)//NDI Polaris
       {
       if(m_Controls->m_radioPolaris5D->isChecked()) //5D Tracking
         {
         //not yet in the open source part so we'll only get NULL here.
         returnValue = ConfigureNDI5DTrackingDevice();
         }
       else //6D Tracking
         {
         returnValue = ConfigureNDI6DTrackingDevice();
         returnValue->SetType(mitk::NDIPolaris);
         }
       }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==1)//NDI Aurora
         {
         returnValue = ConfigureNDI6DTrackingDevice();
         returnValue->SetType(mitk::NDIAurora);
         }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==2)//ClaronTechnology MicronTracker 2
         {
 
         mitk::ClaronTrackingDevice::Pointer newDevice = mitk::ClaronTrackingDevice::New();
         if(this->m_MTCalibrationFile=="") AddOutput("<br>Warning: Calibration file is not set!");
         else
           {
           //extract path from calibration file and set the calibration dir of the device
           std::string path =  itksys::SystemTools::GetFilenamePath(m_MTCalibrationFile);
           newDevice->SetCalibrationDir(path);
           }
         returnValue = newDevice;
         }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==3)
   {
     // Create the Tracking Device this->m_OptitrackDevice = mitk::OptitrackTrackingDevice::New();
     returnValue = ConfigureOptitrackTrackingDevice();
     returnValue->SetType(mitk::NPOptitrack);
   }
   return returnValue;
   }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConfigureNDI5DTrackingDevice()
   {
   return NULL;
   }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConfigureOptitrackTrackingDevice()
   {
   mitk::OptitrackTrackingDevice::Pointer tempTrackingDevice = mitk::OptitrackTrackingDevice::New();
   // Set the calibration File
   tempTrackingDevice->SetCalibrationPath(m_OptitrackCalibrationFile);
 
   //Set the camera parameters
   tempTrackingDevice->SetExp(m_Controls->m_OptitrackExp->value());
   tempTrackingDevice->SetLed(m_Controls->m_OptitrackLed->value());
   tempTrackingDevice->SetThr(m_Controls->m_OptitrackThr->value());
 
   mitk::TrackingDevice::Pointer returnValue = static_cast<mitk::TrackingDevice*>(tempTrackingDevice);
   return returnValue;
   }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConfigureNDI6DTrackingDevice()
   {
   mitk::NDITrackingDevice::Pointer tempTrackingDevice = mitk::NDITrackingDevice::New();
 
   //get port
   int port = 0;
   if (m_Controls->m_trackingDeviceChooser->currentIndex()==1) port = m_Controls->m_portSpinBoxAurora->value();
   else port = m_Controls->m_portSpinBoxPolaris->value();
 
   //build prefix (depends on linux/win)
   QString prefix = "";
   #ifdef WIN32
   prefix ="COM";
   tempTrackingDevice->SetPortNumber(static_cast<mitk::SerialCommunication::PortNumber>(port)); //also set the com port for compatibility
   #else
   if (m_Controls->m_trackingDeviceChooser->currentIndex()==1) //Aurora
     prefix = m_Controls->portTypeAurora->currentText();
   else //Polaris
     prefix = m_Controls->portTypePolaris->currentText();
   #endif
 
   //build port name string
   QString portName = prefix + QString::number(port);
 
   tempTrackingDevice->SetDeviceName(portName.toStdString()); //set the port name
   tempTrackingDevice->SetBaudRate(mitk::SerialCommunication::BaudRate115200);//set baud rate
   mitk::TrackingDevice::Pointer returnValue = static_cast<mitk::TrackingDevice*>(tempTrackingDevice);
   return returnValue;
   }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::GetTrackingDevice()
   {
   if (!m_AdvancedUserControl) m_TrackingDevice = ConstructTrackingDevice();
   if (m_TrackingDevice.IsNull() || !m_TrackingDevice->IsDeviceInstalled()) return NULL;
   else return this->m_TrackingDevice;
   }
 
 bool QmitkTrackingDeviceConfigurationWidget::GetTrackingDeviceConfigured()
   {
   return this->m_TrackingDeviceConfigurated;
   }
 
 void QmitkTrackingDeviceConfigurationWidget::ConfigurationFinished()
   {
   Finished();
 
   }
 
 void QmitkTrackingDeviceConfigurationWidget::EnableAdvancedUserControl(bool enable)
   {
   m_AdvancedUserControl = enable;
   m_Controls->configuration_finished_label->setVisible(enable);
   m_Controls->m_finishedLine->setVisible(enable);
   m_Controls->m_resetButton->setVisible(enable);
   m_Controls->m_finishedButton->setVisible(enable);
   }
 
 
 void QmitkTrackingDeviceConfigurationWidget::StoreUISettings()
 {
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
   if ( this->GetPeristenceService() )
   {
     mitk::PropertyList::Pointer propList = this->GetPeristenceService()->GetPropertyList(id);
     propList->Set("PolarisPortWin",m_Controls->m_portSpinBoxPolaris->value());
     propList->Set("AuroraPortWin",m_Controls->m_portSpinBoxAurora->value());
     propList->Set("PortTypePolaris", m_Controls->portTypePolaris->currentIndex());
     propList->Set("PortTypeAurora", m_Controls->portTypeAurora->currentIndex());
     propList->Set("MTCalibrationFile",m_MTCalibrationFile);
     propList->Set("SelectedDevice",m_Controls->m_trackingDeviceChooser->currentIndex());
   }
   else
   {
     // QSettings as a fallback if the persistence service is not available
     QSettings settings;
 
     settings.beginGroup(QString::fromStdString(id));
 
     settings.setValue("trackingDeviceChooser", QVariant(m_Controls->m_trackingDeviceChooser->currentIndex()));
     settings.setValue("portSpinBoxAurora", QVariant(m_Controls->m_portSpinBoxAurora->value()));
     settings.setValue("portSpinBoxPolaris", QVariant(m_Controls->m_portSpinBoxPolaris->value()));
     settings.setValue("portTypePolaris", QVariant(m_Controls->portTypePolaris->currentIndex()));
     settings.setValue("portTypeAurora", QVariant(m_Controls->portTypeAurora->currentIndex()));
     settings.setValue("mTCalibrationFile", QVariant(QString::fromStdString(m_MTCalibrationFile)));
 
     settings.endGroup();
   }
 }
 
 void QmitkTrackingDeviceConfigurationWidget::LoadUISettings()
 {
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
   if ( this->GetPeristenceService() )
   {
     mitk::PropertyList::Pointer propList = this->GetPeristenceService()->GetPropertyList(id);
     if (propList.IsNull())
     {MITK_ERROR << "Property list for this UI (" << id <<") is not available, could not load UI settings!"; return;}
-    int portPolarisWin,portAuroraWin,portTypePolaris,portTypeAurora,SelectedDevice;
+    int portPolarisWin=0,portAuroraWin=0,portTypePolaris=0,portTypeAurora=0,SelectedDevice=-1;
     propList->Get("PolarisPortWin",portPolarisWin);
     propList->Get("AuroraPortWin",portAuroraWin);
     propList->Get("PortTypePolaris", portTypePolaris);
     propList->Get("PortTypeAurora", portTypeAurora);
     propList->Get("MTCalibrationFile",m_MTCalibrationFile);
     propList->Get("SelectedDevice",SelectedDevice);
     if (SelectedDevice<0)
     {
       MITK_ERROR << "Loaded data from persistence service is invalid (SelectedDevice:" <<SelectedDevice<<"): aborted to restore data!";
       return;
     }
     m_Controls->m_portSpinBoxPolaris->setValue(portPolarisWin);
     m_Controls->m_portSpinBoxAurora->setValue(portAuroraWin);
     m_Controls->portTypePolaris->setCurrentIndex(portTypePolaris);
     m_Controls->portTypeAurora->setCurrentIndex(portTypeAurora);
     m_Controls->m_TrackingSystemWidget->setCurrentIndex(SelectedDevice);
     m_Controls->m_trackingDeviceChooser->setCurrentIndex(SelectedDevice);
     MITK_INFO << "Sucessfully restored UI settings";
   }
   else
   {
     // QSettings as a fallback if the persistence service is not available
     QSettings settings;
 
     settings.beginGroup(QString::fromStdString(id));
 
     m_Controls->m_trackingDeviceChooser->setCurrentIndex(settings.value("trackingDeviceChooser", 0).toInt());
     m_Controls->m_portSpinBoxAurora->setValue(settings.value("portSpinBoxAurora", 0).toInt());
     m_Controls->m_portSpinBoxPolaris->setValue(settings.value("portSpinBoxPolaris", 0).toInt());
     m_Controls->portTypePolaris->setCurrentIndex(settings.value("portTypePolaris", 0).toInt());
     m_Controls->portTypeAurora->setCurrentIndex(settings.value("portTypeAurora", 0).toInt());
     m_MTCalibrationFile = settings.value("mTCalibrationFile", "").toString().toStdString();
 
     settings.endGroup();
   }
 
   m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString::fromStdString(m_MTCalibrationFile));
 }
 
 void QmitkTrackingDeviceConfigurationWidgetConnectionWorker::TestConnectionThreadFunc()
 {
 MITK_INFO << "Testing Connection!";
 QString output;
 bool connected = false;
 mitk::ProgressBar::GetInstance()->AddStepsToDo(4);
 try
   {
   if (!m_TrackingDevice->IsDeviceInstalled())
      {
      output = "ERROR: Device is not installed!";
      }
   else
     {
     //test connection and start tracking, generate output
     output = "<br>testing connection <br>  ...";
     m_TrackingDevice->OpenConnection();
     output += "OK";
     mitk::ProgressBar::GetInstance()->Progress();
 
     //try start/stop tracking
     output += "<br>testing tracking <br>  ...";
     m_TrackingDevice->StartTracking();
     mitk::ProgressBar::GetInstance()->Progress();
     m_TrackingDevice->StopTracking();
     mitk::ProgressBar::GetInstance()->Progress();
 
     //try close connection
     m_TrackingDevice->CloseConnection();
     mitk::ProgressBar::GetInstance()->Progress();
     output += "OK";
     connected = true;
     }
   }
 catch(mitk::IGTException &e)
   {
   output += "ERROR!";
   MITK_WARN << "Error while testing connection / start tracking of the device: " << e.GetDescription();
   }
 mitk::ProgressBar::GetInstance()->Progress(4);
 emit ConnectionTested(connected,output);
 }
 
 void QmitkTrackingDeviceConfigurationWidgetScanPortsWorker::ScanPortsThreadFunc()
 {
   int PolarisPort = -1;
   int AuroraPort = -1;
   int PortTypePolaris = -1;
   int PortTypeAurora = -1;
 
   QString result = "<br>Found Devices:";
   int resultSize = result.size(); //remember size of result: if it stays the same no device were found
 
   #ifdef WIN32
     mitk::ProgressBar::GetInstance()->AddStepsToDo(19);
 
     QString devName;
     for (unsigned int i = 1; i < 20; ++i)
     {
       QString statusOutput = "Scanning Port #" + QString::number(i);
       MITK_INFO << statusOutput.toStdString().c_str();
       if (i<10) devName = QString("COM%1").arg(i);
       else devName = QString("\\\\.\\COM%1").arg(i); // prepend "\\.\ to COM ports >9, to be able to allow connection"
       mitk::TrackingDeviceType scannedPort = ScanPort(devName);
       switch (scannedPort)
       {
       case mitk::NDIPolaris:
         result += "<br>" + devName + ": " + "NDI Polaris";
         PolarisPort = i;
         break;
       case mitk::NDIAurora:
         result += "<br>" + devName + ": " + "NDI Aurora";
         AuroraPort = i;
         break;
       }
       mitk::ProgressBar::GetInstance()->Progress();
     }
   #else //linux systems
     for(unsigned int i = 1; i < 6; ++i)
     {
       QString devName = QString("/dev/ttyS%1").arg(i);
       mitk::TrackingDeviceType scannedPort = ScanPort(devName);
       switch (scannedPort)
       {
       case mitk::NDIPolaris:
         result += "<br>" + devName + ": " + "NDI Polaris";
         PolarisPort = i;
         PortTypePolaris = 1;
         break;
       case mitk::NDIAurora:
         result += "<br>" + devName + ": " + "NDI Aurora";
         AuroraPort = i;
         PortTypeAurora = 1;
         break;
       }
 
     }
     for(unsigned int i = 0; i <7; ++i)
     {
       QString devName = QString("/dev/ttyUSB%1").arg(i);
       mitk::TrackingDeviceType scannedPort = ScanPort(devName);
       switch (scannedPort)
       {
       case mitk::NDIPolaris:
         result += "<br>" + devName + ": " + "NDI Polaris";
         PolarisPort = i;
         PortTypePolaris = 0;
         break;
       case mitk::NDIAurora:
         result += "<br>" + devName + ": " + "NDI Aurora";
         AuroraPort = i;
         PortTypeAurora = 0;
         break;
       }
 
     }
   #endif
 
   if ( result.size() == resultSize) result += "<br>none";
 
   emit PortsScanned(PolarisPort,AuroraPort,result,PortTypePolaris,PortTypeAurora);
 }
 
 mitk::TrackingDeviceType QmitkTrackingDeviceConfigurationWidgetScanPortsWorker::ScanPort(QString port)
 {
   mitk::NDITrackingDevice::Pointer tracker = mitk::NDITrackingDevice::New();
   tracker->SetDeviceName(port.toStdString());
   mitk::TrackingDeviceType returnValue = mitk::TrackingSystemInvalid;
   try
   {returnValue = tracker->TestConnection();}
   catch (mitk::IGTException)
   {}//do nothing: there is simply no device on this port
   return returnValue;
 }
 
 void QmitkTrackingDeviceConfigurationWidgetConnectionWorker::SetTrackingDevice(mitk::TrackingDevice::Pointer t)
 {
   m_TrackingDevice = t;
 }
diff --git a/Modules/Persistence/CMakeLists.txt b/Modules/Persistence/CMakeLists.txt
index 29e8584e0b..4d27809564 100644
--- a/Modules/Persistence/CMakeLists.txt
+++ b/Modules/Persistence/CMakeLists.txt
@@ -1,4 +1,5 @@
 MITK_CREATE_MODULE(
   DEPENDS MitkSceneSerialization
+  AUTOLOAD_WITH MitkCore
 )
 add_subdirectory(Testing)
diff --git a/Modules/Persistence/Testing/mitkPersistenceTest.cpp b/Modules/Persistence/Testing/mitkPersistenceTest.cpp
index a251410ad1..65c023e280 100644
--- a/Modules/Persistence/Testing/mitkPersistenceTest.cpp
+++ b/Modules/Persistence/Testing/mitkPersistenceTest.cpp
@@ -1,169 +1,169 @@
 /*===================================================================
 
 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 <mitkCommon.h>
 #include <usModuleContext.h>
 #include <usServiceReference.h>
 #include <usGetModuleContext.h>
 #include <mitkTestingMacros.h>
 #include <mitkIPersistenceService.h>
 #include <mitkPersistenceService.h>
 #include <mitkSceneIO.h>
 #include <Poco/File.h>
 
 struct PersistenceTestClass
 {
     PersistenceTestClass()
         : id(""), param1(1), param2(2), param3(false)
     {
     }
     std::string id;
     int param1;
     double param2;
     bool param3;
 
     PERSISTENCE_CREATE3(PersistenceTestClass, id, param1, param2, param3)
 };
 
 struct TestPropertyListReplacedObserver: public mitk::PropertyListReplacedObserver
 {
     TestPropertyListReplacedObserver(): counter(0) {}
     virtual void BeforePropertyListReplaced( const std::string& id, mitk::PropertyList* propertyList )
     {
         if( id == m_Id )
             counter++;
     }
 
     virtual void AfterPropertyListReplaced( const std::string& id, mitk::PropertyList* propertyList )
     {
         if( id == m_Id )
             counter++;
     }
 
     int counter;
     std::string m_Id;
 };
 
 std::string testClassId = "testClass";
 int param1 = 100;
 double param2 = 201.56;
 bool param3 = true;
 
 void testParams( const PersistenceTestClass& testClass, const std::string& testClassName )
 {
     MITK_INFO << "Testing parameters of " << testClassName;
     MITK_TEST_CONDITION( testClass.id == testClassId, "testClass.id (" << testClass.id << ") != testClassId (" << testClassId << ")" );
     MITK_TEST_CONDITION( testClass.param1 == param1, "testClass.param1 (" << testClass.param1 << ") != param1 (" << param1 << ")" );
     MITK_TEST_CONDITION( testClass.param2 == param2, "testClass.param2 (" << testClass.param2 << ") != param2 (" << param2 << ")" );
     MITK_TEST_CONDITION( testClass.param3 == param3, "testClass.param3 (" << testClass.param3 << ") != param3 (" << param3 << ")" );
 }
 
 int mitkPersistenceTest(int /*argc*/, char* /*argv*/[])
 {
     MITK_TEST_BEGIN("PersistenceTest")
     // dummy load of SceneIO, otherwise PersistenceService won't be available
-    mitk::PersistenceService::LoadModule();
+    //mitk::PersistenceService::LoadModule();
 
     MITK_INFO << "Testing availability of the PersistenceService.";
     PERSISTENCE_GET_SERVICE_MACRO
     MITK_TEST_CONDITION_REQUIRED(persistenceService, "IPersistenceService available")
 
     MITK_INFO << "Initialize testable parameter values.";
 
     Poco::File defaultPersistenceFile(persistenceService->GetDefaultPersistenceFile());
     PersistenceTestClass autoLoadTestClass;
     autoLoadTestClass.id = testClassId;
     if( defaultPersistenceFile.exists() && persistenceService->GetAutoLoadAndSave() )
     {
         MITK_INFO << "Testing auto load/save of the PersistenceService.";
         defaultPersistenceFile.remove();
         autoLoadTestClass.FromPropertyList();
 
         testParams( autoLoadTestClass, "autoLoadTestClass" );
     }
 
     MITK_INFO << "Removing left-over test files.";
     Poco::File testTempFile("PersistenceTestFile.mitk");
     if( testTempFile.exists() )
         testTempFile.remove(false);
 
     Poco::File testXmlTempFile("PersistenceTestFile.xml");
     if( testXmlTempFile.exists() )
         testXmlTempFile.remove(false);
 
     MITK_INFO << "Testing standard write to scene file/xml file.";
     PersistenceTestClass testClass;
     testClass.id = testClassId;
     testClass.param1 = param1;
     testClass.param2 = param2;
     testClass.param3 = param3;
     MITK_TEST_CONDITION_REQUIRED( testClass.Save(testTempFile.path()), "testClass.Save(testTempFile.path())");
     MITK_TEST_CONDITION_REQUIRED( testClass.Save(testXmlTempFile.path()), "testClass.Save(testTempFile.path())");
 
     MITK_INFO << "Testing read from scene file.";
     MITK_TEST_CONDITION_REQUIRED( persistenceService->RemovePropertyList(testClassId), "persistenceService->RemovePropertyList(testClassId)");
     PersistenceTestClass testClass2;
     testClass2.id = testClassId;
     MITK_TEST_CONDITION_REQUIRED( testClass2.Load(testTempFile.path()), "testClass2.Load(testTempFile.path())");
 
     testParams( testClass2, "testClass2" );
 
     MITK_INFO << "Testing read from xml file.";
     MITK_TEST_CONDITION_REQUIRED( persistenceService->RemovePropertyList(testClassId), "persistenceService->RemovePropertyList(testClassId)");
     PersistenceTestClass testClass3;
     testClass3.id = testClassId;
     MITK_TEST_CONDITION_REQUIRED( testClass3.Load(testXmlTempFile.path()), "testClass3.Load(testXmlTempFile.path())");
 
     testParams( testClass3, "testClass3" );
 
     MITK_INFO << "Testing appendChanges functionality with scene load/write.";
     MITK_TEST_CONDITION_REQUIRED( persistenceService->RemovePropertyList(testClassId), "persistenceService->RemovePropertyList(testClassId)");
     MITK_TEST_CONDITION_REQUIRED( persistenceService->Save(testTempFile.path(), true), "persistenceService->Save(testTempFile.path())");
     MITK_TEST_CONDITION_REQUIRED( persistenceService->Load(testTempFile.path()), "persistenceService->Load(testTempFile.path())");
 
     PersistenceTestClass testClass4;
     testClass4.id = testClassId;
     testClass4.FromPropertyList();
     testParams( testClass4, "testClass4" );
 
     MITK_INFO << "Testing appendChanges functionality with xml load/write.";
     MITK_TEST_CONDITION_REQUIRED( persistenceService->RemovePropertyList(testClassId), "persistenceService->RemovePropertyList(testClassId)");
     MITK_TEST_CONDITION_REQUIRED( persistenceService->Save(testXmlTempFile.path(), true), "persistenceService->Save(testXmlTempFile.path())");
     MITK_TEST_CONDITION_REQUIRED( persistenceService->Load(testXmlTempFile.path()), "persistenceService->Load(testXmlTempFile.path())");
 
     PersistenceTestClass testClass5;
     testClass5.id = testClassId;
     testClass5.FromPropertyList();
     testParams( testClass5, "testClass5" );
 
     MITK_INFO << "Testing observer functionality.";
     TestPropertyListReplacedObserver testObserver;
     testObserver.m_Id = testClassId;
     persistenceService->AddPropertyListReplacedObserver( &testObserver );
     persistenceService->Load(testTempFile.path());
     MITK_TEST_CONDITION( testObserver.counter == 2, "testObserver.counter == 2, testObserver.counter is " << testObserver.counter );
 
     MITK_INFO << "Cleaning test files.";
     if( testXmlTempFile.exists() )
         testXmlTempFile.remove(false);
     if( testTempFile.exists() )
         testTempFile.remove(false);
 
     autoLoadTestClass.param1 = param1;
     autoLoadTestClass.param2 = param2;
     autoLoadTestClass.param3 = param3;
     autoLoadTestClass.ToPropertyList();
     MITK_TEST_END()
 }
diff --git a/Modules/Persistence/mitkPersistenceService.cpp b/Modules/Persistence/mitkPersistenceService.cpp
index d86e7c32bf..0b16b5b523 100644
--- a/Modules/Persistence/mitkPersistenceService.cpp
+++ b/Modules/Persistence/mitkPersistenceService.cpp
@@ -1,401 +1,429 @@
 /*===================================================================
 
 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 "mitkPersistenceService.h"
 #include "mitkStandaloneDataStorage.h"
 #include "mitkUIDGenerator.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkProperties.h"
 #include "usModuleContext.h"
 #include "usGetModuleContext.h"
 #include <itksys/SystemTools.hxx>
 
-//not used at the moment because of bug 17729 (using the strings directly instead until the bug is fixed)
-const std::string mitk::PersistenceService::PERSISTENCE_PROPERTY_NAME("PersistenceNode");
-const std::string mitk::PersistenceService::PERSISTENCE_PROPERTYLIST_NAME("PersistenceService");
+std::string mitk::PersistenceService::GetPersistencePropertyName()
+{
+  return "PersistenceNode";
+}
 
+std::string mitk::PersistenceService::GetPersistencePropertyListName()
+{
+  return "PersistenceService";
+}
 
 mitk::PersistenceService::PersistenceService()
 : m_AutoLoadAndSave( true ), m_Initialized(false), m_InInitialized(false)
 {
 }
 
 void mitk::PersistenceService::Clear()
 {
   this->Initialize();
   m_PropertyLists.clear();
   m_FileNamesToModifiedTimes.clear();
 }
 
 mitk::PersistenceService::~PersistenceService()
 {
   MITK_DEBUG("mitk::PersistenceService") << "destructing PersistenceService";
 }
 
 std::string mitk::PersistenceService::GetDefaultPersistenceFile()
 {
   this->Initialize();
-  std::string file = "PersistentData.mitk";
+  std::string file = "PersistentData.xml";
   us::ModuleContext* context = us::GetModuleContext();
-  std::string contextDataFile = context->GetDataFile("PersistentData.mitk");
-  itksys::SystemTools::MakeDirectory(context->GetDataFile("").c_str());
+  std::string contextDataFile = context->GetDataFile(file);
 
   if( !contextDataFile.empty() )
   {
       file = contextDataFile;
   }
   return file;
 }
 
 mitk::PropertyList::Pointer mitk::PersistenceService::GetPropertyList( std::string& id, bool* existed )
 {
   this->Initialize();
   mitk::PropertyList::Pointer propList;
 
   if( id.empty() )
   {
       UIDGenerator uidGen;
       id = uidGen.GetUID();
   }
 
   std::map<std::string, mitk::PropertyList::Pointer>::iterator it = m_PropertyLists.find( id );
   if( it == m_PropertyLists.end() )
   {
       propList = PropertyList::New();
       m_PropertyLists[id] = propList;
       if( existed )
           *existed = false;
   }
   else
   {
       propList = (*it).second;
       if( existed )
           *existed = true;
   }
 
   return propList;
 }
 
 void mitk::PersistenceService::ClonePropertyList( mitk::PropertyList* from, mitk::PropertyList* to ) const
 {
   to->Clear();
 
   const std::map< std::string, BaseProperty::Pointer>* propMap = from->GetMap();
   std::map< std::string, BaseProperty::Pointer>::const_iterator propMapIt = propMap->begin();
   while( propMapIt != propMap->end() )
   {
       mitk::BaseProperty::Pointer clonedProp = (*propMapIt).second->Clone();
       to->SetProperty( (*propMapIt).first, clonedProp );
       ++propMapIt;
   }
 }
 
 bool mitk::PersistenceService::Save(const std::string& fileName, bool appendChanges)
 {
   this->Initialize();
   bool save = false;
   std::string theFile = fileName;
   if(theFile.empty())
       theFile = PersistenceService::GetDefaultPersistenceFile();
 
+  std::string thePath = itksys::SystemTools::GetFilenamePath( theFile.c_str() );
+  if( !thePath.empty() && !itksys::SystemTools::FileExists( thePath.c_str() ) )
+  {
+    if( !itksys::SystemTools::MakeDirectory( thePath.c_str() ) )
+    {
+      MITK_ERROR("PersistenceService") << "Could not create " << thePath;
+      return false;
+    }
+  }
+
+  bool createFile = !itksys::SystemTools::FileExists(theFile.c_str());
+  if( !itksys::SystemTools::Touch(theFile.c_str(), createFile) )
+  {
+    MITK_ERROR("PersistenceService") << "Could not create or write to " << theFile;
+    return false;
+  }
+
   bool xmlFile = false;
   if( itksys::SystemTools::GetFilenameLastExtension(theFile.c_str()) == ".xml" )
       xmlFile = true;
 
   mitk::DataStorage::Pointer tempDs;
   if( appendChanges )
   {
       if(xmlFile == false)
       {
           if( itksys::SystemTools::FileExists(theFile.c_str()) )
           {
 
               bool load = false;
               DataStorage::Pointer ds = m_SceneIO->LoadScene( theFile );
               load = (m_SceneIO->GetFailedNodes() == 0 || m_SceneIO->GetFailedNodes()->size() == 0) && (m_SceneIO->GetFailedNodes() == 0 || m_SceneIO->GetFailedProperties()->IsEmpty());
               if( !load )
                   return false;
 
               tempDs = ds;
 
           }
       }
       else
       {
           tempDs = mitk::StandaloneDataStorage::New();
           if( xmlFile && appendChanges && itksys::SystemTools::FileExists(theFile.c_str()) )
           {
               if( !m_PropertyListsXmlFileReaderAndWriter->ReadLists( theFile, m_PropertyLists ) )
                   return false;
           }
       }
 
       this->RestorePropertyListsFromPersistentDataNodes( tempDs );
   }
   else if( xmlFile == false )
   {
       tempDs = mitk::StandaloneDataStorage::New();
   }
 
   if( xmlFile )
   {
       save = m_PropertyListsXmlFileReaderAndWriter->WriteLists(theFile, m_PropertyLists);
   }
 
   else
   {
       DataStorage::SetOfObjects::Pointer sceneNodes = this->GetDataNodes(tempDs);
+      if(m_SceneIO.IsNull())
+      {
+        m_SceneIO = mitk::SceneIO::New();
+      }
       save = m_SceneIO->SaveScene( sceneNodes.GetPointer(), tempDs, theFile );
   }
   if( save )
   {
       long int currentModifiedTime = itksys::SystemTools::ModifiedTime( theFile.c_str() );
       m_FileNamesToModifiedTimes[theFile] = currentModifiedTime;
   }
 
   return save;
 }
 
 bool mitk::PersistenceService::Load(const std::string& fileName, bool enforceReload)
 {
   this->Initialize();
   bool load = false;
 
   std::string theFile = fileName;
   if(theFile.empty())
       theFile = PersistenceService::GetDefaultPersistenceFile();
 
   MITK_INFO << "Load persistence data from file: " << theFile;
 
   if( !itksys::SystemTools::FileExists(theFile.c_str()) )
       return false;
 
   bool xmlFile = false;
   if( itksys::SystemTools::GetFilenameLastExtension(theFile.c_str()) == ".xml" )
       xmlFile = true;
 
   if( enforceReload == false )
   {
       bool loadTheFile = true;
       std::map<std::string, long int>::iterator it = m_FileNamesToModifiedTimes.find( theFile );
 
       long int currentModifiedTime = itksys::SystemTools::ModifiedTime( theFile.c_str() );
       if( it != m_FileNamesToModifiedTimes.end() )
       {
           long int knownModifiedTime = (*it).second;
           if( knownModifiedTime >= currentModifiedTime )
           {
               loadTheFile = false;
           }
       }
       if( loadTheFile )
           m_FileNamesToModifiedTimes[theFile] = currentModifiedTime;
       else
           return true;
   }
 
   if( xmlFile )
   {
       load = m_PropertyListsXmlFileReaderAndWriter->ReadLists(theFile, m_PropertyLists);
   }
   else
   {
+    if(m_SceneIO.IsNull())
+    {
+      m_SceneIO = mitk::SceneIO::New();
+    }
       DataStorage::Pointer ds = m_SceneIO->LoadScene( theFile );
       load = (m_SceneIO->GetFailedNodes() == 0 || m_SceneIO->GetFailedNodes()->size() == 0) && (m_SceneIO->GetFailedNodes() == 0 || m_SceneIO->GetFailedProperties()->IsEmpty());
       if( load )
       {
           this->RestorePropertyListsFromPersistentDataNodes( ds );
       }
   }
   if( !load )
   {
       MITK_DEBUG("mitk::PersistenceService") << "loading of scene files failed";
       return load;
   }
 
   return load;
 }
 
 void mitk::PersistenceService::SetAutoLoadAndSave(bool autoLoadAndSave)
 {
   this->Initialize();
   m_AutoLoadAndSave = autoLoadAndSave;
   //std::string id = PERSISTENCE_PROPERTYLIST_NAME; //see bug 17729
-  std::string id = "PersistenceService";
+  std::string id = GetPersistencePropertyListName();
   mitk::PropertyList::Pointer propList = this->GetPropertyList( id );
   propList->Set("m_AutoLoadAndSave", m_AutoLoadAndSave);
   this->Save();
 }
 
 void mitk::PersistenceService::AddPropertyListReplacedObserver(PropertyListReplacedObserver* observer)
 {
   this->Initialize();
   m_PropertyListReplacedObserver.insert( observer );
 }
 
 void mitk::PersistenceService::RemovePropertyListReplacedObserver(PropertyListReplacedObserver* observer)
 {
   this->Initialize();
   m_PropertyListReplacedObserver.erase( observer );
 }
 
 void mitk::PersistenceService::LoadModule()
 {
     MITK_INFO << "Persistence Module loaded.";
 }
 
 us::ModuleContext* mitk::PersistenceService::GetModuleContext()
 {
   return us::GetModuleContext();
 }
 
 std::string mitk::PersistenceService::GetPersistenceNodePropertyName()
 {
   this->Initialize();
   //return PERSISTENCE_PROPERTY_NAME; //see bug 17729
-  return "PersistenceNode";
+  return GetPersistencePropertyName();
 }
 mitk::DataStorage::SetOfObjects::Pointer mitk::PersistenceService::GetDataNodes(mitk::DataStorage* ds)
 {
   this->Initialize();
   DataStorage::SetOfObjects::Pointer set = DataStorage::SetOfObjects::New();
 
   std::map<std::string, mitk::PropertyList::Pointer>::const_iterator it = m_PropertyLists.begin();
   while( it != m_PropertyLists.end() )
   {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       const std::string& name = (*it).first;
 
       this->ClonePropertyList( (*it).second, node->GetPropertyList() );
 
 
       node->SetName( name );
-      MITK_DEBUG << "Persistence Property Name: " <<PERSISTENCE_PROPERTY_NAME.c_str();
+      MITK_DEBUG << "Persistence Property Name: " << GetPersistencePropertyName().c_str();
       //node->SetBoolProperty( PERSISTENCE_PROPERTY_NAME.c_str() , true ); //see bug 17729
-      node->SetBoolProperty( "PersistenceNode" , true );
+      node->SetBoolProperty( GetPersistencePropertyName().c_str() , true );
 
       ds->Add(node);
       set->push_back( node );
       ++it;
   }
 
   return set;
 }
 
 bool mitk::PersistenceService::RestorePropertyListsFromPersistentDataNodes( const DataStorage* storage )
 {
   this->Initialize();
   bool oneFound = false;
   DataStorage::SetOfObjects::ConstPointer allNodes = storage->GetAll();
   for ( mitk::DataStorage::SetOfObjects::const_iterator sourceIter = allNodes->begin();
       sourceIter != allNodes->end();
       ++sourceIter )
   {
       mitk::DataNode* node = *sourceIter;
       bool isPersistenceNode = false;
       //node->GetBoolProperty( PERSISTENCE_PROPERTY_NAME.c_str(), isPersistenceNode ); //see bug 17729
-      node->GetBoolProperty( "PersistenceNode", isPersistenceNode );
+      node->GetBoolProperty( GetPersistencePropertyName().c_str(), isPersistenceNode );
 
       if( isPersistenceNode )
       {
           oneFound = true;
           MITK_DEBUG("mitk::PersistenceService") << "isPersistenceNode was true";
           std::string name = node->GetName();
 
           bool existed = false;
           mitk::PropertyList::Pointer propList = this->GetPropertyList( name, &existed );
 
           if( existed )
           {
               MITK_DEBUG("mitk::PersistenceService") << "calling replace observer before replacing values";
               std::set<PropertyListReplacedObserver*>::iterator it = m_PropertyListReplacedObserver.begin();
               while( it != m_PropertyListReplacedObserver.end() )
               {
                   (*it)->BeforePropertyListReplaced( name, propList );
                   ++it;
               }
           } // if( existed )
 
           MITK_DEBUG("mitk::PersistenceService") << "replacing values";
 
           this->ClonePropertyList(  node->GetPropertyList(), propList );
 
           if( existed )
           {
               MITK_DEBUG("mitk::PersistenceService") << "calling replace observer before replacing values";
               std::set<PropertyListReplacedObserver*>::iterator it = m_PropertyListReplacedObserver.begin();
               while( it != m_PropertyListReplacedObserver.end() )
               {
                   (*it)->AfterPropertyListReplaced( name, propList );
                   ++it;
               }
           } // if( existed )
       } // if( isPersistenceNode )
   } // for ( mitk::DataStorage::SetOfObjects::const_iterator sourceIter = allNodes->begin(); ...
 
   return oneFound;
 }
 
 bool mitk::PersistenceService::GetAutoLoadAndSave()
 {
   this->Initialize();
   return m_AutoLoadAndSave;
 }
 
 bool mitk::PersistenceService::RemovePropertyList( std::string& id )
 {
   this->Initialize();
   std::map<std::string, mitk::PropertyList::Pointer>::iterator it = m_PropertyLists.find( id );
   if( it != m_PropertyLists.end() )
   {
       m_PropertyLists.erase(it);
       return true;
   }
   return false;
 }
 
 void mitk::PersistenceService::Initialize()
 {
   if( m_Initialized || m_InInitialized)
     return;
   m_InInitialized = true;
 
-  m_SceneIO = SceneIO::New();
   m_PropertyListsXmlFileReaderAndWriter = PropertyListsXmlFileReaderAndWriter::New();
 
   // Load Default File in any case
   this->Load();
   //std::string id = mitk::PersistenceService::PERSISTENCE_PROPERTYLIST_NAME; //see bug 17729
-  std::string id = "PersistenceService";
+  std::string id = GetPersistencePropertyListName();
   mitk::PropertyList::Pointer propList = this->GetPropertyList( id );
   bool autoLoadAndSave = true;
   propList->GetBoolProperty("m_AutoLoadAndSave", autoLoadAndSave);
 
   if( autoLoadAndSave == false )
   {
     MITK_DEBUG("mitk::PersistenceService") << "autoloading was not wished. clearing data we got so far.";
     this->SetAutoLoadAndSave(false);
     this->Clear();
   }
 
   m_InInitialized = false;
   m_Initialized = true;
 }
 
 void mitk::PersistenceService::Unitialize()
 {
   if(this->GetAutoLoadAndSave())
     this->Save();
-}
+}
\ No newline at end of file
diff --git a/Modules/Persistence/mitkPersistenceService.h b/Modules/Persistence/mitkPersistenceService.h
index 7060466f70..3b66cb9983 100644
--- a/Modules/Persistence/mitkPersistenceService.h
+++ b/Modules/Persistence/mitkPersistenceService.h
@@ -1,83 +1,83 @@
 /*===================================================================
 
 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 mitkPersistenceService_h
 #define mitkPersistenceService_h
 
 #include "mitkIPersistenceService.h"
 #include "mitkPropertyListsXmlFileReaderAndWriter.h"
 #include <itkLightObject.h>
 #include "mitkSceneIO.h"
-#include <MitkPersistenceExports.h>
 
 namespace mitk
 {
     ///
     /// implementation of the IPersistenceService
     /// \see IPersistenceService
-    class MitkPersistence_EXPORT PersistenceService: public itk::LightObject, public mitk::IPersistenceService
+    class PersistenceService: public itk::LightObject, public mitk::IPersistenceService
     {
     public:
-        static const std::string PERSISTENCE_PROPERTY_NAME;
-        static const std::string PERSISTENCE_PROPERTYLIST_NAME;
+        static std::string GetPersistencePropertyName();
+
+        static std::string GetPersistencePropertyListName();
 
         static void LoadModule();
         static us::ModuleContext* GetModuleContext();
 
         PersistenceService();
 
         ~PersistenceService();
 
         std::string GetDefaultPersistenceFile();
 
         mitk::PropertyList::Pointer GetPropertyList( std::string& id, bool* existed=0 );
 
         bool RemovePropertyList( std::string& id );
 
         std::string GetPersistenceNodePropertyName();
 
         DataStorage::SetOfObjects::Pointer GetDataNodes(DataStorage* ds=0);
 
         bool Save(const std::string& fileName="", bool appendChanges=false);
 
         bool Load(const std::string& fileName="", bool enforeReload=true);
 
         void SetAutoLoadAndSave(bool autoLoadAndSave);
 
         bool GetAutoLoadAndSave();
 
         void AddPropertyListReplacedObserver( PropertyListReplacedObserver* observer );
 
         void RemovePropertyListReplacedObserver( PropertyListReplacedObserver* observer );
 
         bool RestorePropertyListsFromPersistentDataNodes(const DataStorage* storage);
 
         void Clear();
 
         void Unitialize();
     private:
         void ClonePropertyList( mitk::PropertyList* from, mitk::PropertyList* to ) const;
         void Initialize();
         std::map<std::string, mitk::PropertyList::Pointer> m_PropertyLists;
         bool m_AutoLoadAndSave;
         std::set<PropertyListReplacedObserver*> m_PropertyListReplacedObserver;
         SceneIO::Pointer m_SceneIO;
         PropertyListsXmlFileReaderAndWriter::Pointer m_PropertyListsXmlFileReaderAndWriter;
         std::map<std::string, long int> m_FileNamesToModifiedTimes;
         bool m_Initialized;
         bool m_InInitialized;
     };
 }
 #endif
diff --git a/Modules/Persistence/mitkPropertyListsXmlFileReaderAndWriter.cpp b/Modules/Persistence/mitkPropertyListsXmlFileReaderAndWriter.cpp
index 2685473070..287f410781 100644
--- a/Modules/Persistence/mitkPropertyListsXmlFileReaderAndWriter.cpp
+++ b/Modules/Persistence/mitkPropertyListsXmlFileReaderAndWriter.cpp
@@ -1,256 +1,259 @@
 /*===================================================================
 
 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 "mitkPropertyListsXmlFileReaderAndWriter.h"
 #include "mitkStandaloneDataStorage.h"
 #include "mitkProperties.h"
 #include <tinyxml.h>
 #include <itksys/SystemTools.hxx>
 
 namespace mitk
 {
 
-const std::string mitk::PropertyListsXmlFileReaderAndWriter::PROPERTY_LIST_ID_ELEMENT_NAME("Name");
-
 bool PropertyListsXmlFileReaderAndWriter::PropertyFromXmlElem(std::string& name, mitk::BaseProperty::Pointer& prop, TiXmlElement* elem) const
 {
     if(!elem)
     {
         return false;
     }
 
     bool readOp = false;
     std::string type = "";
     readOp = elem->QueryStringAttribute("type", &type) == TIXML_SUCCESS;
     if( readOp )
         readOp = elem->QueryStringAttribute("name", &name) == TIXML_SUCCESS;
     else
         MITK_WARN << "type" << " attribute not found in a property";
 
     if( readOp )
     {
         if( type == "BoolProperty" )
         {
             int val = 0;
             readOp = elem->QueryIntAttribute("value", &val) == TIXML_SUCCESS;
             if( readOp )
             {
                 prop = mitk::BoolProperty::New(val==1?true: false);
             }
         }
         else if( type == "StringProperty" )
         {
             std::string val = "";
             readOp = elem->QueryStringAttribute("value", &val) == TIXML_SUCCESS;
             if( readOp )
             {
                 prop = mitk::StringProperty::New(val);
             }
         }
         else if( type == "IntProperty" )
         {
             int val = 0;
             readOp = elem->QueryIntAttribute("value", &val) == TIXML_SUCCESS;
             if( readOp )
             {
                 prop = mitk::IntProperty::New(val);
             }
         }
         else if( type == "DoubleProperty" )
         {
             double val = 0;
             readOp = elem->QueryDoubleAttribute("value", &val) == TIXML_SUCCESS;
             if( readOp )
             {
                 prop = mitk::DoubleProperty::New(val);
             }
 
         }
         else if( type == "FloatProperty" )
         {
             float val = 0;
             readOp = elem->QueryFloatAttribute("value", &val) == TIXML_SUCCESS;
             if( readOp )
             {
                 prop = mitk::FloatProperty::New(val);
             }
         }
         else
         {
             readOp = false;
             MITK_WARN << "type" << " attribute unknown. Only BoolProperty, StringProperty, IntProperty, DoubleProperty or FloatProperty allowed.";
         }
     }
     else
         MITK_WARN << "name" << " attribute not found in a property";
 
     if( !readOp )
         MITK_WARN << "value" << " attribute not found in a property";
 
     return readOp;
 
 }
 bool PropertyListsXmlFileReaderAndWriter::PropertyToXmlElem(const std::string& name, const mitk::BaseProperty* prop, TiXmlElement* elem)  const
 {
     if(!prop || !elem)
     {
         return false;
     }
 
     const mitk::IntProperty* intProp = 0;
     const mitk::FloatProperty* floatProp = 0;
     const mitk::DoubleProperty* doubleProp = 0;
     const mitk::BoolProperty* boolProp = 0;
     const mitk::StringProperty* stringProp = 0;
     bool writeOp = true;
 
     if( (boolProp = dynamic_cast<const BoolProperty*>( prop  ) ) )
     {
-        elem->SetAttribute("name", name);
+        elem->SetAttribute(GetPropertyListIdElementName(), name);
         elem->SetAttribute("value", boolProp->GetValue()? 1: 0);
         elem->SetAttribute("type", "BoolProperty");
     }
     else if( (stringProp = dynamic_cast<const StringProperty*>( prop  ) ) )
     {
-        elem->SetAttribute("name", name);
+        elem->SetAttribute(GetPropertyListIdElementName(), name);
         elem->SetAttribute("value", stringProp->GetValue());
         elem->SetAttribute("type", "StringProperty");
     }
     else if( (intProp = dynamic_cast<const IntProperty*>( prop ) ) )
     {
-        elem->SetAttribute("name", name);
+        elem->SetAttribute(GetPropertyListIdElementName(), name);
         elem->SetAttribute("value", intProp->GetValue());
         elem->SetAttribute("type", "IntProperty");
     }
     else if( (doubleProp = dynamic_cast<const DoubleProperty*>( prop  ) ) )
     {
-        elem->SetAttribute("name", name);
+        elem->SetAttribute(GetPropertyListIdElementName(), name);
         elem->SetDoubleAttribute("value", doubleProp->GetValue());
         elem->SetAttribute("type", "DoubleProperty");
     }
     else if( (floatProp = dynamic_cast<const FloatProperty*>( prop ) ) )
     {
-        elem->SetAttribute("name", name);
+        elem->SetAttribute(GetPropertyListIdElementName(), name);
         elem->SetDoubleAttribute("value", static_cast<float>( floatProp->GetValue() ) );
         elem->SetAttribute("type", "FloatProperty");
     }
     else
     {
         MITK_WARN("PropertyListImportFromXmlFile") << "Base property " << name << " is unknown";
         writeOp = false;
     }
     return writeOp;
 }
 bool PropertyListsXmlFileReaderAndWriter::WriteLists( const std::string& fileName, const std::map<std::string, mitk::PropertyList::Pointer>& _PropertyLists ) const
 {
 
     TiXmlDocument doc;
 
     TiXmlDeclaration * decl = new TiXmlDeclaration( "1.0", "", "" );
     doc.LinkEndChild( decl );
     // create root
     TiXmlElement* propertyListsElem = new TiXmlElement( "PropertyLists" );
 
     bool allPropsConverted = true;
     std::map<std::string, mitk::PropertyList::Pointer>::const_iterator it = _PropertyLists.begin();
     while( it != _PropertyLists.end() )
     {
         const std::string& id = (*it).first;
         const PropertyList* propList = (*it).second;
         TiXmlElement* propertyListElem = new TiXmlElement( "PropertyList" );
-        propertyListElem->SetAttribute(PROPERTY_LIST_ID_ELEMENT_NAME, id);
+        propertyListElem->SetAttribute(GetPropertyListIdElementName(), id);
 
         const std::map< std::string, BaseProperty::Pointer>* propMap = propList->GetMap();
         std::map< std::string, BaseProperty::Pointer>::const_iterator propMapIt = propMap->begin();
         while( propMapIt != propMap->end() )
         {
             const std::string& propName = (*propMapIt).first;
             const BaseProperty* prop = (*propMapIt).second;
             TiXmlElement* propertyElem = new TiXmlElement( "Property" );
 
             if( !this->PropertyToXmlElem(propName, prop, propertyElem) )
                 allPropsConverted = false;
 
             propertyListElem->LinkEndChild(propertyElem);
             ++propMapIt;
         }
 
         propertyListsElem->LinkEndChild(propertyListElem);
         ++it;
     }
 
     doc.LinkEndChild( propertyListsElem );
 
     return ( allPropsConverted && doc.SaveFile( fileName.c_str() ) );
 }
 bool PropertyListsXmlFileReaderAndWriter::ReadLists( const std::string& fileName, std::map<std::string, mitk::PropertyList::Pointer>& _PropertyLists )  const
 {
     // reread
     TiXmlDocument doc( fileName );
     doc.LoadFile();
 
     TiXmlHandle docHandle( &doc );
     TiXmlElement* elem = docHandle.FirstChildElement( "PropertyLists" ).FirstChildElement( "PropertyList" ).ToElement();
 
     if(!elem)
     {
         MITK_WARN("PropertyListFromXml") << "Cannot find a PropertyList element (inside a PropertyLists element)";
         return false;
     }
 
     bool opRead = false;
     while(elem)
     {
         std::string propListId;
-        opRead = elem->QueryStringAttribute( PROPERTY_LIST_ID_ELEMENT_NAME.c_str(), &propListId ) == TIXML_SUCCESS;
+        opRead = elem->QueryStringAttribute( GetPropertyListIdElementName(), &propListId ) == TIXML_SUCCESS;
         if( !opRead )
             break;
 
         mitk::PropertyList::Pointer propList = mitk::PropertyList::New();
 
         TiXmlElement* propElem = elem->FirstChildElement("Property");
 
         while(propElem)
         {
             std::string name;
             mitk::BaseProperty::Pointer prop;
             opRead = this->PropertyFromXmlElem( name, prop, propElem );
             if(!opRead)
                 break;
             propList->SetProperty( name, prop );
             propElem = propElem->NextSiblingElement( "Property" );
         }
 
         if( !opRead )
             break;
         _PropertyLists[propListId] = propList;
         elem = elem->NextSiblingElement( "PropertyList" );
     }
 
     return opRead;
 }
 
 PropertyListsXmlFileReaderAndWriter::PropertyListsXmlFileReaderAndWriter()
 {
 
 }
 
 PropertyListsXmlFileReaderAndWriter::~PropertyListsXmlFileReaderAndWriter()
 {
 
 }
 
+const char* PropertyListsXmlFileReaderAndWriter::GetPropertyListIdElementName()
+{
+  return "name";
+}
+
 }
diff --git a/Modules/Persistence/mitkPropertyListsXmlFileReaderAndWriter.h b/Modules/Persistence/mitkPropertyListsXmlFileReaderAndWriter.h
index 28281b695a..e381ee6f9d 100644
--- a/Modules/Persistence/mitkPropertyListsXmlFileReaderAndWriter.h
+++ b/Modules/Persistence/mitkPropertyListsXmlFileReaderAndWriter.h
@@ -1,52 +1,52 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef mitkXmlSceneIO_h_included
 #define mitkXmlSceneIO_h_included
 
 #include "mitkDataStorage.h"
 
 class TiXmlElement;
 
 namespace mitk
 {
 class PropertyListsXmlFileReaderAndWriter;
 
 class PropertyListsXmlFileReaderAndWriter : public itk::Object
 {
   public:
-    static const std::string PROPERTY_LIST_ID_ELEMENT_NAME;
+    static const char* GetPropertyListIdElementName();
 
     mitkClassMacro( PropertyListsXmlFileReaderAndWriter, itk::Object );
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     bool WriteLists( const std::string& fileName, const std::map<std::string, mitk::PropertyList::Pointer>& _PropertyLists ) const;
     bool ReadLists( const std::string& fileName, std::map<std::string, mitk::PropertyList::Pointer>& _PropertyLists ) const;
 
   protected:
 
     PropertyListsXmlFileReaderAndWriter();
     virtual ~PropertyListsXmlFileReaderAndWriter();
 
     bool PropertyFromXmlElem(std::string& name, mitk::BaseProperty::Pointer& prop, TiXmlElement* elem) const;
     bool PropertyToXmlElem(const std::string& name, const mitk::BaseProperty* prop, TiXmlElement* elem) const;
 };
 
 }
 
 #endif
 
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/mitkPluginActivator.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/mitkPluginActivator.cpp
index c0d10ce077..e5ccf3f4ed 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/mitkPluginActivator.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/mitkPluginActivator.cpp
@@ -1,52 +1,52 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include "mitkPluginActivator.h"
 
 
 #include <QtPlugin>
 
 #include "QmitkMITKIGTNavigationToolManagerView.h"
 #include "QmitkMITKIGTTrackingToolboxView.h"
 #include "QmitkNavigationDataPlayerView.h"
 
 #include <mitkPersistenceService.h> //Workaround for bug in persistence module (see bug 16643 for details)
                                     //CAN BE REMOVED WHEN THE BUG IS FIXED
 
 namespace mitk {
 
 void PluginActivator::start(ctkPluginContext* context)
 {
-  mitk::PersistenceService::LoadModule(); //Workaround for bug in persistence module (see bug 16643 for details)
+  //mitk::PersistenceService::LoadModule(); //Workaround for bug in persistence module (see bug 16643 for details)
                                           //CAN BE REMOVED WHEN THE BUG IS FIXED
 
 
   BERRY_REGISTER_EXTENSION_CLASS(QmitkMITKIGTNavigationToolManagerView, context)
   BERRY_REGISTER_EXTENSION_CLASS( QmitkMITKIGTTrackingToolboxView , context)
   BERRY_REGISTER_EXTENSION_CLASS( QmitkNavigationDataPlayerView , context)
 
 
 }
 
 void PluginActivator::stop(ctkPluginContext* context)
 {
   Q_UNUSED(context)
 }
 
 }
 
 Q_EXPORT_PLUGIN2(org_mitk_gui_qt_igttracking, mitk::PluginActivator)