diff --git a/Modules/BoundingShape/include/mitkBoundingShapeObjectFactory.h b/Modules/BoundingShape/include/mitkBoundingShapeObjectFactory.h
index 32d137ba62..74712aee6f 100644
--- a/Modules/BoundingShape/include/mitkBoundingShapeObjectFactory.h
+++ b/Modules/BoundingShape/include/mitkBoundingShapeObjectFactory.h
@@ -1,50 +1,50 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkBoundingShapeObjectFactory_h
 #define mitkBoundingShapeObjectFactory_h
 
 #include <MitkBoundingShapeExports.h>
 #include <mitkCoreObjectFactoryBase.h>
 
 namespace mitk
 {
   class MITKBOUNDINGSHAPE_EXPORT BoundingShapeObjectFactory : public CoreObjectFactoryBase
   {
   public:
     mitkClassMacro(BoundingShapeObjectFactory, CoreObjectFactoryBase);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       Mapper::Pointer CreateMapper(DataNode *node, MapperSlotId slotId) override;
     void SetDefaultProperties(DataNode *node) override;
-    const char *GetFileExtensions() override;
+    std::string GetFileExtensions() override;
     CoreObjectFactoryBase::MultimapType GetFileExtensionsMap() override;
-    const char *GetSaveFileExtensions() override;
+    std::string GetSaveFileExtensions() override;
     CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap() override;
     const char *GetDescription() const override;
 
   protected:
     BoundingShapeObjectFactory();
     ~BoundingShapeObjectFactory() override;
 
     void CreateFileExtensionsMap();
 
   private:
     MultimapType m_FileExtensionsMap;
     MultimapType m_SaveFileExtensionsMap;
   };
 
   MITKBOUNDINGSHAPE_EXPORT void RegisterBoundingShapeObjectFactory();
 }
 
 #endif
diff --git a/Modules/BoundingShape/src/DataManagement/mitkBoundingShapeObjectFactory.cpp b/Modules/BoundingShape/src/DataManagement/mitkBoundingShapeObjectFactory.cpp
index a1ddf7cb39..a700c9bed7 100644
--- a/Modules/BoundingShape/src/DataManagement/mitkBoundingShapeObjectFactory.cpp
+++ b/Modules/BoundingShape/src/DataManagement/mitkBoundingShapeObjectFactory.cpp
@@ -1,94 +1,94 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkBoundingShapeObjectFactory.h"
 #include "mitkBoundingShapeVtkMapper2D.h"
 #include "mitkBoundingShapeVtkMapper3D.h"
 #include <mitkCoreObjectFactory.h>
 
 mitk::BoundingShapeObjectFactory::BoundingShapeObjectFactory()
 {
 }
 
 mitk::BoundingShapeObjectFactory::~BoundingShapeObjectFactory()
 {
 }
 
 mitk::Mapper::Pointer mitk::BoundingShapeObjectFactory::CreateMapper(mitk::DataNode *node, MapperSlotId slotId)
 {
   Mapper::Pointer mapper;
 
   if (dynamic_cast<GeometryData *>(node->GetData()) != nullptr)
   {
     if (slotId == BaseRenderer::Standard2D)
     {
       mapper = BoundingShapeVtkMapper2D::New();
     }
     else if (slotId == BaseRenderer::Standard3D)
     {
       mapper = BoundingShapeVtkMapper3D::New();
     }
 
     if (mapper.IsNotNull())
       mapper->SetDataNode(node);
   }
 
   return mapper;
 }
 
 const char *mitk::BoundingShapeObjectFactory::GetDescription() const
 {
   return "BoundingShape Object Factory";
 }
 
-const char *mitk::BoundingShapeObjectFactory::GetFileExtensions()
+std::string mitk::BoundingShapeObjectFactory::GetFileExtensions()
 {
   return nullptr;
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::BoundingShapeObjectFactory::GetFileExtensionsMap()
 {
   return MultimapType();
 }
 
-const char *mitk::BoundingShapeObjectFactory::GetSaveFileExtensions()
+std::string mitk::BoundingShapeObjectFactory::GetSaveFileExtensions()
 {
   return nullptr;
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::BoundingShapeObjectFactory::GetSaveFileExtensionsMap()
 {
   return MultimapType();
 }
 
 void mitk::BoundingShapeObjectFactory::SetDefaultProperties(mitk::DataNode *node)
 {
   if (node == nullptr)
     return;
 
   if (dynamic_cast<GeometryData *>(node->GetData()) != nullptr)
   {
     BoundingShapeVtkMapper2D::SetDefaultProperties(node);
     BoundingShapeVtkMapper3D::SetDefaultProperties(node);
   }
 }
 
 void mitk::RegisterBoundingShapeObjectFactory()
 {
   static bool alreadyRegistered = false;
 
   if (!alreadyRegistered)
   {
     CoreObjectFactory::GetInstance()->RegisterExtraFactory(BoundingShapeObjectFactory::New());
     alreadyRegistered = true;
   }
 }
diff --git a/Modules/ContourModel/Algorithms/mitkContourObjectFactory.cpp b/Modules/ContourModel/Algorithms/mitkContourObjectFactory.cpp
index 0dc7d5256e..946f2ac32c 100644
--- a/Modules/ContourModel/Algorithms/mitkContourObjectFactory.cpp
+++ b/Modules/ContourModel/Algorithms/mitkContourObjectFactory.cpp
@@ -1,144 +1,144 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkContourObjectFactory.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 
 #include "mitkContourModel.h"
 #include "mitkContourModelGLMapper2D.h"
 #include "mitkContourModelMapper2D.h"
 #include "mitkContourModelMapper3D.h"
 #include "mitkContourModelSet.h"
 #include "mitkContourModelSetGLMapper2D.h"
 #include "mitkContourModelSetMapper3D.h"
 #include "mitkContourModelSetWriter.h"
 #include "mitkContourModelWriter.h"
 
 mitk::ContourObjectFactory::ContourObjectFactory() : CoreObjectFactoryBase()
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "ContourObjectFactory c'tor" << std::endl;
 
     alreadyDone = true;
   }
 }
 
 mitk::ContourObjectFactory::~ContourObjectFactory()
 {
 }
 
 mitk::Mapper::Pointer mitk::ContourObjectFactory::CreateMapper(mitk::DataNode *node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper = nullptr;
 
   if (id == mitk::BaseRenderer::Standard2D)
   {
     std::string classname("ContourModel");
     if (dynamic_cast<mitk::ContourModel *>(node->GetData()) != nullptr)
     {
       newMapper = mitk::ContourModelGLMapper2D::New();
       newMapper->SetDataNode(node);
     }
     else if (dynamic_cast<mitk::ContourModelSet *>(node->GetData()) != nullptr)
     {
       newMapper = mitk::ContourModelSetGLMapper2D::New();
       newMapper->SetDataNode(node);
     }
   }
   else if (id == mitk::BaseRenderer::Standard3D)
   {
     if (dynamic_cast<mitk::ContourModel *>(node->GetData()) != nullptr)
     {
       newMapper = mitk::ContourModelMapper3D::New();
       newMapper->SetDataNode(node);
     }
     else if (dynamic_cast<mitk::ContourModelSet *>(node->GetData()) != nullptr)
     {
       newMapper = mitk::ContourModelSetMapper3D::New();
       newMapper->SetDataNode(node);
     }
   }
   return newMapper;
 }
 
 void mitk::ContourObjectFactory::SetDefaultProperties(mitk::DataNode *node)
 {
   if (node == nullptr)
     return;
 
   mitk::DataNode::Pointer nodePointer = node;
 
   if (node->GetData() == nullptr)
     return;
 
   if (dynamic_cast<mitk::ContourModel *>(node->GetData()) != nullptr)
   {
     mitk::ContourModelGLMapper2D::SetDefaultProperties(node);
     mitk::ContourModelMapper3D::SetDefaultProperties(node);
   }
   else if (dynamic_cast<mitk::ContourModelSet *>(node->GetData()) != nullptr)
   {
     mitk::ContourModelSetGLMapper2D::SetDefaultProperties(node);
     mitk::ContourModelSetMapper3D::SetDefaultProperties(node);
   }
 }
 
-const char *mitk::ContourObjectFactory::GetFileExtensions()
+std::string mitk::ContourObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::ContourObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::ContourObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::ContourObjectFactory::CreateFileExtensionsMap()
 {
 }
 
-const char *mitk::ContourObjectFactory::GetSaveFileExtensions()
+std::string mitk::ContourObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 void mitk::ContourObjectFactory::RegisterIOFactories()
 {
 }
 
 struct RegisterContourObjectFactory
 {
   RegisterContourObjectFactory() : m_Factory(mitk::ContourObjectFactory::New())
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(m_Factory);
   }
 
   ~RegisterContourObjectFactory() { mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory(m_Factory); }
   mitk::ContourObjectFactory::Pointer m_Factory;
 };
 
 static RegisterContourObjectFactory registerContourObjectFactory;
diff --git a/Modules/ContourModel/Algorithms/mitkContourObjectFactory.h b/Modules/ContourModel/Algorithms/mitkContourObjectFactory.h
index e8f53b5e9c..96df9101df 100644
--- a/Modules/ContourModel/Algorithms/mitkContourObjectFactory.h
+++ b/Modules/ContourModel/Algorithms/mitkContourObjectFactory.h
@@ -1,48 +1,48 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef SEGMENTATIONOBJECTFACTORY_H_INCLUDED
 #define SEGMENTATIONOBJECTFACTORY_H_INCLUDED
 
 #include "mitkCoreObjectFactoryBase.h"
 #include <MitkContourModelExports.h>
 
 namespace mitk
 {
   class MITKCONTOURMODEL_EXPORT ContourObjectFactory : public CoreObjectFactoryBase
   {
   public:
     mitkClassMacro(ContourObjectFactory, CoreObjectFactoryBase);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self) Mapper::Pointer
       CreateMapper(mitk::DataNode *node, MapperSlotId slotId) override;
     void SetDefaultProperties(mitk::DataNode *node) override;
-    const char *GetFileExtensions() override;
+    std::string GetFileExtensions() override;
     mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap() override;
-    const char *GetSaveFileExtensions() override;
+    std::string GetSaveFileExtensions() override;
     mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap() override;
 
     /** \deprecatedSince{2013_09} */
     DEPRECATED(void RegisterIOFactories());
 
   protected:
     ContourObjectFactory();
     ~ContourObjectFactory() override;
     void CreateFileExtensionsMap();
     MultimapType m_FileExtensionsMap;
     MultimapType m_SaveFileExtensionsMap;
 
   private:
   };
 }
 
 #endif
diff --git a/Modules/Core/include/mitkCoreObjectFactory.h b/Modules/Core/include/mitkCoreObjectFactory.h
index 5ba7b0f3b9..f1bdca80dd 100644
--- a/Modules/Core/include/mitkCoreObjectFactory.h
+++ b/Modules/Core/include/mitkCoreObjectFactory.h
@@ -1,140 +1,140 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef COREOBJECTFACTORY_H_INCLUDED
 #define COREOBJECTFACTORY_H_INCLUDED
 
 #include <set>
 
 #include "mitkCoreObjectFactoryBase.h"
 #include "mitkFileWriterWithInformation.h"
 #include <MitkCoreExports.h>
 namespace mitk
 {
   class Event;
   class LegacyFileReaderService;
   class LegacyFileWriterService;
   class LegacyImageWriterService;
 
   class MITKCORE_EXPORT CoreObjectFactory : public CoreObjectFactoryBase
   {
   public:
     mitkClassMacro(CoreObjectFactory, CoreObjectFactoryBase);
     itkFactorylessNewMacro(CoreObjectFactory);
 
       Mapper::Pointer CreateMapper(mitk::DataNode *node, MapperSlotId slotId) override;
     void SetDefaultProperties(mitk::DataNode *node) override;
 
     virtual void MapEvent(const mitk::Event *event, const int eventID);
 
     virtual void RegisterExtraFactory(CoreObjectFactoryBase *factory);
     virtual void UnRegisterExtraFactory(CoreObjectFactoryBase *factory);
 
     static Pointer GetInstance();
 
     ~CoreObjectFactory() override;
 
     /**
      * @brief This method gets the supported (open) file extensions as string.
      *
      * This string can then used by the Qt QFileDialog widget.
      *
      * @return The c-string that contains the file extensions
      * @deprecatedSince{2014_10} See mitk::FileReaderRegistry and QmitkIOUtil
      */
-    DEPRECATED(virtual const char *GetFileExtensions() override);
+    DEPRECATED(virtual std::string GetFileExtensions() override);
 
     /**
      * @brief get the defined (open) file extension map
      *
      * @return the defined (open) file extension map
      * @deprecatedSince{2014_10} See mitk::FileReaderRegistry and QmitkIOUtil
      */
     DEPRECATED(virtual MultimapType GetFileExtensionsMap() override);
 
     /**
      * @brief This method gets the supported (save) file extensions as string.
      *
      * This string can then used by the Qt QFileDialog widget.
      *
      * @return The c-string that contains the (save) file extensions
      * @deprecatedSince{2014_10} See mitk::FileWriterRegistry and QmitkIOUtil
      */
-    DEPRECATED(virtual const char *GetSaveFileExtensions() override);
+    DEPRECATED(virtual std::string GetSaveFileExtensions() override);
 
     /**
      * @brief get the defined (save) file extension map
      *
      * @return the defined (save) file extension map
      * @deprecatedSince{2014_10} See mitk::FileWriterRegistry and QmitkIOUtil
      */
     MultimapType GetSaveFileExtensionsMap() override;
 
     /**
      * @deprecatedSince{2014_10} See mitk::FileWriterRegistry
      */
     DEPRECATED(virtual FileWriterList GetFileWriters());
 
     /**
      * @deprecatedSince{2014_10} See mitk::FileWriterRegistry and QmitkIOUtil
      */
     DEPRECATED(std::string GetDescriptionForExtension(const std::string &extension));
 
   protected:
     CoreObjectFactory();
 
     /**
      * @brief Merge the input map into the fileExtensionsMap. Duplicate entries are removed
      *
      * @param fileExtensionsMap the existing map, it contains value pairs like
      *        ("*.dcm", "DICOM files"),("*.dc3", "DICOM files").
      *        This map is extented/merged with the values from the input map.
      * @param inputMap the input map, it contains value pairs like ("*.dcm",
      *        "DICOM files"),("*.dc3", "DICOM files") returned by the extra factories.
      * @deprecatedSince{2014_10}
      */
     void MergeFileExtensions(MultimapType &fileExtensionsMap, MultimapType inputMap);
 
     /**
      * @brief initialize the file extension entries for open and save
      * @deprecatedSince{2014_10}
      */
     void CreateFileExtensionsMap();
 
     /**
      * @deprecatedSince{2014_10}
      */
     DEPRECATED(void CreateSaveFileExtensions());
 
     typedef std::set<mitk::CoreObjectFactoryBase::Pointer> ExtraFactoriesContainer;
 
     ExtraFactoriesContainer m_ExtraFactories;
     FileWriterList m_FileWriters;
     std::string m_FileExtensions;
     MultimapType m_FileExtensionsMap;
     std::string m_SaveFileExtensions;
     MultimapType m_SaveFileExtensionsMap;
 
   private:
     void RegisterLegacyReaders(mitk::CoreObjectFactoryBase *factory);
     void RegisterLegacyWriters(mitk::CoreObjectFactoryBase *factory);
 
     void UnRegisterLegacyReaders(mitk::CoreObjectFactoryBase *factory);
     void UnRegisterLegacyWriters(mitk::CoreObjectFactoryBase *factory);
 
     std::map<mitk::CoreObjectFactoryBase *, std::list<mitk::LegacyFileReaderService *>> m_LegacyReaders;
     std::map<mitk::CoreObjectFactoryBase *, std::list<mitk::LegacyFileWriterService *>> m_LegacyWriters;
   };
 
 } // namespace mitk
 
 #endif
diff --git a/Modules/Core/include/mitkCoreObjectFactoryBase.h b/Modules/Core/include/mitkCoreObjectFactoryBase.h
index 52300916c9..b5b553f008 100644
--- a/Modules/Core/include/mitkCoreObjectFactoryBase.h
+++ b/Modules/Core/include/mitkCoreObjectFactoryBase.h
@@ -1,91 +1,91 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef COREOBJECTFACTORYBASE_H_INCLUDED
 #define COREOBJECTFACTORYBASE_H_INCLUDED
 
 // the mbilog header is necessary for CMake test drivers.
 // Since the EXTRA_INCLUDE parameter of CREATE_TEST_SOURCELIST only
 // allows one extra include file, we specify mitkLog.h here so it will
 // be available to all classes implementing this interface.
 #include "mitkLog.h"
 
 #include "mitkFileWriterWithInformation.h"
 #include "mitkMapper.h"
 #include <MitkCoreExports.h>
 #include <itkObjectFactoryBase.h>
 #include <itkVersion.h>
 
 namespace mitk
 {
   class DataNode;
 
   //## @brief base-class for factories of certain mitk objects.
   //## @ingroup Algorithms
   //## This interface can be implemented by factories which add new mapper classes or extend the
   //## data tree deserialization mechanism.
 
   class MITKCORE_EXPORT CoreObjectFactoryBase : public itk::Object
   {
   public:
     typedef std::list<mitk::FileWriterWithInformation::Pointer> FileWriterList;
     typedef std::multimap<std::string, std::string> MultimapType;
 
     mitkClassMacroItkParent(CoreObjectFactoryBase, itk::Object);
 
       virtual Mapper::Pointer CreateMapper(mitk::DataNode *node, MapperSlotId slotId) = 0;
     virtual void SetDefaultProperties(mitk::DataNode *node) = 0;
 
     /**
      * @deprecatedSince{2014_10} See mitk::FileReaderRegistry and QmitkIOUtil
      */
-    virtual const char *GetFileExtensions() = 0;
+    virtual std::string GetFileExtensions() = 0;
 
     /**
      * @deprecatedSince{2014_10} See mitk::FileReaderRegistry and QmitkIOUtil
      */
     virtual MultimapType GetFileExtensionsMap() = 0;
 
     /**
      * @deprecatedSince{2014_10} See mitk::FileWriterRegistry and QmitkIOUtil
      */
-    virtual const char *GetSaveFileExtensions() = 0;
+    virtual std::string GetSaveFileExtensions() = 0;
 
     /**
      * @deprecatedSince{2014_10} See mitk::FileWriterRegistry and QmitkIOUtil
      */
     virtual MultimapType GetSaveFileExtensionsMap() = 0;
 
     virtual const char *GetITKSourceVersion() const { return ITK_SOURCE_VERSION; }
     virtual const char *GetDescription() const { return "Core Object Factory"; }
     /**
      * @deprecatedSince{2014_10} See mitk::FileWriterRegistry
      */
     FileWriterList GetFileWriters() { return m_FileWriters; }
   protected:
     /**
      * @brief create a string from a map that contains the file extensions
      * @param fileExtensionsMap input map with the file extensions, e.g. ("*.dcm", "DICOM files")("*.dc3", "DICOM
      * files")
      * @param fileExtensions the converted output string, suitable for the QT QFileDialog widget
      *                       e.g. "all (*.dcm *.DCM *.dc3 ... *.vti *.hdr *.nrrd *.nhdr );;ODF Images (*.odf *qbi)"
      *
      * @deprecatedSince{2014_10}
      */
     static void CreateFileExtensions(MultimapType fileExtensionsMap, std::string &fileExtensions);
 
     FileWriterList m_FileWriters;
 
     friend class CoreObjectFactory;
   };
 }
 #endif
diff --git a/Modules/Core/src/mitkCoreObjectFactory.cpp b/Modules/Core/src/mitkCoreObjectFactory.cpp
index bc3ccef8a5..4e0574e882 100644
--- a/Modules/Core/src/mitkCoreObjectFactory.cpp
+++ b/Modules/Core/src/mitkCoreObjectFactory.cpp
@@ -1,454 +1,454 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkCoreObjectFactory.h"
 #include "mitkConfig.h"
 
 #include "mitkColorProperty.h"
 #include "mitkDataNode.h"
 #include "mitkEnumerationProperty.h"
 #include "mitkGeometry3D.h"
 #include "mitkGeometryData.h"
 #include "mitkImage.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkPlaneGeometryData.h"
 #include "mitkPlaneGeometryDataMapper2D.h"
 #include "mitkPlaneGeometryDataVtkMapper3D.h"
 #include "mitkPointSet.h"
 #include "mitkPointSetVtkMapper2D.h"
 #include "mitkPointSetVtkMapper3D.h"
 #include "mitkProperties.h"
 #include "mitkPropertyList.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkSmartPointerProperty.h"
 #include "mitkStringProperty.h"
 #include "mitkSurface.h"
 #include "mitkSurface.h"
 #include "mitkSurfaceVtkMapper2D.h"
 #include "mitkSurfaceVtkMapper3D.h"
 #include "mitkTimeGeometry.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkVtkInterpolationProperty.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include <mitkImageVtkMapper2D.h>
 
 // Legacy Support:
 #include <mitkCoreServices.h>
 #include <mitkLegacyFileReaderService.h>
 #include <mitkLegacyFileWriterService.h>
 
 void mitk::CoreObjectFactory::RegisterExtraFactory(CoreObjectFactoryBase *factory)
 {
   MITK_DEBUG << "CoreObjectFactory: registering extra factory of type " << factory->GetNameOfClass();
   m_ExtraFactories.insert(CoreObjectFactoryBase::Pointer(factory));
   // Register Legacy Reader and Writer
   this->RegisterLegacyReaders(factory);
   this->RegisterLegacyWriters(factory);
 }
 
 void mitk::CoreObjectFactory::UnRegisterExtraFactory(CoreObjectFactoryBase *factory)
 {
   MITK_DEBUG << "CoreObjectFactory: un-registering extra factory of type " << factory->GetNameOfClass();
   this->UnRegisterLegacyWriters(factory);
   this->UnRegisterLegacyReaders(factory);
   try
   {
     m_ExtraFactories.erase(factory);
   }
   catch ( const std::exception &e )
   {
     MITK_ERROR << "Caugt exception while unregistering: " << e.what();
   }
 }
 
 mitk::CoreObjectFactory::Pointer mitk::CoreObjectFactory::GetInstance()
 {
   static mitk::CoreObjectFactory::Pointer instance;
   if (instance.IsNull())
   {
     instance = mitk::CoreObjectFactory::New();
   }
   return instance;
 }
 
 mitk::CoreObjectFactory::~CoreObjectFactory()
 {
   for (auto iter =
          m_LegacyReaders.begin();
        iter != m_LegacyReaders.end();
        ++iter)
   {
     for (auto &elem : iter->second)
     {
       delete elem;
     }
   }
 
   for (auto iter =
          m_LegacyWriters.begin();
        iter != m_LegacyWriters.end();
        ++iter)
   {
     for (auto &elem : iter->second)
     {
       delete elem;
     }
   }
 }
 
 void mitk::CoreObjectFactory::SetDefaultProperties(mitk::DataNode *node)
 {
   if (node == nullptr)
     return;
 
   mitk::DataNode::Pointer nodePointer = node;
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(node->GetData());
   if (image.IsNotNull() && image->IsInitialized())
   {
     mitk::ImageVtkMapper2D::SetDefaultProperties(node);
   }
 
   mitk::PlaneGeometryData::Pointer planeGeometry = dynamic_cast<mitk::PlaneGeometryData *>(node->GetData());
   if (planeGeometry.IsNotNull())
   {
     mitk::PlaneGeometryDataMapper2D::SetDefaultProperties(node);
   }
 
   mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface *>(node->GetData());
   if (surface.IsNotNull())
   {
     mitk::SurfaceVtkMapper2D::SetDefaultProperties(node);
     mitk::SurfaceVtkMapper3D::SetDefaultProperties(node);
   }
 
   mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet *>(node->GetData());
   if (pointSet.IsNotNull())
   {
     mitk::PointSetVtkMapper2D::SetDefaultProperties(node);
     mitk::PointSetVtkMapper3D::SetDefaultProperties(node);
   }
   for (auto it = m_ExtraFactories.begin(); it != m_ExtraFactories.end(); ++it)
   {
     (*it)->SetDefaultProperties(node);
   }
 }
 
 mitk::CoreObjectFactory::CoreObjectFactory()
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     CreateFileExtensionsMap();
 
     // RegisterLegacyReaders(this);
     // RegisterLegacyWriters(this);
 
     alreadyDone = true;
   }
 }
 
 mitk::Mapper::Pointer mitk::CoreObjectFactory::CreateMapper(mitk::DataNode *node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper = nullptr;
   mitk::Mapper::Pointer tmpMapper = nullptr;
 
   // check whether extra factories provide mapper
   for (auto it = m_ExtraFactories.begin(); it != m_ExtraFactories.end(); ++it)
   {
     tmpMapper = (*it)->CreateMapper(node, id);
     if (tmpMapper.IsNotNull())
       newMapper = tmpMapper;
   }
 
   if (newMapper.IsNull())
   {
     mitk::BaseData *data = node->GetData();
 
     if (id == mitk::BaseRenderer::Standard2D)
     {
       if ((dynamic_cast<Image *>(data) != nullptr))
       {
         newMapper = mitk::ImageVtkMapper2D::New();
         newMapper->SetDataNode(node);
       }
       else if ((dynamic_cast<PlaneGeometryData *>(data) != nullptr))
       {
         newMapper = mitk::PlaneGeometryDataMapper2D::New();
         newMapper->SetDataNode(node);
       }
       else if ((dynamic_cast<Surface *>(data) != nullptr))
       {
         newMapper = mitk::SurfaceVtkMapper2D::New();
         // cast because SetDataNode is not virtual
         auto *castedMapper = dynamic_cast<mitk::SurfaceVtkMapper2D *>(newMapper.GetPointer());
         castedMapper->SetDataNode(node);
       }
       else if ((dynamic_cast<PointSet *>(data) != nullptr))
       {
         newMapper = mitk::PointSetVtkMapper2D::New();
         newMapper->SetDataNode(node);
       }
     }
     else if (id == mitk::BaseRenderer::Standard3D)
     {
       if ((dynamic_cast<PlaneGeometryData *>(data) != nullptr))
       {
         newMapper = mitk::PlaneGeometryDataVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
       else if ((dynamic_cast<Surface *>(data) != nullptr))
       {
         newMapper = mitk::SurfaceVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
       else if ((dynamic_cast<PointSet *>(data) != nullptr))
       {
         newMapper = mitk::PointSetVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
     }
   }
 
   return newMapper;
 }
 
-const char *mitk::CoreObjectFactory::GetFileExtensions()
+std::string mitk::CoreObjectFactory::GetFileExtensions()
 {
   MultimapType aMap;
   for (auto it = m_ExtraFactories.begin(); it != m_ExtraFactories.end(); ++it)
   {
     aMap = (*it)->GetFileExtensionsMap();
     this->MergeFileExtensions(m_FileExtensionsMap, aMap);
   }
   this->CreateFileExtensions(m_FileExtensionsMap, m_FileExtensions);
   return m_FileExtensions.c_str();
 }
 
 void mitk::CoreObjectFactory::MergeFileExtensions(MultimapType &fileExtensionsMap, MultimapType inputMap)
 {
   std::pair<MultimapType::iterator, MultimapType::iterator> pairOfIter;
   for (auto it = inputMap.begin(); it != inputMap.end(); ++it)
   {
     bool duplicateFound = false;
     pairOfIter = fileExtensionsMap.equal_range((*it).first);
     for (auto it2 = pairOfIter.first; it2 != pairOfIter.second; ++it2)
     {
       // cout << "  [" << (*it).first << ", " << (*it).second << "]" << endl;
       std::string aString = (*it2).second;
       if (aString.compare((*it).second) == 0)
       {
         // cout << "  DUP!! [" << (*it).first << ", " << (*it).second << "]" << endl;
         duplicateFound = true;
         break;
       }
     }
     if (!duplicateFound)
     {
       fileExtensionsMap.insert(std::pair<std::string, std::string>((*it).first, (*it).second));
     }
   }
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::CoreObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 void mitk::CoreObjectFactory::CreateFileExtensionsMap()
 {
   /*
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.DCM", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dc3", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.DC3", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gdcm", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.seq", "DKFZ Pic"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.seq.gz", "DKFZ Pic"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gdcm", "Sets of 2D slices"));
   */
 }
 
-const char *mitk::CoreObjectFactory::GetSaveFileExtensions()
+std::string mitk::CoreObjectFactory::GetSaveFileExtensions()
 {
   MultimapType aMap;
   for (auto it = m_ExtraFactories.begin(); it != m_ExtraFactories.end(); ++it)
   {
     aMap = (*it)->GetSaveFileExtensionsMap();
     this->MergeFileExtensions(m_SaveFileExtensionsMap, aMap);
   }
   this->CreateFileExtensions(m_SaveFileExtensionsMap, m_SaveFileExtensions);
   return m_SaveFileExtensions.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::CoreObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 mitk::CoreObjectFactory::FileWriterList mitk::CoreObjectFactory::GetFileWriters()
 {
   FileWriterList allWriters = m_FileWriters;
   // sort to merge lists later on
   typedef std::set<mitk::FileWriterWithInformation::Pointer> FileWriterSet;
   FileWriterSet fileWritersSet;
 
   fileWritersSet.insert(allWriters.begin(), allWriters.end());
 
   // collect all extra factories
   for (auto it = m_ExtraFactories.begin(); it != m_ExtraFactories.end(); ++it)
   {
     FileWriterList list2 = (*it)->GetFileWriters();
 
     // add them to the sorted set
     fileWritersSet.insert(list2.begin(), list2.end());
   }
 
   // write back to allWriters to return a list
   allWriters.clear();
   allWriters.insert(allWriters.end(), fileWritersSet.begin(), fileWritersSet.end());
 
   return allWriters;
 }
 
 void mitk::CoreObjectFactory::MapEvent(const mitk::Event *, const int)
 {
 }
 
 std::string mitk::CoreObjectFactory::GetDescriptionForExtension(const std::string &extension)
 {
   std::multimap<std::string, std::string> fileExtensionMap = GetSaveFileExtensionsMap();
   for (auto it = fileExtensionMap.begin(); it != fileExtensionMap.end();
        ++it)
     if (it->first == extension)
       return it->second;
   return ""; // If no matching extension was found, return emtpy string
 }
 
 void mitk::CoreObjectFactory::RegisterLegacyReaders(mitk::CoreObjectFactoryBase *factory)
 {
   // We are not really interested in the string, just call the method since
   // many readers initialize the map the first time when this method is called
   factory->GetFileExtensions();
 
   std::map<std::string, std::vector<std::string>> extensionsByCategories;
   std::multimap<std::string, std::string> fileExtensionMap = factory->GetFileExtensionsMap();
   for (auto it = fileExtensionMap.begin(); it != fileExtensionMap.end();
        ++it)
   {
     std::string extension = it->first;
     // remove "*."
     extension = extension.erase(0, 2);
 
     extensionsByCategories[it->second].push_back(extension);
   }
 
   for (auto &extensionsByCategorie : extensionsByCategories)
   {
     m_LegacyReaders[factory].push_back(
       new mitk::LegacyFileReaderService(extensionsByCategorie.second, extensionsByCategorie.first));
   }
 }
 
 void mitk::CoreObjectFactory::UnRegisterLegacyReaders(mitk::CoreObjectFactoryBase *factory)
 {
   auto iter =
     m_LegacyReaders.find(factory);
   if (iter != m_LegacyReaders.end())
   {
     for (auto &elem : iter->second)
     {
       delete elem;
     }
 
     m_LegacyReaders.erase(iter);
   }
 }
 
 void mitk::CoreObjectFactory::RegisterLegacyWriters(mitk::CoreObjectFactoryBase *factory)
 {
   // Get all external Writers
   mitk::CoreObjectFactory::FileWriterList writers = factory->GetFileWriters();
 
   // We are not really interested in the string, just call the method since
   // many writers initialize the map the first time when this method is called
   factory->GetSaveFileExtensions();
 
   MultimapType fileExtensionMap = factory->GetSaveFileExtensionsMap();
 
   for (auto it = writers.begin(); it != writers.end(); ++it)
   {
     std::vector<std::string> extensions = (*it)->GetPossibleFileExtensions();
     if (extensions.empty())
       continue;
 
     std::string description;
     for (auto ext = extensions.begin(); ext != extensions.end(); ++ext)
     {
       if (ext->empty())
         continue;
 
       std::string extension = *ext;
       std::string extensionWithStar = extension;
       if (extension.find_first_of('*') == 0)
       {
         // remove "*."
         extension = extension.substr(0, extension.size() - 2);
       }
       else
       {
         extensionWithStar.insert(extensionWithStar.begin(), '*');
       }
 
       for (auto fileExtensionIter = fileExtensionMap.begin();
            fileExtensionIter != fileExtensionMap.end();
            ++fileExtensionIter)
       {
         if (fileExtensionIter->first == extensionWithStar)
         {
           description = fileExtensionIter->second;
           break;
         }
       }
       if (!description.empty())
         break;
     }
     if (description.empty())
     {
       description = std::string("Legacy ") + (*it)->GetNameOfClass() + " Reader";
     }
 
     mitk::FileWriter::Pointer fileWriter(it->GetPointer());
     mitk::LegacyFileWriterService *lfws = new mitk::LegacyFileWriterService(fileWriter, description);
     m_LegacyWriters[factory].push_back(lfws);
   }
 }
 
 void mitk::CoreObjectFactory::UnRegisterLegacyWriters(mitk::CoreObjectFactoryBase *factory)
 {
   auto iter =
     m_LegacyWriters.find(factory);
   if (iter != m_LegacyWriters.end())
   {
     for (auto &elem : iter->second)
     {
       delete elem;
     }
 
     m_LegacyWriters.erase(iter);
   }
 }
diff --git a/Modules/Gizmo/src/mitkGizmoObjectFactory.h b/Modules/Gizmo/src/mitkGizmoObjectFactory.h
index a9528ba978..7e6fb76dad 100644
--- a/Modules/Gizmo/src/mitkGizmoObjectFactory.h
+++ b/Modules/Gizmo/src/mitkGizmoObjectFactory.h
@@ -1,64 +1,64 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef GizmoObjectFactor_h
 #define GizmoObjectFactor_h
 
 // MITK includes
 #include <mitkCoreObjectFactory.h>
 
 // Export definitions
 #include <MitkGizmoExports.h>
 
 namespace mitk
 {
   /*
       \brief Registers mappers and assigns default properties for mitk::Gizmo.
 
       This class is still required by MITK to register custom mappers.
       The base class interface requires also methods that describe file
       reader/writer extensions, but this is already deprecated. We do
       not implement those methods but use the new micro-service registration
       via GizmoActivator.
   */
   class MITKGIZMO_EXPORT GizmoObjectFactory : public mitk::CoreObjectFactoryBase
   {
   public:
     mitkClassMacro(GizmoObjectFactory, CoreObjectFactoryBase);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     // Create a mapper for given node
     mitk::Mapper::Pointer CreateMapper(mitk::DataNode *node, MapperSlotId slotId) override;
 
     // Assign default properties to given node
     void SetDefaultProperties(mitk::DataNode *node) override;
 
     // Deprecated but required!
-    const char *GetFileExtensions() override { return ""; }
+    std::string GetFileExtensions() override { return ""; }
     // Deprecated but required!
     mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap() override
     {
       return CoreObjectFactoryBase::MultimapType();
     }
 
     // Deprecated but required!
-    const char *GetSaveFileExtensions() override { return ""; }
+    std::string GetSaveFileExtensions() override { return ""; }
     // Deprecated but required!
     mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap() override
     {
       return CoreObjectFactoryBase::MultimapType();
     }
   };
 }
 
 #endif
diff --git a/Modules/IOExt/Internal/mitkIOExtObjectFactory.cpp b/Modules/IOExt/Internal/mitkIOExtObjectFactory.cpp
index ee4c2453dc..d268917ff6 100644
--- a/Modules/IOExt/Internal/mitkIOExtObjectFactory.cpp
+++ b/Modules/IOExt/Internal/mitkIOExtObjectFactory.cpp
@@ -1,180 +1,180 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkIOExtObjectFactory.h"
 
 #include "mitkCoreObjectFactory.h"
 
 #include "mitkParRecFileIOFactory.h"
 //#include "mitkObjFileIOFactory.h"
 #include "mitkStlVolumeTimeSeriesIOFactory.h"
 #include "mitkVtkVolumeTimeSeriesIOFactory.h"
 
 #include "mitkUnstructuredGridVtkWriter.h"
 #include "mitkUnstructuredGridVtkWriterFactory.h"
 
 #include "mitkVolumeMapperVtkSmart3D.h"
 #include "mitkMesh.h"
 #include "mitkMeshMapper2D.h"
 #include "mitkMeshVtkMapper3D.h"
 #include "mitkUnstructuredGridMapper2D.h"
 #include "mitkUnstructuredGridVtkMapper3D.h"
 #include "mitkVtkGLMapperWrapper.h"
 
 #include <vtkUnstructuredGridWriter.h>
 #include <vtkXMLPUnstructuredGridWriter.h>
 #include <vtkXMLUnstructuredGridWriter.h>
 
 mitk::IOExtObjectFactory::IOExtObjectFactory()
   : CoreObjectFactoryBase(),
     m_ParRecFileIOFactory(ParRecFileIOFactory::New().GetPointer())
     //, m_ObjFileIOFactory(ObjFileIOFactory::New().GetPointer())
     ,
     m_StlVolumeTimeSeriesIOFactory(StlVolumeTimeSeriesIOFactory::New().GetPointer()),
     m_VtkVolumeTimeSeriesIOFactory(VtkVolumeTimeSeriesIOFactory::New().GetPointer()),
     m_UnstructuredGridVtkWriterFactory(UnstructuredGridVtkWriterFactory::New().GetPointer())
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "IOExtObjectFactory c'tor" << std::endl;
 
     itk::ObjectFactoryBase::RegisterFactory(m_ParRecFileIOFactory);
     itk::ObjectFactoryBase::RegisterFactory(m_StlVolumeTimeSeriesIOFactory);
     itk::ObjectFactoryBase::RegisterFactory(m_VtkVolumeTimeSeriesIOFactory);
 
     itk::ObjectFactoryBase::RegisterFactory(m_UnstructuredGridVtkWriterFactory);
 
     m_FileWriters.push_back(mitk::UnstructuredGridVtkWriter<vtkUnstructuredGridWriter>::New().GetPointer());
     m_FileWriters.push_back(mitk::UnstructuredGridVtkWriter<vtkXMLUnstructuredGridWriter>::New().GetPointer());
     m_FileWriters.push_back(mitk::UnstructuredGridVtkWriter<vtkXMLPUnstructuredGridWriter>::New().GetPointer());
 
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 }
 
 mitk::IOExtObjectFactory::~IOExtObjectFactory()
 {
   itk::ObjectFactoryBase::UnRegisterFactory(m_ParRecFileIOFactory);
   itk::ObjectFactoryBase::UnRegisterFactory(m_StlVolumeTimeSeriesIOFactory);
   itk::ObjectFactoryBase::UnRegisterFactory(m_VtkVolumeTimeSeriesIOFactory);
 
   itk::ObjectFactoryBase::UnRegisterFactory(m_UnstructuredGridVtkWriterFactory);
 }
 
 mitk::Mapper::Pointer mitk::IOExtObjectFactory::CreateMapper(mitk::DataNode *node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper = nullptr;
   mitk::BaseData *data = node->GetData();
 
   if (id == mitk::BaseRenderer::Standard2D)
   {
     if ((dynamic_cast<Mesh *>(data) != nullptr))
     {
       newMapper = mitk::MeshMapper2D::New();
       newMapper->SetDataNode(node);
     }
     else if ((dynamic_cast<UnstructuredGrid *>(data) != nullptr))
     {
       newMapper = mitk::VtkGLMapperWrapper::New(mitk::UnstructuredGridMapper2D::New().GetPointer());
       newMapper->SetDataNode(node);
     }
   }
   else if (id == mitk::BaseRenderer::Standard3D)
   {
     if ((dynamic_cast<Image *>(data) != nullptr) && std::string("Image").compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::VolumeMapperVtkSmart3D::New();
       newMapper->SetDataNode(node);
     }
     else if ((dynamic_cast<Mesh *>(data) != nullptr))
     {
       newMapper = mitk::MeshVtkMapper3D::New();
       newMapper->SetDataNode(node);
     }
     else if ((dynamic_cast<UnstructuredGrid *>(data) != nullptr))
     {
       newMapper = mitk::UnstructuredGridVtkMapper3D::New();
       newMapper->SetDataNode(node);
     }
   }
   return newMapper;
 }
 
 void mitk::IOExtObjectFactory::SetDefaultProperties(mitk::DataNode *node)
 {
   if (node == nullptr)
     return;
 
   mitk::DataNode::Pointer nodePointer = node;
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(node->GetData());
   if (image.IsNotNull() && image->IsInitialized())
   {
     mitk::VolumeMapperVtkSmart3D::SetDefaultProperties(node);
   }
 
   if (dynamic_cast<mitk::UnstructuredGrid *>(node->GetData()))
   {
     mitk::UnstructuredGridVtkMapper3D::SetDefaultProperties(node);
   }
 }
 
-const char *mitk::IOExtObjectFactory::GetFileExtensions()
+std::string mitk::IOExtObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::IOExtObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::IOExtObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::IOExtObjectFactory::CreateFileExtensionsMap()
 {
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtu", "VTK Unstructured Grid"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "VTK Unstructured Grid"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pvtu", "VTK Unstructured Grid"));
 
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.pvtu", "VTK Parallel XML Unstructured Grid"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtu", "VTK XML Unstructured Grid"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "VTK Legacy Unstructured Grid"));
 }
 
-const char *mitk::IOExtObjectFactory::GetSaveFileExtensions()
+std::string mitk::IOExtObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 struct RegisterIOExtObjectFactory
 {
   RegisterIOExtObjectFactory() : m_Factory(mitk::IOExtObjectFactory::New())
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(m_Factory);
   }
 
   ~RegisterIOExtObjectFactory() { mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory(m_Factory); }
   mitk::IOExtObjectFactory::Pointer m_Factory;
 };
 
 static RegisterIOExtObjectFactory registerIOExtObjectFactory;
diff --git a/Modules/IOExt/Internal/mitkIOExtObjectFactory.h b/Modules/IOExt/Internal/mitkIOExtObjectFactory.h
index 3ac2264d7f..f9c7bd0a80 100644
--- a/Modules/IOExt/Internal/mitkIOExtObjectFactory.h
+++ b/Modules/IOExt/Internal/mitkIOExtObjectFactory.h
@@ -1,51 +1,51 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef COREEXTOBJECTFACTORY_H_INCLUDED
 #define COREEXTOBJECTFACTORY_H_INCLUDED
 
 #include "mitkCoreObjectFactoryBase.h"
 
 namespace mitk
 {
   class IOExtObjectFactory : public CoreObjectFactoryBase
   {
   public:
     mitkClassMacro(IOExtObjectFactory, CoreObjectFactoryBase);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       Mapper::Pointer CreateMapper(mitk::DataNode *node, MapperSlotId slotId) override;
     void SetDefaultProperties(mitk::DataNode *node) override;
-    const char *GetFileExtensions() override;
+    std::string GetFileExtensions() override;
     mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap() override;
-    const char *GetSaveFileExtensions() override;
+    std::string GetSaveFileExtensions() override;
     mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap() override;
 
   private:
     IOExtObjectFactory();
     ~IOExtObjectFactory() override;
 
     void CreateFileExtensionsMap();
     MultimapType m_FileExtensionsMap;
     MultimapType m_SaveFileExtensionsMap;
 
     itk::ObjectFactoryBase::Pointer m_ParRecFileIOFactory;
     itk::ObjectFactoryBase::Pointer m_VtkUnstructuredGridIOFactory;
     itk::ObjectFactoryBase::Pointer m_StlVolumeTimeSeriesIOFactory;
     itk::ObjectFactoryBase::Pointer m_VtkVolumeTimeSeriesIOFactory;
 
     itk::ObjectFactoryBase::Pointer m_UnstructuredGridVtkWriterFactory;
   };
 }
 
 #endif
diff --git a/Modules/MatchPointRegistration/mitkMAPRegistrationWrapperObjectFactory.cpp b/Modules/MatchPointRegistration/mitkMAPRegistrationWrapperObjectFactory.cpp
index a76440f531..b63be757e4 100644
--- a/Modules/MatchPointRegistration/mitkMAPRegistrationWrapperObjectFactory.cpp
+++ b/Modules/MatchPointRegistration/mitkMAPRegistrationWrapperObjectFactory.cpp
@@ -1,123 +1,123 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkMAPRegistrationWrapperObjectFactory.h"
 
 #include <mitkProperties.h>
 #include <mitkBaseRenderer.h>
 #include <mitkDataNode.h>
 
 #include "mitkRegistrationWrapperMapper2D.h"
 #include "mitkRegistrationWrapperMapper3D.h"
 #include "mitkMAPRegistrationWrapper.h"
 
 typedef std::multimap<std::string, std::string> MultimapType;
 
 mitk::MAPRegistrationWrapperObjectFactory::MAPRegistrationWrapperObjectFactory()
 : CoreObjectFactoryBase()
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     alreadyDone = true;
   }
 
 }
 
 mitk::MAPRegistrationWrapperObjectFactory::~MAPRegistrationWrapperObjectFactory()
 {
 }
 
 mitk::Mapper::Pointer
 mitk::MAPRegistrationWrapperObjectFactory::
 CreateMapper(mitk::DataNode* node, MapperSlotId slotId)
 {
     mitk::Mapper::Pointer newMapper=nullptr;
 
     if ( slotId == mitk::BaseRenderer::Standard2D )
     {
         std::string classname("MAPRegistrationWrapper");
         if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
         {
           newMapper = mitk::MITKRegistrationWrapperMapper2D::New();
           newMapper->SetDataNode(node);
         }
     }
     else if ( slotId == mitk::BaseRenderer::Standard3D )
     {
       std::string classname("MAPRegistrationWrapper");
       if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
       {
         newMapper = mitk::MITKRegistrationWrapperMapper3D::New();
         newMapper->SetDataNode(node);
       }
     }
 
     return newMapper;
 };
 
 void mitk::MAPRegistrationWrapperObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
   if(node==nullptr)
     return;
 
   mitk::DataNode::Pointer nodePointer = node;
 
   if(node->GetData() ==nullptr)
     return;
 
   if( dynamic_cast<mitk::MAPRegistrationWrapper*>(node->GetData())!=nullptr )
   {
     mitk::MITKRegistrationWrapperMapperBase::SetDefaultProperties(node);
   }
 }
 
-const char* mitk::MAPRegistrationWrapperObjectFactory::GetFileExtensions()
+std::string mitk::MAPRegistrationWrapperObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions({}, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::MAPRegistrationWrapperObjectFactory::GetFileExtensionsMap()
 {
   return {};
 }
 
-const char* mitk::MAPRegistrationWrapperObjectFactory::GetSaveFileExtensions()
+std::string mitk::MAPRegistrationWrapperObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions({}, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::MAPRegistrationWrapperObjectFactory::GetSaveFileExtensionsMap()
 {
   return {};
 }
 
 struct RegisterMAPRegistrationWrapperObjectFactoryHelper{
   RegisterMAPRegistrationWrapperObjectFactoryHelper()
     : m_Factory( mitk::MAPRegistrationWrapperObjectFactory::New() )
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory( m_Factory );
   }
 
   ~RegisterMAPRegistrationWrapperObjectFactoryHelper()
   {
     mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory( m_Factory );
   }
 
   mitk::MAPRegistrationWrapperObjectFactory::Pointer m_Factory;
 };
 
 static RegisterMAPRegistrationWrapperObjectFactoryHelper registerMITKRegistrationWrapperIOFactoryHelper;
diff --git a/Modules/MatchPointRegistration/mitkMAPRegistrationWrapperObjectFactory.h b/Modules/MatchPointRegistration/mitkMAPRegistrationWrapperObjectFactory.h
index 79f9a88e16..2d01634581 100644
--- a/Modules/MatchPointRegistration/mitkMAPRegistrationWrapperObjectFactory.h
+++ b/Modules/MatchPointRegistration/mitkMAPRegistrationWrapperObjectFactory.h
@@ -1,58 +1,58 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef __mitkMAPRegistrationWrapperObjectFactory_h
 #define __mitkMAPRegistrationWrapperObjectFactory_h
 
 #include <mitkCoreObjectFactory.h>
 #include "MitkMatchPointRegistrationExports.h"
 
 namespace mitk {
 
 class MAPRegistrationWrapperObjectFactory : public mitk::CoreObjectFactoryBase
 {
   public:
     mitkClassMacro(MAPRegistrationWrapperObjectFactory,CoreObjectFactoryBase);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     ~MAPRegistrationWrapperObjectFactory() override;
 
     void SetDefaultProperties(mitk::DataNode* node) override;
 
     /**
      * @deprecatedSince{2014_10} See mitk::FileWriterRegistry and QmitkIOUtil
      */
-    DEPRECATED(virtual const char* GetFileExtensions());
+    DEPRECATED(virtual std::string GetFileExtensions());
     /**
      * @deprecatedSince{2014_10} See mitk::FileWriterRegistry and QmitkIOUtil
      */
     DEPRECATED(virtual mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap());
     /**
      * @deprecatedSince{2014_10} See mitk::FileWriterRegistry and QmitkIOUtil
      */
-    DEPRECATED(virtual const char* GetSaveFileExtensions());
+    DEPRECATED(virtual std::string GetSaveFileExtensions());
     /**
      * @deprecatedSince{2014_10} See mitk::FileWriterRegistry and QmitkIOUtil
      */
     DEPRECATED(virtual mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap());
 
     mitk::Mapper::Pointer CreateMapper(mitk::DataNode* node, MapperSlotId slotId) override;
 
   protected:
     MAPRegistrationWrapperObjectFactory();
 };
 
 }
 
 #endif
diff --git a/Modules/MatchPointRegistration/mitkRegEvaluationObjectFactory.cpp b/Modules/MatchPointRegistration/mitkRegEvaluationObjectFactory.cpp
index a5b59f1363..9f32e5abe6 100644
--- a/Modules/MatchPointRegistration/mitkRegEvaluationObjectFactory.cpp
+++ b/Modules/MatchPointRegistration/mitkRegEvaluationObjectFactory.cpp
@@ -1,103 +1,103 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkRegEvaluationObjectFactory.h"
 
 #include <mitkProperties.h>
 #include <mitkBaseRenderer.h>
 #include <mitkDataNode.h>
 
 #include "mitkRegEvaluationMapper2D.h"
 
 typedef std::multimap<std::string, std::string> MultimapType;
 
 mitk::RegEvaluationObjectFactory::RegEvaluationObjectFactory()
 : CoreObjectFactoryBase()
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     alreadyDone = true;
   }
 
 }
 
 mitk::RegEvaluationObjectFactory::~RegEvaluationObjectFactory()
 {
 }
 
 mitk::Mapper::Pointer
 mitk::RegEvaluationObjectFactory::
 CreateMapper(mitk::DataNode* node, MapperSlotId slotId)
 {
     mitk::Mapper::Pointer newMapper = nullptr;
 
     if ( slotId == mitk::BaseRenderer::Standard2D )
     {
         std::string classname("RegEvaluationObject");
         if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
         {
           newMapper = mitk::RegEvaluationMapper2D::New();
           newMapper->SetDataNode(node);
         }
     }
 
     return newMapper;
 };
 
 void mitk::RegEvaluationObjectFactory::SetDefaultProperties(mitk::DataNode*)
 {
 
 }
 
-const char* mitk::RegEvaluationObjectFactory::GetFileExtensions()
+std::string mitk::RegEvaluationObjectFactory::GetFileExtensions()
 {
   //return empty (dummy) extension string
   return m_FileExtensions.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::RegEvaluationObjectFactory::GetFileExtensionsMap()
 {
   return mitk::CoreObjectFactoryBase::MultimapType();
 }
 
-const char* mitk::RegEvaluationObjectFactory::GetSaveFileExtensions()
+std::string mitk::RegEvaluationObjectFactory::GetSaveFileExtensions()
 {
   //return empty (dummy) extension string
   return m_FileExtensions.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::RegEvaluationObjectFactory::GetSaveFileExtensionsMap()
 {
   return mitk::CoreObjectFactoryBase::MultimapType();
 }
 
 void mitk::RegEvaluationObjectFactory::RegisterIOFactories()
 {
 }
 
 struct RegisterRegEvaluationObjectFactoryHelper{
   RegisterRegEvaluationObjectFactoryHelper()
     : m_Factory( mitk::RegEvaluationObjectFactory::New() )
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory( m_Factory );
   }
 
   ~RegisterRegEvaluationObjectFactoryHelper()
   {
     mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory( m_Factory );
   }
 
   mitk::RegEvaluationObjectFactory::Pointer m_Factory;
 };
 
 static RegisterRegEvaluationObjectFactoryHelper registerMITKRegistrationWrapperIOFactoryHelper;
diff --git a/Modules/MatchPointRegistration/mitkRegEvaluationObjectFactory.h b/Modules/MatchPointRegistration/mitkRegEvaluationObjectFactory.h
index b7448303ae..0064aae384 100644
--- a/Modules/MatchPointRegistration/mitkRegEvaluationObjectFactory.h
+++ b/Modules/MatchPointRegistration/mitkRegEvaluationObjectFactory.h
@@ -1,45 +1,45 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef __MITKRegEvaluationObjectFactory_h
 #define __MITKRegEvaluationObjectFactory_h
 
 #include <mitkCoreObjectFactory.h>
 #include "MitkMatchPointRegistrationExports.h"
 
 namespace mitk {
 
   /** Factory that registers everything (the mapper) needed for handling
    RegEvaluationObject instances in MITK.*/
   class RegEvaluationObjectFactory : public mitk::CoreObjectFactoryBase
   {
   public:
     mitkClassMacro(RegEvaluationObjectFactory,CoreObjectFactoryBase);
     itkNewMacro(RegEvaluationObjectFactory);
 
     ~RegEvaluationObjectFactory() override;
 
     void SetDefaultProperties(mitk::DataNode* node) override;
-    const char* GetFileExtensions() override;
+    std::string GetFileExtensions() override;
     mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap() override;
-    const char* GetSaveFileExtensions() override;
+    std::string GetSaveFileExtensions() override;
     mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap() override;
     mitk::Mapper::Pointer CreateMapper(mitk::DataNode* node, MapperSlotId slotId) override;
     void RegisterIOFactories();
   protected:
     std::string m_FileExtensions;
     RegEvaluationObjectFactory();
   };
 
 }
 
 #endif
diff --git a/Modules/Multilabel/mitkMultilabelObjectFactory.cpp b/Modules/Multilabel/mitkMultilabelObjectFactory.cpp
index 6bce2dc1d8..03be75a0e8 100644
--- a/Modules/Multilabel/mitkMultilabelObjectFactory.cpp
+++ b/Modules/Multilabel/mitkMultilabelObjectFactory.cpp
@@ -1,124 +1,124 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkMultilabelObjectFactory.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include <mitkCoreServices.h>
 #include <mitkIPropertyFilters.h>
 #include <mitkLabelSetImageVtkMapper2D.h>
 #include <mitkPropertyFilter.h>
 
 mitk::MultilabelObjectFactory::MultilabelObjectFactory() : CoreObjectFactoryBase()
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "MultilabelObjectFactory c'tor" << std::endl;
 
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 }
 
 mitk::MultilabelObjectFactory::~MultilabelObjectFactory()
 {
 }
 
 mitk::Mapper::Pointer mitk::MultilabelObjectFactory::CreateMapper(mitk::DataNode *node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper = nullptr;
   mitk::BaseData *data = node->GetData();
 
   if (id == mitk::BaseRenderer::Standard2D)
   {
     if ((dynamic_cast<mitk::LabelSetImage *>(data) != nullptr))
     {
       newMapper = mitk::LabelSetImageVtkMapper2D::New();
       newMapper->SetDataNode(node);
     }
   }
   return newMapper;
 }
 
 void mitk::MultilabelObjectFactory::SetDefaultProperties(mitk::DataNode *node)
 {
   if (node == nullptr)
     return;
 
   if (node->GetData() == nullptr)
     return;
 
   if (dynamic_cast<LabelSetImage *>(node->GetData()) != nullptr)
   {
     mitk::LabelSetImageVtkMapper2D::SetDefaultProperties(node);
 
     auto propertyFilters = CoreServices::GetPropertyFilters();
 
     if (propertyFilters != nullptr)
     {
       PropertyFilter labelSetImageFilter;
       labelSetImageFilter.AddEntry("binaryimage.hoveringannotationcolor", PropertyFilter::Blacklist);
       labelSetImageFilter.AddEntry("binaryimage.hoveringcolor", PropertyFilter::Blacklist);
       labelSetImageFilter.AddEntry("binaryimage.selectedannotationcolor", PropertyFilter::Blacklist);
       labelSetImageFilter.AddEntry("binaryimage.selectedcolor", PropertyFilter::Blacklist);
       labelSetImageFilter.AddEntry("outline binary shadow color", PropertyFilter::Blacklist);
 
       propertyFilters->AddFilter(labelSetImageFilter, "LabelSetImage");
     }
   }
 }
 
-const char *mitk::MultilabelObjectFactory::GetFileExtensions()
+std::string mitk::MultilabelObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions({}, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::MultilabelObjectFactory::GetFileExtensionsMap()
 {
   return {};
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::MultilabelObjectFactory::GetSaveFileExtensionsMap()
 {
   return {};
 }
 
 void mitk::MultilabelObjectFactory::CreateFileExtensionsMap()
 {
 }
 
-const char *mitk::MultilabelObjectFactory::GetSaveFileExtensions()
+std::string mitk::MultilabelObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions({}, fileExtension);
   return fileExtension.c_str();
 }
 
 struct RegisterMultilabelObjectFactory
 {
   RegisterMultilabelObjectFactory() : m_Factory(mitk::MultilabelObjectFactory::New())
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(m_Factory);
   }
 
   ~RegisterMultilabelObjectFactory() { mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory(m_Factory); }
   mitk::MultilabelObjectFactory::Pointer m_Factory;
 };
 
 static RegisterMultilabelObjectFactory registerMultilabelObjectFactory;
diff --git a/Modules/Multilabel/mitkMultilabelObjectFactory.h b/Modules/Multilabel/mitkMultilabelObjectFactory.h
index 2631cf6500..cb8e084500 100644
--- a/Modules/Multilabel/mitkMultilabelObjectFactory.h
+++ b/Modules/Multilabel/mitkMultilabelObjectFactory.h
@@ -1,42 +1,42 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MULTILABELOBJECTFACTORY_H_INCLUDED
 #define MULTILABELOBJECTFACTORY_H_INCLUDED
 
 #include "mitkCoreObjectFactoryBase.h"
 
 #include <mitkAbstractFileIO.h>
 
 namespace mitk
 {
   class MultilabelObjectFactory : public CoreObjectFactoryBase
   {
   public:
     mitkClassMacro(MultilabelObjectFactory, CoreObjectFactoryBase);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self) Mapper::Pointer
       CreateMapper(mitk::DataNode *node, MapperSlotId slotId) override;
     void SetDefaultProperties(mitk::DataNode *node) override;
-    const char *GetFileExtensions() override;
+    std::string GetFileExtensions() override;
     mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap() override;
-    const char *GetSaveFileExtensions() override;
+    std::string GetSaveFileExtensions() override;
     mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap() override;
 
   protected:
     MultilabelObjectFactory();
     ~MultilabelObjectFactory() override;
     void CreateFileExtensionsMap();
   };
 }
 
 #endif
diff --git a/Modules/PlanarFigure/include/mitkPlanarFigureObjectFactory.h b/Modules/PlanarFigure/include/mitkPlanarFigureObjectFactory.h
index 5bfb6260bb..801f233cc8 100644
--- a/Modules/PlanarFigure/include/mitkPlanarFigureObjectFactory.h
+++ b/Modules/PlanarFigure/include/mitkPlanarFigureObjectFactory.h
@@ -1,48 +1,48 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef PLANARFIGUREOBJECTFACTORY_H_INCLUDED
 #define PLANARFIGUREOBJECTFACTORY_H_INCLUDED
 
 #include "mitkCoreObjectFactoryBase.h"
 #include <MitkPlanarFigureExports.h>
 
 namespace mitk
 {
   class MITKPLANARFIGURE_EXPORT PlanarFigureObjectFactory : public CoreObjectFactoryBase
   {
   public:
     mitkClassMacro(PlanarFigureObjectFactory, CoreObjectFactoryBase);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       ~PlanarFigureObjectFactory() override;
 
     Mapper::Pointer CreateMapper(mitk::DataNode *node, MapperSlotId slotId) override;
 
     void SetDefaultProperties(mitk::DataNode *node) override;
 
-    const char *GetFileExtensions() override;
+    std::string GetFileExtensions() override;
 
     mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap() override;
 
-    const char *GetSaveFileExtensions() override;
+    std::string GetSaveFileExtensions() override;
 
     mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap() override;
 
   protected:
     PlanarFigureObjectFactory();
     void CreateFileExtensionsMap();
   };
 }
 
 #endif // PLANARFIGUREOBJECTFACTORY_H_INCLUDED
diff --git a/Modules/PlanarFigure/src/Algorithms/mitkPlanarFigureObjectFactory.cpp b/Modules/PlanarFigure/src/Algorithms/mitkPlanarFigureObjectFactory.cpp
index 6ab9c276c3..09f10501a6 100644
--- a/Modules/PlanarFigure/src/Algorithms/mitkPlanarFigureObjectFactory.cpp
+++ b/Modules/PlanarFigure/src/Algorithms/mitkPlanarFigureObjectFactory.cpp
@@ -1,117 +1,117 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkPlanarFigureObjectFactory.h"
 
 #include "mitkCoreObjectFactory.h"
 
 #include "mitkPlanarFigure.h"
 #include "mitkPlanarFigureMapper2D.h"
 #include "mitkPlanarFigureVtkMapper3D.h"
 #include "mitkVtkGLMapperWrapper.h"
 
 typedef std::multimap<std::string, std::string> MultimapType;
 
 mitk::PlanarFigureObjectFactory::PlanarFigureObjectFactory()
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 }
 
 mitk::PlanarFigureObjectFactory::~PlanarFigureObjectFactory()
 {
 }
 
 mitk::Mapper::Pointer mitk::PlanarFigureObjectFactory::CreateMapper(mitk::DataNode *node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper = nullptr;
   mitk::BaseData *data = node->GetData();
 
   if (dynamic_cast<PlanarFigure *>(data) != nullptr)
   {
     if (id == mitk::BaseRenderer::Standard2D)
     {
       newMapper = mitk::PlanarFigureMapper2D::New();
       newMapper->SetDataNode(node);
     }
     else if (id == mitk::BaseRenderer::Standard3D)
     {
       newMapper = mitk::PlanarFigureVtkMapper3D::New();
       newMapper->SetDataNode(node);
     }
   }
 
   return newMapper;
 }
 
 void mitk::PlanarFigureObjectFactory::SetDefaultProperties(mitk::DataNode *node)
 {
   if (node == nullptr)
   {
     return;
   }
 
   mitk::DataNode::Pointer nodePointer = node;
 
   mitk::PlanarFigure::Pointer pf = dynamic_cast<mitk::PlanarFigure *>(node->GetData());
   if (pf.IsNotNull())
   {
     mitk::PlanarFigureMapper2D::SetDefaultProperties(node);
     mitk::PlanarFigureVtkMapper3D::SetDefaultProperties(node);
     node->AddProperty("color", mitk::ColorProperty::New(1.0, 1.0, 1.0), nullptr, true);
     node->AddProperty("opacity", mitk::FloatProperty::New(0.8), nullptr, true);
   }
 }
 
-const char *mitk::PlanarFigureObjectFactory::GetFileExtensions()
+std::string mitk::PlanarFigureObjectFactory::GetFileExtensions()
 {
   return "";
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::PlanarFigureObjectFactory::GetFileExtensionsMap()
 {
   return {};
 }
 
-const char *mitk::PlanarFigureObjectFactory::GetSaveFileExtensions()
+std::string mitk::PlanarFigureObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions({}, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::PlanarFigureObjectFactory::GetSaveFileExtensionsMap()
 {
   return {};
 }
 
 void mitk::PlanarFigureObjectFactory::CreateFileExtensionsMap()
 {
 }
 
 struct RegisterPlanarFigureObjectFactory
 {
   RegisterPlanarFigureObjectFactory() : m_Factory(mitk::PlanarFigureObjectFactory::New())
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(m_Factory);
   }
 
   ~RegisterPlanarFigureObjectFactory() { mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory(m_Factory); }
   mitk::PlanarFigureObjectFactory::Pointer m_Factory;
 };
 
 static RegisterPlanarFigureObjectFactory registerPlanarFigureObjectFactory;
diff --git a/Modules/Segmentation/Algorithms/mitkSegmentationObjectFactory.cpp b/Modules/Segmentation/Algorithms/mitkSegmentationObjectFactory.cpp
index 84ef4cb83e..9ae4041a66 100644
--- a/Modules/Segmentation/Algorithms/mitkSegmentationObjectFactory.cpp
+++ b/Modules/Segmentation/Algorithms/mitkSegmentationObjectFactory.cpp
@@ -1,138 +1,138 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkSegmentationObjectFactory.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 
 #include "mitkContour.h"
 #include "mitkContourMapper2D.h"
 #include "mitkContourSetMapper2D.h"
 #include "mitkContourSetVtkMapper3D.h"
 #include "mitkContourVtkMapper3D.h"
 
 #include <mitkVtkGLMapperWrapper.h>
 
 mitk::SegmentationObjectFactory::SegmentationObjectFactory() : CoreObjectFactoryBase()
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "SegmentationObjectFactory c'tor" << std::endl;
 
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 }
 
 mitk::Mapper::Pointer mitk::SegmentationObjectFactory::CreateMapper(mitk::DataNode *node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper = nullptr;
   mitk::BaseData *data = node->GetData();
 
   if (id == mitk::BaseRenderer::Standard2D)
   {
     std::string classname("ContourModel");
     if (dynamic_cast<mitk::Contour *>(node->GetData()) != nullptr)
     {
       newMapper = mitk::ContourMapper2D::New();
       newMapper->SetDataNode(node);
     }
     else if (dynamic_cast<mitk::ContourSet *>(node->GetData()) != nullptr)
     {
       newMapper = mitk::ContourSetMapper2D::New();
       newMapper->SetDataNode(node);
     }
   }
   else if (id == mitk::BaseRenderer::Standard3D)
   {
     if ((dynamic_cast<Contour *>(data) != nullptr))
     {
       newMapper = mitk::ContourVtkMapper3D::New();
       newMapper->SetDataNode(node);
     }
     else if ((dynamic_cast<ContourSet *>(data) != nullptr))
     {
       newMapper = mitk::ContourSetVtkMapper3D::New();
       newMapper->SetDataNode(node);
     }
   }
   return newMapper;
 }
 
 void mitk::SegmentationObjectFactory::SetDefaultProperties(mitk::DataNode *node)
 {
   if (node == nullptr)
     return;
 
   mitk::DataNode::Pointer nodePointer = node;
 
   //  mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   //  if(image.IsNotNull() && image->IsInitialized())
   //  {
   //    mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   //  }
   //
   //  if (dynamic_cast<mitk::UnstructuredGrid*>(node->GetData()))
   //  {
   //    mitk::UnstructuredGridVtkMapper3D::SetDefaultProperties(node);
   //  }
 }
 
-const char *mitk::SegmentationObjectFactory::GetFileExtensions()
+std::string mitk::SegmentationObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::SegmentationObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::SegmentationObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::SegmentationObjectFactory::CreateFileExtensionsMap()
 {
 }
 
-const char *mitk::SegmentationObjectFactory::GetSaveFileExtensions()
+std::string mitk::SegmentationObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 void mitk::SegmentationObjectFactory::RegisterIOFactories()
 {
 }
 
 struct RegisterSegmentationObjectFactory
 {
   RegisterSegmentationObjectFactory() : m_Factory(mitk::SegmentationObjectFactory::New())
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(m_Factory);
   }
 
   ~RegisterSegmentationObjectFactory() { mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory(m_Factory); }
   mitk::SegmentationObjectFactory::Pointer m_Factory;
 };
 
 static RegisterSegmentationObjectFactory registerSegmentationObjectFactory;
diff --git a/Modules/Segmentation/Algorithms/mitkSegmentationObjectFactory.h b/Modules/Segmentation/Algorithms/mitkSegmentationObjectFactory.h
index f204a8d24b..cbb5031bb6 100644
--- a/Modules/Segmentation/Algorithms/mitkSegmentationObjectFactory.h
+++ b/Modules/Segmentation/Algorithms/mitkSegmentationObjectFactory.h
@@ -1,43 +1,43 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef SEGMENTATIONOBJECTFACTORY_H_INCLUDED
 #define SEGMENTATIONOBJECTFACTORY_H_INCLUDED
 
 #include "mitkCoreObjectFactoryBase.h"
 #include <MitkSegmentationExports.h>
 
 namespace mitk
 {
   class MITKSEGMENTATION_EXPORT SegmentationObjectFactory : public CoreObjectFactoryBase
   {
   public:
     mitkClassMacro(SegmentationObjectFactory, CoreObjectFactoryBase);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self) Mapper::Pointer
       CreateMapper(mitk::DataNode *node, MapperSlotId slotId) override;
     void SetDefaultProperties(mitk::DataNode *node) override;
-    const char *GetFileExtensions() override;
+    std::string GetFileExtensions() override;
     mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap() override;
-    const char *GetSaveFileExtensions() override;
+    std::string GetSaveFileExtensions() override;
     mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap() override;
     void RegisterIOFactories();
 
   protected:
     SegmentationObjectFactory();
     void CreateFileExtensionsMap();
     MultimapType m_FileExtensionsMap;
     MultimapType m_SaveFileExtensionsMap;
   };
 }
 
 #endif
diff --git a/Modules/TubeGraph/include/mitkTubeGraphObjectFactory.h b/Modules/TubeGraph/include/mitkTubeGraphObjectFactory.h
index 5bca4067c6..62ed773840 100644
--- a/Modules/TubeGraph/include/mitkTubeGraphObjectFactory.h
+++ b/Modules/TubeGraph/include/mitkTubeGraphObjectFactory.h
@@ -1,51 +1,51 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef TubeGraphObjectFactory_H_INCLUDED
 #define TubeGraphObjectFactory_H_INCLUDED
 
 #include <MitkTubeGraphExports.h>
 
 #include <mitkCoreObjectFactory.h>
 
 namespace mitk
 {
   class MITKTUBEGRAPH_EXPORT TubeGraphObjectFactory : public CoreObjectFactoryBase
   {
   public:
     mitkClassMacro(TubeGraphObjectFactory, CoreObjectFactoryBase);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       Mapper::Pointer CreateMapper(mitk::DataNode *node, MapperSlotId slotId) override;
     void SetDefaultProperties(mitk::DataNode *node) override;
-    const char *GetFileExtensions() override;
+    std::string GetFileExtensions() override;
     mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap() override;
-    const char *GetSaveFileExtensions() override;
+    std::string GetSaveFileExtensions() override;
     mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap() override;
     void RegisterIOFactories();
 
   protected:
     TubeGraphObjectFactory();
 
   private:
     void CreateFileExtensionsMap();
 
     std::string m_ExternalFileExtensions;
     std::string m_InternalFileExtensions;
     std::string m_SaveFileExtensions;
     MultimapType m_FileExtensionsMap;
     MultimapType m_SaveFileExtensionsMap;
   };
 }
 
 #endif
diff --git a/Modules/TubeGraph/src/IO/mitkTubeGraphObjectFactory.cpp b/Modules/TubeGraph/src/IO/mitkTubeGraphObjectFactory.cpp
index a2263df2ad..7165d1b8a3 100644
--- a/Modules/TubeGraph/src/IO/mitkTubeGraphObjectFactory.cpp
+++ b/Modules/TubeGraph/src/IO/mitkTubeGraphObjectFactory.cpp
@@ -1,97 +1,97 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkTubeGraphObjectFactory.h"
 
 #include <mitkBaseRenderer.h>
 #include <mitkDataNode.h>
 #include <mitkProperties.h>
 
 #include "mitkTubeGraph.h"
 #include "mitkTubeGraphVtkMapper3D.h"
 
 mitk::TubeGraphObjectFactory::TubeGraphObjectFactory() : CoreObjectFactoryBase()
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_INFO << "TubeGraphObjectFactory c'tor" << std::endl;
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 }
 
 mitk::Mapper::Pointer mitk::TubeGraphObjectFactory::CreateMapper(mitk::DataNode *node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper = nullptr;
 
   if (id == mitk::BaseRenderer::Standard3D)
   {
     if ((dynamic_cast<mitk::TubeGraph *>(node->GetData()) != nullptr))
     {
       newMapper = mitk::TubeGraphVtkMapper3D::New();
       newMapper->SetDataNode(node);
     }
   }
 
   return newMapper;
 }
 
 void mitk::TubeGraphObjectFactory::SetDefaultProperties(mitk::DataNode *node)
 {
   if ((dynamic_cast<mitk::TubeGraph *>(node->GetData()) != nullptr))
   {
     node->SetProperty("Tube Graph.Clip Structures", mitk::BoolProperty::New(false));
     mitk::TubeGraphVtkMapper3D::SetDefaultProperties(node);
   }
 }
 
-const char *mitk::TubeGraphObjectFactory::GetFileExtensions()
+std::string mitk::TubeGraphObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::TubeGraphObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
-const char *mitk::TubeGraphObjectFactory::GetSaveFileExtensions()
+std::string mitk::TubeGraphObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::TubeGraphObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::TubeGraphObjectFactory::CreateFileExtensionsMap()
 {
 }
 
 struct RegisterTubeGraphObjectFactory
 {
   RegisterTubeGraphObjectFactory() : m_Factory(mitk::TubeGraphObjectFactory::New())
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(m_Factory);
   }
   ~RegisterTubeGraphObjectFactory() { mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory(m_Factory); }
   mitk::TubeGraphObjectFactory::Pointer m_Factory;
 };
 
 static RegisterTubeGraphObjectFactory registerTubeGraphObjectFactory;
diff --git a/Plugins/org.mitk.gui.qt.chartExample/src/internal/QmitkChartExampleView.cpp b/Plugins/org.mitk.gui.qt.chartExample/src/internal/QmitkChartExampleView.cpp
index 89d9282182..1adeb0b41b 100644
--- a/Plugins/org.mitk.gui.qt.chartExample/src/internal/QmitkChartExampleView.cpp
+++ b/Plugins/org.mitk.gui.qt.chartExample/src/internal/QmitkChartExampleView.cpp
@@ -1,452 +1,452 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // Blueberry
 #include <berryIQtStyleManager.h>
 #include <berryWorkbenchPlugin.h>
 
 // Qmitk
 #include "QmitkChartExampleView.h"
 #include <QmitkChartxyData.h>
 
 const std::string QmitkChartExampleView::VIEW_ID = "org.mitk.views.qmitkchartexample";
 
 void QmitkChartExampleView::SetFocus()
 {
   m_Controls.m_buttonCreateChart->setFocus();
 }
 
 void QmitkChartExampleView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   CreateConnectionsForGUIElements();
   connect(m_Controls.m_comboBoxChartType, &QComboBox::currentTextChanged, this, &QmitkChartExampleView::AdaptDataGUI);
 
   m_Controls.m_lineEditDataXVector->setText("0;1;2;3;4;5;6;7;8;9");
   m_Controls.m_lineEditDataYVector->setText("0;1;2;3;4;5;6;7;8;9");
   m_Controls.m_lineEditDataLabel->setText("Test");
   m_Controls.m_lineEditXAxisLabel->setText("X-Axis");
   m_Controls.m_lineEditYAxisLabel->setText("Y-Axis");
   m_Controls.m_lineEditTitle->setText("Title");
 
   m_Controls.m_labelPieData->setVisible(false);
   m_Controls.m_lineEditPieDataLabel->setVisible(false);
 
   m_Controls.m_groupBoxErrors->setVisible(false);
   m_Controls.m_groupBoxXErrors->setVisible(false);
   m_Controls.m_groupBoxYErrors->setVisible(false);
 
   m_Controls.m_doubleSpinBox_maxZoomX->setValue(10);
   m_Controls.m_doubleSpinBox_maxZoomY->setValue(10);
 
   m_AxisScaleNameToAxisScaleType.emplace("linear", QmitkChartWidget::AxisScale::linear);
   m_AxisScaleNameToAxisScaleType.emplace("logarithmic", QmitkChartWidget::AxisScale::log);
 
   m_LegendPositionNameToLegendPositionType.emplace("bottom middle", QmitkChartWidget::LegendPosition::bottomMiddle);
   m_LegendPositionNameToLegendPositionType.emplace("bottom right", QmitkChartWidget::LegendPosition::bottomRight);
   m_LegendPositionNameToLegendPositionType.emplace("top right", QmitkChartWidget::LegendPosition::topRight);
   m_LegendPositionNameToLegendPositionType.emplace("top left", QmitkChartWidget::LegendPosition::topLeft);
   m_LegendPositionNameToLegendPositionType.emplace("middle right", QmitkChartWidget::LegendPosition::middleRight);
 }
 
 void QmitkChartExampleView::CreateConnectionsForGUIElements()
 {
   connect(m_Controls.m_buttonCreateChart, &QPushButton::clicked, this, &QmitkChartExampleView::CreateChart);
   connect(m_Controls.m_buttonUpdateData, &QPushButton::clicked, this, &QmitkChartExampleView::UpdateData);
   connect(m_Controls.m_buttonClearChart, &QPushButton::clicked, this, &QmitkChartExampleView::ClearChart);
   connect(m_Controls.m_buttonAddData, &QPushButton::clicked, this, &QmitkChartExampleView::AddData);
   connect(m_Controls.m_comboBoxExistingData, &QComboBox::currentTextChanged, this, &QmitkChartExampleView::UpdateSelectedData);
   connect(m_Controls.m_checkBoxEnableErrors, &QCheckBox::toggled, this, &QmitkChartExampleView::ShowErrorOptions);
   connect(m_Controls.m_checkBoxEnableXErrors, &QCheckBox::toggled, this, &QmitkChartExampleView::ShowXErrorOptions);
   connect(m_Controls.m_checkBoxEnableYErrors, &QCheckBox::toggled, this, &QmitkChartExampleView::ShowYErrorOptions);
   connect(m_Controls.m_doubleSpinBox_minZoomX, &QSpinBox::editingFinished, this, &QmitkChartExampleView::AdaptZoomX);
   connect(m_Controls.m_doubleSpinBox_maxZoomX, &QSpinBox::editingFinished, this, &QmitkChartExampleView::AdaptZoomX);
   connect(m_Controls.m_doubleSpinBox_minZoomY, &QSpinBox::editingFinished, this, &QmitkChartExampleView::AdaptZoomY);
   connect(m_Controls.m_doubleSpinBox_maxZoomY, &QSpinBox::editingFinished, this, &QmitkChartExampleView::AdaptZoomY);
   connect(m_Controls.m_comboBoxLegendPosition, &QComboBox::currentTextChanged, this, &QmitkChartExampleView::OnLegendPositionChanged);
   connect(m_Controls.m_lineEditTitle, &QLineEdit::editingFinished, this, &QmitkChartExampleView::OnTitleChanged);
   connect(m_Controls.m_lineEditXAxisLabel, &QLineEdit::editingFinished, this, &QmitkChartExampleView::OnXAxisLabelChanged);
   connect(m_Controls.m_lineEditYAxisLabel, &QLineEdit::editingFinished, this, &QmitkChartExampleView::OnYAxisLabelChanged);
   connect(m_Controls.m_comboBoxYAxisScale, &QComboBox::currentTextChanged, this, &QmitkChartExampleView::OnYAxisScaleChanged);
   connect(m_Controls.m_checkBoxShowLegend, &QCheckBox::stateChanged, this, &QmitkChartExampleView::OnShowLegendChanged);
   connect(m_Controls.m_checkBoxStackedData, &QCheckBox::stateChanged, this, &QmitkChartExampleView::OnStackedDataChanged);
   connect(m_Controls.m_checkBoxShowDataPoints, &QCheckBox::stateChanged, this, &QmitkChartExampleView::OnShowDataPointsChanged);
   connect(m_Controls.m_checkBoxShowSubchart, &QCheckBox::stateChanged, this, &QmitkChartExampleView::OnShowSubchartChanged);
 }
 
 void QmitkChartExampleView::AddData()
 {
     QString lineEditDataX = m_Controls.m_lineEditDataXVector->text();
     QString lineEditDataY = m_Controls.m_lineEditDataYVector->text();
     auto dataX = ConvertToDoubleVector(lineEditDataX);
     auto dataY = ConvertToDoubleVector(lineEditDataY);
     auto dataXandY = CreatePairList(dataX, dataY);
     QString data = QString::fromStdString(ConvertToText(dataXandY));
 
     std::string dataLabel = m_Controls.m_lineEditDataLabel->text().toStdString();
     std::string chartTypeAsString = m_Controls.m_comboBoxChartType->currentText().toStdString();
     std::string chartColorAsString = m_Controls.m_comboBoxColor->currentText().toStdString();
     std::string chartLineStyleAsString = m_Controls.m_comboBoxLineStyle->currentText().toStdString();
     std::string pieLabelsAsString = m_Controls.m_lineEditPieDataLabel->text().toStdString();
 
     if (std::find(labelStorage.begin(), labelStorage.end(), dataLabel) != labelStorage.end())
     {
         m_Controls.m_labelInfo->setText("This data already exists");
         m_Controls.m_labelInfo->setStyleSheet("color: red;");
         return;
     }
 
     if (dataX.size() != dataY.size())
     {
         m_Controls.m_labelInfo->setText("Data x and y size have to be equal");
         m_Controls.m_labelInfo->setStyleSheet("color: red;");
         return;
     }
 
     labelStorage.push_back(dataLabel);
     m_Controls.m_Chart->AddChartExampleData(dataXandY, dataLabel, chartTypeAsString, chartColorAsString, chartLineStyleAsString, pieLabelsAsString);
     m_Controls.m_comboBoxExistingData->addItem(m_Controls.m_lineEditDataLabel->text());
 
     if (m_Controls.m_checkBoxEnableErrors->isChecked())
     {
         if (m_Controls.m_checkBoxEnableXErrors->isChecked())
         {
             auto errorsPlus = ConvertToDoubleVector(m_Controls.m_lineEditXErrorPlus->text());
             auto errorsMinus = ConvertToDoubleVector(m_Controls.m_lineEditXErrorMinus->text());
             m_Controls.m_Chart->SetXErrorBars(m_Controls.m_lineEditDataLabel->text().toStdString(), errorsPlus, errorsMinus);
         }
         if (m_Controls.m_checkBoxEnableYErrors->isChecked())
         {
             auto errorsPlus = ConvertToDoubleVector(m_Controls.m_lineEditYErrorPlus->text());
             auto errorsMinus = ConvertToDoubleVector(m_Controls.m_lineEditYErrorMinus->text());
             m_Controls.m_Chart->SetYErrorBars(m_Controls.m_lineEditDataLabel->text().toStdString(), errorsPlus, errorsMinus);
         }
     }
 
     QString dataOverview;
     dataOverview.append(m_Controls.m_lineEditDataLabel->text());
     dataOverview.append("(").append(m_Controls.m_comboBoxChartType->currentText());
 
     dataOverview.append(", ").append(m_Controls.m_comboBoxLineStyle->currentText());
     dataOverview.append(")");
     dataOverview.append(":").append(data);
 
     m_Controls.m_plainTextEditDataView->appendPlainText(dataOverview);
 }
 
 void QmitkChartExampleView::CreateChart()
 {
   auto dataYAxisScaleType =
     m_AxisScaleNameToAxisScaleType.at(m_Controls.m_comboBoxYAxisScale->currentText().toStdString());
   auto xAxisLabel = m_Controls.m_lineEditXAxisLabel->text().toStdString();
   auto yAxisLabel = m_Controls.m_lineEditYAxisLabel->text().toStdString();
   auto showLegend = m_Controls.m_checkBoxShowLegend->isChecked();
   auto legendPosition =
     m_LegendPositionNameToLegendPositionType.at(m_Controls.m_comboBoxLegendPosition->currentText().toStdString());
   auto showDataPoints = m_Controls.m_checkBoxShowDataPoints->isChecked();
   auto stackedData = m_Controls.m_checkBoxStackedData->isChecked();
   auto showSubchart = m_Controls.m_checkBoxShowSubchart->isChecked();
   auto title = m_Controls.m_lineEditTitle->text().toStdString();
 
   m_Controls.m_Chart->SetTitle(title);
   m_Controls.m_Chart->SetYAxisScale(dataYAxisScaleType);
   m_Controls.m_Chart->SetXAxisLabel(xAxisLabel);
   m_Controls.m_Chart->SetYAxisLabel(yAxisLabel);
   m_Controls.m_Chart->SetShowLegend(showLegend);
   m_Controls.m_Chart->SetLegendPosition(legendPosition);
   m_Controls.m_Chart->SetShowErrorBars(true);
   m_Controls.m_Chart->SetShowDataPoints(showDataPoints);
   m_Controls.m_Chart->SetStackedData(stackedData);
   m_Controls.m_Chart->Show(showSubchart);
 }
 
 void QmitkChartExampleView::UpdateData()
 {
     if (m_Controls.m_comboBoxExistingData->currentText().isEmpty())
     {
         m_Controls.m_labelInfo->setText("Please enter a valid Datalabel");
         m_Controls.m_labelInfo->setStyleSheet("color: red;");
         return;
     }
 
     if (m_Controls.m_lineEditDataLabel->text() != m_Controls.m_comboBoxExistingData->currentText())
     {
         return;
     }
 
     QString lineEditDataX = m_Controls.m_lineEditDataXVector->text();
     QString lineEditDataY = m_Controls.m_lineEditDataYVector->text();
     auto dataX = ConvertToDoubleVector(lineEditDataX);
     auto dataY = ConvertToDoubleVector(lineEditDataY);
     auto dataXandY = CreatePairList(dataX, dataY);
     QString data = QString::fromStdString(ConvertToText(dataXandY));
 
     std::string dataLabel = m_Controls.m_lineEditDataLabel->text().toStdString();
     std::string chartTypeAsString = m_Controls.m_comboBoxChartType->currentText().toStdString();
     std::string chartColorAsString = m_Controls.m_comboBoxColor->currentText().toStdString();
     std::string chartLineStyleAsString = m_Controls.m_comboBoxLineStyle->currentText().toStdString();
     std::string pieLabelsAsString = m_Controls.m_lineEditPieDataLabel->text().toStdString();
 
     if (dataX.size() != dataY.size())
     {
         m_Controls.m_labelInfo->setText("Data x and y size have to be equal");
         m_Controls.m_labelInfo->setStyleSheet("color: red;");
         return;
     }
 
     m_Controls.m_Chart->UpdateChartExampleData(dataXandY, dataLabel, chartTypeAsString, chartColorAsString, chartLineStyleAsString, pieLabelsAsString);
 }
 
 void QmitkChartExampleView::UpdateSelectedData()
 {
     std::string label = m_Controls.m_comboBoxExistingData->currentText().toStdString();
     auto data = m_Controls.m_Chart->GetDataElementByLabel(label);
 
     if (data == nullptr)
     {
         return;
     }
 
     auto x = data->GetXData();
     auto y = data->GetYData();
 
     auto xVector = x.toVector().toStdVector();
     auto yVector = y.toVector().toStdVector();
 
     QString xString = QString::fromStdString(ConvertToText(xVector));
     QString yString = QString::fromStdString(ConvertToText(yVector));
 
     auto color = data->GetColor();
     auto type = data->GetChartType();
     auto style = data->GetLineStyle();
 
     if (type.toString() == "pie")
     {
         m_Controls.m_comboBoxLineStyle->setVisible(false);
         m_Controls.m_labelLineStyle->setVisible(false);
         m_Controls.m_lineEditPieDataLabel->setVisible(true);
         m_Controls.m_labelPieData->setVisible(true);
 
         auto pieLabelsString = ConvertToText(data->GetPieLabels());
 
         m_Controls.m_lineEditPieDataLabel->setText(QString::fromStdString(pieLabelsString));
     }
 
     else
     {
         m_Controls.m_lineEditPieDataLabel->setVisible(false);
         m_Controls.m_labelPieData->setVisible(false);
         m_Controls.m_comboBoxLineStyle->setVisible(true);
         m_Controls.m_labelLineStyle->setVisible(true);
         m_Controls.m_comboBoxLineStyle->setCurrentText(style.toString());
     }
 
     m_Controls.m_lineEditDataXVector->setText(xString);
     m_Controls.m_lineEditDataYVector->setText(yString);
     m_Controls.m_lineEditDataLabel->setText(QString::fromStdString(label));
     m_Controls.m_comboBoxColor->setCurrentText(color.toString());
     m_Controls.m_comboBoxChartType->setCurrentText(type.toString());
 }
 
 void QmitkChartExampleView::ClearChart()
 {
   m_Controls.m_Chart->Clear();
 
   m_Controls.m_plainTextEditDataView->clear();
 
   m_Controls.m_comboBoxExistingData->clear();
 
   labelStorage.clear();
 }
 
 void QmitkChartExampleView::ShowErrorOptions(bool show)
 {
   m_Controls.m_groupBoxErrors->setVisible(show);
 }
 
 void QmitkChartExampleView::ShowXErrorOptions(bool show)
 {
   m_Controls.m_groupBoxXErrors->setVisible(show);
 }
 
 void QmitkChartExampleView::ShowYErrorOptions(bool show)
 {
   m_Controls.m_groupBoxYErrors->setVisible(show);
 }
 
 void QmitkChartExampleView::AdaptZoomX()
 {
   m_Controls.m_Chart->SetMinMaxValueXView(m_Controls.m_doubleSpinBox_minZoomX->value(),
                                              m_Controls.m_doubleSpinBox_maxZoomX->value());
   m_Controls.m_Chart->Show();
 }
 
 void QmitkChartExampleView::AdaptZoomY()
 {
   m_Controls.m_Chart->SetMinMaxValueYView(m_Controls.m_doubleSpinBox_minZoomY->value(),
                                              m_Controls.m_doubleSpinBox_maxZoomY->value());
   m_Controls.m_Chart->Show();
 }
 
 void QmitkChartExampleView::AdaptDataGUI(QString chartType)
 {
   if (chartType == "pie")
   {
     m_Controls.m_labelPieData->setVisible(true);
     m_Controls.m_lineEditPieDataLabel->setVisible(true);
     m_Controls.m_labelLineStyle->setVisible(false);
     m_Controls.m_comboBoxLineStyle->setVisible(false);
   }
 
   else
   {
     m_Controls.m_labelLineStyle->setVisible(true);
     m_Controls.m_comboBoxLineStyle->setVisible(true);
     m_Controls.m_labelPieData->setVisible(false);
     m_Controls.m_lineEditPieDataLabel->setVisible(false);
   }
 }
 
 void QmitkChartExampleView::OnLegendPositionChanged(const QString &newText)
 {
   auto legendPosition = m_LegendPositionNameToLegendPositionType.at(newText.toStdString());
   m_Controls.m_Chart->SetLegendPosition(legendPosition);
 }
 
 void QmitkChartExampleView::OnTitleChanged() {
   auto newTitle = m_Controls.m_lineEditTitle->text();
   m_Controls.m_Chart->SetTitle(newTitle.toStdString());
 }
 
 void QmitkChartExampleView::OnXAxisLabelChanged() {
   auto newXAxisLabel = m_Controls.m_lineEditXAxisLabel->text();
   m_Controls.m_Chart->SetXAxisLabel(newXAxisLabel.toStdString());
 }
 
 void QmitkChartExampleView::OnYAxisLabelChanged() {
   auto newYAxisLabel = m_Controls.m_lineEditYAxisLabel->text();
   m_Controls.m_Chart->SetYAxisLabel(newYAxisLabel.toStdString());
 }
 
 void QmitkChartExampleView::OnYAxisScaleChanged(const QString &newYAxisScale) {
   auto yAxisScale = m_AxisScaleNameToAxisScaleType.at(newYAxisScale.toStdString());
   m_Controls.m_Chart->SetYAxisScale(yAxisScale);
 }
 
 void QmitkChartExampleView::OnShowLegendChanged(int newState) {
   m_Controls.m_Chart->SetShowLegend(newState == Qt::Checked);
 }
 
 void QmitkChartExampleView::OnStackedDataChanged(int newState) {
   m_Controls.m_Chart->SetStackedData(newState == Qt::Checked);
 }
 
 void QmitkChartExampleView::OnShowDataPointsChanged(int newState) {
   m_Controls.m_Chart->SetShowDataPoints(newState == Qt::Checked);
 }
 
 void QmitkChartExampleView::OnShowSubchartChanged(int newState) {
   m_Controls.m_Chart->SetShowSubchart(newState == Qt::Checked);
 }
 
 std::vector< std::pair<double, double> > QmitkChartExampleView::CreatePairList(std::vector<double> keys, std::vector<double> values) const
 {
     std::vector< std::pair<double, double> > aMap;
     std::transform(keys.begin(), keys.end(), values.begin(), std::inserter(aMap, aMap.end()), [](double a, double b) {
         return std::make_pair(a, b);
         });
     return aMap;
 }
 
 std::string QmitkChartExampleView::ConvertToText(std::vector<std::pair<double, double> > numbers, std::string delimiter) const
 {
     std::ostringstream oss;
     oss.precision(3);
 
     if (!numbers.empty())
     {
-        for (const auto keyValue : numbers)
+        for (const auto& keyValue : numbers)
         {
             oss << keyValue.first << ":" << keyValue.second << delimiter;
         }
     }
     auto aString = oss.str();
     aString.pop_back();
     return aString;
 }
 
 std::string QmitkChartExampleView::ConvertToText(std::vector<QVariant> numbers, std::string delimiter) const
 {
     std::ostringstream oss;
     oss.precision(3);
 
     if (!numbers.empty())
     {
         for (auto number : numbers)
         {
             oss << number.toDouble() << delimiter;
         }
     }
     auto aString = oss.str();
     aString.pop_back();
     return aString;
 }
 
 std::string QmitkChartExampleView::ConvertToText(QVariantList list, std::string delimiter) const
 {
     std::ostringstream oss;
 
     if (!list.isEmpty())
     {
         for (auto element : list)
         {
             oss << element.toString().toStdString() << delimiter;
         }
 
         auto aString = oss.str();
         aString.pop_back();
         return aString;
     }
 
     return "";
 }
 
 std::vector<double> QmitkChartExampleView::ConvertToDoubleVector(const QString& data, QChar delimiter) const
 {
     std::vector<double> output;
     if (data.isEmpty())
     {
         return output;
     }
 
-    for (const QString entry : data.split(delimiter))
+    for (const QString& entry : data.split(delimiter))
     {
         output.push_back(entry.toDouble());
     }
     return output;
 }
 
 std::vector<std::string> QmitkChartExampleView::ConvertToStringVector(const QString& data, QChar delimiter) const
 {
     std::vector<std::string> output;
     if (data.isEmpty())
     {
         return output;
     }
 
-    for (const QString entry : data.split(delimiter))
+    for (const QString& entry : data.split(delimiter))
     {
         output.push_back(entry.toStdString());
     }
     return output;
 }
diff --git a/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationPlugin.cpp b/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationPlugin.cpp
index dcba3917e1..11a5a20215 100644
--- a/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationPlugin.cpp
+++ b/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationPlugin.cpp
@@ -1,203 +1,203 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkFlowApplicationPlugin.h"
 #include "QmitkFlowApplication.h"
 
 #include <service/cm/ctkConfigurationAdmin.h>
 #include <service/cm/ctkConfiguration.h>
 
 #include <berryPlatform.h>
 #include <berryPlatformUI.h>
 #include <berryIPreferencesService.h>
 #include <berryIPreferences.h>
 
 #include <mitkVersion.h>
 #include <mitkLogMacros.h>
 
 #include <mitkIDataStorageService.h>
 #include <mitkSceneIO.h>
 #include <mitkProgressBar.h>
 #include <mitkRenderingManager.h>
 #include <mitkIOUtil.h>
 
 #include <QtWidgetsExtRegisterClasses.h>
 
 #include <QProcess>
 #include <QMainWindow>
 #include <QCoreApplication>
 
 
 QmitkFlowApplicationPlugin* QmitkFlowApplicationPlugin::inst = nullptr;
 
 QmitkFlowApplicationPlugin::QmitkFlowApplicationPlugin()
 {
   inst = this;
 }
 
 QmitkFlowApplicationPlugin::~QmitkFlowApplicationPlugin()
 {
 }
 
 QmitkFlowApplicationPlugin* QmitkFlowApplicationPlugin::GetDefault()
 {
   return inst;
 }
 
 void QmitkFlowApplicationPlugin::start(ctkPluginContext* context)
 {
   berry::AbstractUICTKPlugin::start(context);
 
   this->_context = context;
 
   QtWidgetsExtRegisterClasses();
 
   BERRY_REGISTER_EXTENSION_CLASS(QmitkFlowApplication, context);
 
   ctkServiceReference cmRef = context->getServiceReference<ctkConfigurationAdmin>();
   ctkConfigurationAdmin* configAdmin = nullptr;
   if (cmRef)
   {
     configAdmin = context->getService<ctkConfigurationAdmin>(cmRef);
   }
 
   // Use the CTK Configuration Admin service to configure the BlueBerry help system
   if (configAdmin)
   {
     ctkConfigurationPtr conf = configAdmin->getConfiguration("org.blueberry.services.help", QString());
     ctkDictionary helpProps;
     helpProps.insert("homePage", "qthelp://org.mitk.gui.qt.flowapplication/bundle/index.html");
     conf->update(helpProps);
     context->ungetService(cmRef);
   }
   else
   {
     MITK_WARN << "Configuration Admin service unavailable, cannot set home page url.";
   }
 
   if (qApp->metaObject()->indexOfSignal("messageReceived(QByteArray)") > -1)
   {
     connect(qApp, SIGNAL(messageReceived(QByteArray)), this, SLOT(handleIPCMessage(QByteArray)));
   }
 
   // This is a potentially long running operation.
   loadDataFromDisk(berry::Platform::GetApplicationArgs(), true);
 }
 
 void QmitkFlowApplicationPlugin::stop(ctkPluginContext* context)
 {
   Q_UNUSED(context)
 
     this->_context = nullptr;
 }
 
 ctkPluginContext* QmitkFlowApplicationPlugin::GetPluginContext() const
 {
   return _context;
 }
 
 void QmitkFlowApplicationPlugin::loadDataFromDisk(const QStringList &arguments, bool globalReinit)
 {
   if (!arguments.empty())
   {
     ctkServiceReference serviceRef = _context->getServiceReference<mitk::IDataStorageService>();
     if (serviceRef)
     {
       mitk::IDataStorageService* dataStorageService = _context->getService<mitk::IDataStorageService>(serviceRef);
       mitk::DataStorage::Pointer dataStorage = dataStorageService->GetDefaultDataStorage()->GetDataStorage();
 
       int argumentsAdded = 0;
       for (int i = 0; i < arguments.size(); ++i)
       {
         if (arguments[i].startsWith("--flow."))
         { //By convention no further files are specified as soon as a flow arguments comes.
           break;
         }
         else if (arguments[i].right(5) == ".mitk")
         {
           mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New();
 
           bool clearDataStorageFirst(false);
           mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
           dataStorage = sceneIO->LoadScene(arguments[i].toLocal8Bit().constData(), dataStorage, clearDataStorageFirst);
           mitk::ProgressBar::GetInstance()->Progress(2);
           argumentsAdded++;
         }
         else if (arguments[i].right(15) == ".mitksceneindex")
         {
           mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New();
 
           bool clearDataStorageFirst(false);
           mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
           dataStorage = sceneIO->LoadSceneUnzipped(arguments[i].toLocal8Bit().constData(), dataStorage, clearDataStorageFirst);
           mitk::ProgressBar::GetInstance()->Progress(2);
           argumentsAdded++;
         }
         else
         {
           try
           {
             const std::string path(arguments[i].toStdString());
             auto addedNodes = mitk::IOUtil::Load(path, *dataStorage);
 
-            for (auto const node : *addedNodes)
+            for (const auto& node : *addedNodes)
             {
               node->SetIntProperty("layer", argumentsAdded);
             }
 
             argumentsAdded++;
           }
           catch (...)
           {
             MITK_WARN << "Failed to load command line argument: " << arguments[i].toStdString();
           }
         }
       } // end for each command line argument
 
       if (argumentsAdded > 0 && globalReinit)
       {
         // calculate bounding geometry
         mitk::RenderingManager::GetInstance()->InitializeViews(dataStorage->ComputeBoundingGeometry3D());
       }
     }
     else
     {
       MITK_ERROR << "A service reference for mitk::IDataStorageService does not exist";
     }
   }
 }
 
 void QmitkFlowApplicationPlugin::handleIPCMessage(const QByteArray& msg)
 {
   QDataStream ds(msg);
   QString msgType;
   ds >> msgType;
 
   // we only handle messages containing command line arguments
   if (msgType != "$cmdLineArgs") return;
 
   // activate the current workbench window
   berry::IWorkbenchWindow::Pointer window =
     berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow();
 
   QMainWindow* mainWindow =
     static_cast<QMainWindow*> (window->GetShell()->GetControl());
 
   mainWindow->setWindowState(mainWindow->windowState() & ~Qt::WindowMinimized);
   mainWindow->raise();
   mainWindow->activateWindow();
 
   QStringList args;
   ds >> args;
 
   loadDataFromDisk(args, false);
 }