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..faefd37e55 100644
--- a/Modules/Persistence/mitkPersistenceService.cpp
+++ b/Modules/Persistence/mitkPersistenceService.cpp
@@ -1,401 +1,406 @@
 /*===================================================================
 
 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";
   us::ModuleContext* context = us::GetModuleContext();
   std::string contextDataFile = context->GetDataFile("PersistentData.mitk");
   itksys::SystemTools::MakeDirectory(context->GetDataFile("").c_str());
 
   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();
 
   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);
       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
   {
       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/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)