diff --git a/Modules/Core/files.cmake b/Modules/Core/files.cmake
index 3178dddf16..17432bc657 100644
--- a/Modules/Core/files.cmake
+++ b/Modules/Core/files.cmake
@@ -1,326 +1,327 @@
 file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*")
 
 set(CPP_FILES
   mitkCoreActivator.cpp
   mitkCoreObjectFactoryBase.cpp
   mitkCoreObjectFactory.cpp
   mitkCoreServices.cpp
   mitkException.cpp
 
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkCompareImageDataFilter.cpp
   Algorithms/mitkCompositePixelValueToString.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkExtractSliceFilter2.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkImageToSurfaceFilter.cpp
   Algorithms/mitkMultiComponentImageDataComparisonFilter.cpp
   Algorithms/mitkPlaneGeometryDataToSurfaceFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToImageFilter.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
   Algorithms/mitkTemporalJoinImagesFilter.cpp
 
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkLayerController.cpp
   DataManagement/mitkAnatomicalStructureColorPresets.cpp
   DataManagement/mitkArbitraryTimeGeometry.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkApplyTransformMatrixOperation.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseGeometry.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataStorage.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkFloatPropertyExtension.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGeometryTransformHolder.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkGenericIDRelationRule.cpp
   DataManagement/mitkIdentifiable.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageReadAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageVtkReadAccessor.cpp
   DataManagement/mitkImageVtkWriteAccessor.cpp
   DataManagement/mitkImageWriteAccessor.cpp
   DataManagement/mitkIntPropertyExtension.cpp
   DataManagement/mitkIPersistenceService.cpp
   DataManagement/mitkIPropertyAliases.cpp
   DataManagement/mitkIPropertyDescriptions.cpp
   DataManagement/mitkIPropertyExtensions.cpp
   DataManagement/mitkIPropertyFilters.cpp
   DataManagement/mitkIPropertyOwner.cpp
   DataManagement/mitkIPropertyPersistence.cpp
   DataManagement/mitkIPropertyProvider.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLine.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTableProperty.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMaterial.cpp
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModifiedLock.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDataUID.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateFunction.cpp
   DataManagement/mitkNodePredicateGeometry.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateDataProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkNodePredicateSubGeometry.cpp
   DataManagement/mitkNumericConstants.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneGeometryData.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkPointSetShapeProperty.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyAliases.cpp
   DataManagement/mitkPropertyDescriptions.cpp
   DataManagement/mitkPropertyExtension.cpp
   DataManagement/mitkPropertyExtensions.cpp
   DataManagement/mitkPropertyFilter.cpp
   DataManagement/mitkPropertyFilters.cpp
   DataManagement/mitkPropertyKeyPath.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkPropertyListReplacedObserver.cpp
   DataManagement/mitkPropertyNameHelper.cpp
   DataManagement/mitkPropertyObserver.cpp
   DataManagement/mitkPropertyPersistence.cpp
   DataManagement/mitkPropertyPersistenceInfo.cpp
   DataManagement/mitkPropertyRelationRuleBase.cpp
   DataManagement/mitkProportionalTimeGeometry.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkScaleOperation.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkSourceImageRelationRule.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTimeGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTemporoSpatialStringProperty.cpp
   DataManagement/mitkUIDManipulator.cpp
   DataManagement/mitkVector.cpp
   DataManagement/mitkVectorProperty.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkIPropertyRelations.cpp
   DataManagement/mitkPropertyRelations.cpp
 
   Interactions/mitkAction.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
   Interactions/mitkCrosshairPositionEvent.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.cpp
   Interactions/mitkDisplayActionEventBroadcast.cpp
   Interactions/mitkDisplayActionEventFunctions.cpp
   Interactions/mitkDisplayActionEventHandler.cpp
   Interactions/mitkDisplayActionEventHandlerDesynchronized.cpp
   Interactions/mitkDisplayActionEventHandlerStd.cpp
   Interactions/mitkDisplayActionEventHandlerSynchronized.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkDisplayInteractor.cpp
   Interactions/mitkEventConfig.cpp
   Interactions/mitkEventFactory.cpp
   Interactions/mitkEventRecorder.cpp
   Interactions/mitkEventStateMachine.cpp
   Interactions/mitkInteractionEventConst.cpp
   Interactions/mitkInteractionEvent.cpp
   Interactions/mitkInteractionEventHandler.cpp
   Interactions/mitkInteractionEventObserver.cpp
   Interactions/mitkInteractionKeyEvent.cpp
   Interactions/mitkInteractionPositionEvent.cpp
   Interactions/mitkInteractionSchemeSwitcher.cpp
   Interactions/mitkInternalEvent.cpp
   Interactions/mitkMouseDoubleClickEvent.cpp
   Interactions/mitkMouseModeSwitcher.cpp
   Interactions/mitkMouseMoveEvent.cpp
   Interactions/mitkMousePressEvent.cpp
   Interactions/mitkMouseReleaseEvent.cpp
   Interactions/mitkMouseWheelEvent.cpp
   Interactions/mitkPointSetDataInteractor.cpp
   Interactions/mitkSinglePointDataInteractor.cpp
   Interactions/mitkStateMachineAction.cpp
   Interactions/mitkStateMachineCondition.cpp
   Interactions/mitkStateMachineContainer.cpp
   Interactions/mitkStateMachineState.cpp
   Interactions/mitkStateMachineTransition.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkXML2EventParser.cpp
 
   IO/mitkAbstractFileIO.cpp
   IO/mitkAbstractFileReader.cpp
   IO/mitkAbstractFileWriter.cpp
   IO/mitkCustomMimeType.cpp
   IO/mitkFileReader.cpp
   IO/mitkFileReaderRegistry.cpp
   IO/mitkFileReaderSelector.cpp
   IO/mitkFileReaderWriterBase.cpp
   IO/mitkFileWriter.cpp
   IO/mitkFileWriterRegistry.cpp
   IO/mitkFileWriterSelector.cpp
   IO/mitkGeometry3DToXML.cpp
   IO/mitkIFileIO.cpp
   IO/mitkIFileReader.cpp
   IO/mitkIFileWriter.cpp
   IO/mitkGeometryDataReaderService.cpp
   IO/mitkGeometryDataWriterService.cpp
   IO/mitkImageGenerator.cpp
   IO/mitkImageVtkLegacyIO.cpp
   IO/mitkImageVtkXmlIO.cpp
   IO/mitkIMimeTypeProvider.cpp
   IO/mitkIOConstants.cpp
   IO/mitkIOMimeTypes.cpp
   IO/mitkIOUtil.cpp
   IO/mitkItkImageIO.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkLegacyFileReaderService.cpp
   IO/mitkLegacyFileWriterService.cpp
   IO/mitkLocaleSwitch.cpp
   IO/mitkLog.cpp
   IO/mitkMimeType.cpp
   IO/mitkMimeTypeProvider.cpp
   IO/mitkOperation.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetReaderService.cpp
   IO/mitkPointSetWriterService.cpp
   IO/mitkProportionalTimeGeometryToXML.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSurfaceStlIO.cpp
   IO/mitkSurfaceVtkIO.cpp
   IO/mitkSurfaceVtkLegacyIO.cpp
   IO/mitkSurfaceVtkXmlIO.cpp
   IO/mitkVtkLoggingAdapter.cpp
   IO/mitkPreferenceListReaderOptionsFunctor.cpp
   IO/mitkIOMetaInformationPropertyConstants.cpp
 
   Rendering/mitkAbstractAnnotationRenderer.cpp
   Rendering/mitkAnnotationUtils.cpp
   Rendering/mitkBaseRenderer.cpp
   #Rendering/mitkGLMapper.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkAnnotation.cpp
   Rendering/mitkPlaneGeometryDataMapper2D.cpp
   Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
   Rendering/mitkPointSetVtkMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowFrame.cpp
   #Rendering/mitkSurfaceGLMapper2D.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkSurfaceVtkMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkVtkMapper.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
 )
 
 set(RESOURCE_FILES
 Interactions/globalConfig.xml
 Interactions/DisplayInteraction.xml
 Interactions/DisplayConfig.xml
 Interactions/DisplayConfigPACS.xml
 Interactions/DisplayConfigPACSPan.xml
 Interactions/DisplayConfigPACSScroll.xml
 Interactions/DisplayConfigPACSZoom.xml
 Interactions/DisplayConfigPACSLevelWindow.xml
 Interactions/DisplayConfigMITK.xml
 Interactions/DisplayConfigMITKNoCrosshair.xml
 Interactions/DisplayConfigMITKRotation.xml
 Interactions/DisplayConfigMITKRotationUnCoupled.xml
 Interactions/DisplayConfigMITKSwivel.xml
 Interactions/DisplayConfigMITKLimited.xml
+Interactions/DisplayConfigBlockLMB.xml
 Interactions/PointSet.xml
 Interactions/Legacy/StateMachine.xml
 Interactions/Legacy/DisplayConfigMITKTools.xml
 Interactions/PointSetConfig.xml
 
 mitkLevelWindowPresets.xml
 mitkAnatomicalStructureColorPresets.xml
 )
diff --git a/Modules/Core/resource/Interactions/DisplayConfigBlockLMB.xml b/Modules/Core/resource/Interactions/DisplayConfigBlockLMB.xml
new file mode 100644
index 0000000000..050093513b
--- /dev/null
+++ b/Modules/Core/resource/Interactions/DisplayConfigBlockLMB.xml
@@ -0,0 +1,5 @@
+<config>
+   <event_variant class="MousePressEvent" name="None">
+    <attribute name="EventButton" value="LeftMouseButton"/>
+  </event_variant>
+</config>
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
index ab3ce6c2a5..5ccc2dc29b 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
@@ -1,757 +1,757 @@
 /*============================================================================
 
 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 "mitkSegTool2D.h"
 #include "mitkToolManager.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkDataStorage.h"
 
 #include "mitkPlaneGeometry.h"
 
 // Include of the new ImageExtractor
 #include "mitkMorphologicalOperations.h"
 #include "mitkPlanarCircle.h"
 
 #include "usGetModuleContext.h"
 
 // Includes for 3DSurfaceInterpolation
 #include "mitkImageTimeSelector.h"
 #include "mitkImageToContourFilter.h"
 #include "mitkSurfaceInterpolationController.h"
 
 // includes for resling and overwriting
 #include <mitkExtractSliceFilter.h>
 #include <mitkVtkImageOverwrite.h>
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
 
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 #include <mitkDiffSliceOperationApplier.h>
 
 #include "mitkAbstractTransformGeometry.h"
 #include "mitkLabelSetImage.h"
 
 #include "mitkContourModelUtils.h"
 
 #include "itkImageRegionIterator.h"
 
 #define ROUND(a) ((a) > 0 ? (int)((a) + 0.5) : -(int)(0.5 - (a)))
 
 bool mitk::SegTool2D::m_SurfaceInterpolationEnabled = true;
 
 mitk::SegTool2D::SliceInformation::SliceInformation(const mitk::Image* aSlice, const mitk::PlaneGeometry* aPlane, mitk::TimeStepType aTimestep) :
   slice(aSlice), plane(aPlane), timestep(aTimestep)
 {
 }
 
 mitk::SegTool2D::SegTool2D(const char *type, const us::Module *interactorModule)
   : Tool(type, interactorModule), m_Contourmarkername("Position")
 {
-  Tool::m_EventConfig = "DisplayConfigMITKNoCrosshair.xml";
+  Tool::m_EventConfig = "DisplayConfigBlockLMB.xml";
 }
 
 mitk::SegTool2D::~SegTool2D()
 {
 }
 
 bool mitk::SegTool2D::FilterEvents(InteractionEvent *interactionEvent, DataNode *)
 {
   const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
 
   bool isValidEvent =
     (positionEvent && // Only events of type mitk::InteractionPositionEvent
      interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D // Only events from the 2D renderwindows
      );
   return isValidEvent;
 }
 
 bool mitk::SegTool2D::DetermineAffectedImageSlice(const Image *image,
                                                   const PlaneGeometry *plane,
                                                   int &affectedDimension,
                                                   int &affectedSlice)
 {
   assert(image);
   assert(plane);
 
   // compare normal of plane to the three axis vectors of the image
   Vector3D normal = plane->GetNormal();
   Vector3D imageNormal0 = image->GetSlicedGeometry()->GetAxisVector(0);
   Vector3D imageNormal1 = image->GetSlicedGeometry()->GetAxisVector(1);
   Vector3D imageNormal2 = image->GetSlicedGeometry()->GetAxisVector(2);
 
   normal.Normalize();
   imageNormal0.Normalize();
   imageNormal1.Normalize();
   imageNormal2.Normalize();
 
   imageNormal0.SetVnlVector(vnl_cross_3d<ScalarType>(normal.GetVnlVector(), imageNormal0.GetVnlVector()));
   imageNormal1.SetVnlVector(vnl_cross_3d<ScalarType>(normal.GetVnlVector(), imageNormal1.GetVnlVector()));
   imageNormal2.SetVnlVector(vnl_cross_3d<ScalarType>(normal.GetVnlVector(), imageNormal2.GetVnlVector()));
 
   double eps(0.00001);
   // axial
   if (imageNormal2.GetNorm() <= eps)
   {
     affectedDimension = 2;
   }
   // sagittal
   else if (imageNormal1.GetNorm() <= eps)
   {
     affectedDimension = 1;
   }
   // frontal
   else if (imageNormal0.GetNorm() <= eps)
   {
     affectedDimension = 0;
   }
   else
   {
     affectedDimension = -1; // no idea
     return false;
   }
 
   // determine slice number in image
   BaseGeometry *imageGeometry = image->GetGeometry(0);
   Point3D testPoint = imageGeometry->GetCenter();
   Point3D projectedPoint;
   plane->Project(testPoint, projectedPoint);
 
   Point3D indexPoint;
 
   imageGeometry->WorldToIndex(projectedPoint, indexPoint);
   affectedSlice = ROUND(indexPoint[affectedDimension]);
   MITK_DEBUG << "indexPoint " << indexPoint << " affectedDimension " << affectedDimension << " affectedSlice "
              << affectedSlice;
 
   // check if this index is still within the image
   if (affectedSlice < 0 || affectedSlice >= static_cast<int>(image->GetDimension(affectedDimension)))
     return false;
 
   return true;
 }
 
 void mitk::SegTool2D::UpdateSurfaceInterpolation(const Image *slice,
                                                  const Image *workingImage,
                                                  const PlaneGeometry *plane,
                                                  bool detectIntersection)
 {
   std::vector<SliceInformation> slices = { SliceInformation(slice, plane, 0)};
   Self::UpdateSurfaceInterpolation(slices, workingImage, detectIntersection);
 }
 
 void  mitk::SegTool2D::RemoveContourFromInterpolator(const SliceInformation& sliceInfo)
 {
   mitk::SurfaceInterpolationController::ContourPositionInformation contourInfo;
   contourInfo.contourNormal = sliceInfo.plane->GetNormal();
   contourInfo.contourPoint = sliceInfo.plane->GetOrigin();
   mitk::SurfaceInterpolationController::GetInstance()->RemoveContour(contourInfo);
 }
 
 void mitk::SegTool2D::UpdateSurfaceInterpolation(const std::vector<SliceInformation>& sliceInfos,
   const Image* workingImage,
   bool detectIntersection)
 {
   if (!m_SurfaceInterpolationEnabled)
     return;
 
   //Remark: the ImageTimeSelector is just needed to extract a timestep/channel of
   //the image in order to get the image dimension (time dimension and channel dimension
   //stripped away). Therfore it is OK to always use time step 0 and channel 0
   mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
   timeSelector->SetInput(workingImage);
   timeSelector->SetTimeNr(0);
   timeSelector->SetChannelNr(0);
   timeSelector->Update();
   const auto dimRefImg = timeSelector->GetOutput()->GetDimension();
 
   if (dimRefImg != 3)
     return;
 
   std::vector<mitk::Surface::Pointer> contourList;
   contourList.reserve(sliceInfos.size());
 
   ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
 
   std::vector<SliceInformation> relevantSlices = sliceInfos;
 
   if (detectIntersection)
   {
     relevantSlices.clear();
 
     for (const auto& sliceInfo : sliceInfos)
     {
       // Test whether there is something to extract or whether the slice just contains intersections of others
       mitk::Image::Pointer slice2 = sliceInfo.slice->Clone();
       mitk::MorphologicalOperations::Erode(slice2, 2, mitk::MorphologicalOperations::Ball);
 
       contourExtractor->SetInput(slice2);
       contourExtractor->Update();
       mitk::Surface::Pointer contour = contourExtractor->GetOutput();
 
       if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
       {
         Self::RemoveContourFromInterpolator(sliceInfo);
       }
       else
       {
         relevantSlices.push_back(sliceInfo);
       }
     }
   }
 
   if (relevantSlices.empty())
     return;
 
   for (const auto& sliceInfo : relevantSlices)
   {
 
     contourExtractor->SetInput(sliceInfo.slice);
     contourExtractor->Update();
     mitk::Surface::Pointer contour = contourExtractor->GetOutput();
 
     if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
     {
       Self::RemoveContourFromInterpolator(sliceInfo);
     }
     else
     {
       contour->DisconnectPipeline();
       contourList.push_back(contour);
     }
   }
   mitk::SurfaceInterpolationController::GetInstance()->AddNewContours(contourList);
 }
 
 
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const InteractionPositionEvent *positionEvent, const Image *image, unsigned int component /*= 0*/)
 {
   if (!positionEvent)
   {
     return nullptr;
   }
 
   assert(positionEvent->GetSender()); // sure, right?
   const auto timeStep = positionEvent->GetSender()->GetTimeStep(image); // get the timestep of the visible part (time-wise) of the image
 
   return GetAffectedImageSliceAs2DImage(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry(), image, timeStep, component);
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(const PlaneGeometry* planeGeometry, const Image* image, TimePointType timePoint, unsigned int component /*= 0*/)
 {
   if (!image || !planeGeometry)
   {
     return nullptr;
   }
 
   if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
     return nullptr;
 
   return SegTool2D::GetAffectedImageSliceAs2DImage(planeGeometry, image, image->GetTimeGeometry()->TimePointToTimeStep(timePoint), component);
 }
 
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PlaneGeometry *planeGeometry, const Image *image, TimeStepType timeStep, unsigned int component /*= 0*/)
 {
   if (!image || !planeGeometry)
   {
     return nullptr;
   }
 
   // Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   // set to false to extract a slice
   reslice->SetOverwriteMode(false);
   reslice->Modified();
 
   // use ExtractSliceFilter with our specific vtkImageReslice for overwriting and extracting
   mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput(image);
   extractor->SetTimeStep(timeStep);
   extractor->SetWorldGeometry(planeGeometry);
   extractor->SetVtkOutputRequest(false);
   extractor->SetResliceTransformByGeometry(image->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
   // additionally extract the given component
   // default is 0; the extractor checks for multi-component images
   extractor->SetComponent(component);
 
   extractor->Modified();
   extractor->Update();
 
   Image::Pointer slice = extractor->GetOutput();
 
   return slice;
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedWorkingSlice(const InteractionPositionEvent *positionEvent) const
 {
   const auto workingNode = this->GetWorkingDataNode();
   if (!workingNode)
   {
     return nullptr;
   }
 
   const auto *workingImage = dynamic_cast<Image *>(workingNode->GetData());
   if (!workingImage)
   {
     return nullptr;
   }
 
   return GetAffectedImageSliceAs2DImage(positionEvent, workingImage);
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const InteractionPositionEvent *positionEvent) const
 {
   DataNode* referenceNode = this->GetReferenceDataNode();
   if (!referenceNode)
   {
     return nullptr;
   }
 
   auto *referenceImage = dynamic_cast<Image *>(referenceNode->GetData());
   if (!referenceImage)
   {
     return nullptr;
   }
 
   int displayedComponent = 0;
   if (referenceNode->GetIntProperty("Image.Displayed Component", displayedComponent))
   {
     // found the displayed component
     return GetAffectedImageSliceAs2DImage(positionEvent, referenceImage, displayedComponent);
   }
   else
   {
     return GetAffectedImageSliceAs2DImage(positionEvent, referenceImage);
   }
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const PlaneGeometry* planeGeometry, TimeStepType timeStep) const
 {
   DataNode* referenceNode = this->GetReferenceDataNode();
   if (!referenceNode)
   {
     return nullptr;
   }
 
   auto* referenceImage = dynamic_cast<Image*>(referenceNode->GetData());
   if (!referenceImage)
   {
     return nullptr;
   }
 
   int displayedComponent = 0;
   if (referenceNode->GetIntProperty("Image.Displayed Component", displayedComponent))
   {
     // found the displayed component
     return GetAffectedImageSliceAs2DImage(planeGeometry, referenceImage, timeStep, displayedComponent);
   }
   else
   {
     return GetAffectedImageSliceAs2DImage(planeGeometry, referenceImage, timeStep);
   }
 }
 
 void mitk::SegTool2D::Activated()
 {
   Superclass::Activated();
 
   this->GetToolManager()->SelectedTimePointChanged +=
     mitk::MessageDelegate<mitk::SegTool2D>(this, &mitk::SegTool2D::OnTimePointChangedInternal);
 
   m_LastTimePointTriggered = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 }
 
 void mitk::SegTool2D::Deactivated()
 {
   this->GetToolManager()->SelectedTimePointChanged -=
     mitk::MessageDelegate<mitk::SegTool2D>(this, &mitk::SegTool2D::OnTimePointChangedInternal);
   Superclass::Deactivated();
 }
 
 void mitk::SegTool2D::OnTimePointChangedInternal()
 {
   if (m_IsTimePointChangeAware && nullptr != this->GetWorkingDataNode())
   {
     const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 
     if (timePoint != m_LastTimePointTriggered)
     {
       m_LastTimePointTriggered = timePoint;
       this->OnTimePointChanged();
     }
   }
 }
 
 void mitk::SegTool2D::OnTimePointChanged()
 {
   //default implementation does nothing
 }
 
 mitk::DataNode* mitk::SegTool2D::GetWorkingDataNode() const
 {
   if (nullptr != this->GetToolManager())
   {
     return this->GetToolManager()->GetWorkingData(0);
   }
   return nullptr;
 }
 
 mitk::Image* mitk::SegTool2D::GetWorkingData() const
 {
   auto node = this->GetWorkingDataNode();
   if (nullptr != node)
   {
     return dynamic_cast<Image*>(node->GetData());
   }
   return nullptr;
 }
 
 mitk::DataNode* mitk::SegTool2D::GetReferenceDataNode() const
 {
   if (nullptr != this->GetToolManager())
   {
     return this->GetToolManager()->GetReferenceData(0);
   }
   return nullptr;
 }
 
 mitk::Image* mitk::SegTool2D::GetReferenceData() const
 {
   auto node = this->GetReferenceDataNode();
   if (nullptr != node)
   {
     return dynamic_cast<Image*>(node->GetData());
   }
   return nullptr;
 }
 
 
 void mitk::SegTool2D::WriteBackSegmentationResult(const InteractionPositionEvent *positionEvent, const Image * segmentationResult)
 {
   if (!positionEvent)
     return;
 
   const PlaneGeometry *planeGeometry((positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
   const auto *abstractTransformGeometry(
     dynamic_cast<const AbstractTransformGeometry *>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
 
   if (planeGeometry && segmentationResult && !abstractTransformGeometry)
   {
     const auto workingNode = this->GetWorkingDataNode();
     auto *image = dynamic_cast<Image *>(workingNode->GetData());
     const auto timeStep = positionEvent->GetSender()->GetTimeStep(image);
     this->WriteBackSegmentationResult(planeGeometry, segmentationResult, timeStep);
   }
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResult(const DataNode* workingNode, const PlaneGeometry* planeGeometry, const Image* segmentationResult, TimeStepType timeStep)
 {
   if (!planeGeometry || !segmentationResult)
     return;
 
   SliceInformation sliceInfo(segmentationResult, const_cast<mitk::PlaneGeometry*>(planeGeometry), timeStep);
   Self::WriteBackSegmentationResults(workingNode, { sliceInfo }, true);
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResult(const PlaneGeometry *planeGeometry,
                                                   const Image * segmentationResult,
                                                   TimeStepType timeStep)
 {
   if (!planeGeometry || !segmentationResult)
     return;
 
   SliceInformation sliceInfo(segmentationResult, const_cast<mitk::PlaneGeometry *>(planeGeometry), timeStep);
   WriteBackSegmentationResults({ sliceInfo }, true);
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResults(const std::vector<SegTool2D::SliceInformation> &sliceList,
                                                   bool writeSliceToVolume)
 {
   if (sliceList.empty())
   {
     return;
   }
 
   if (nullptr == m_LastEventSender)
   {
     MITK_WARN << "Cannot write tool results. Tool seems to be in an invalid state, as no interaction event was recieved but is expected.";
     return;
   }
 
   const auto workingNode = this->GetWorkingDataNode();
 
   mitk::SegTool2D::WriteBackSegmentationResults(workingNode, sliceList, writeSliceToVolume);
 
   // the first geometry is needed otherwise restoring the position is not working
   const auto* plane3 =
     dynamic_cast<const PlaneGeometry*>(dynamic_cast<const mitk::SlicedGeometry3D*>(
       m_LastEventSender->GetSliceNavigationController()->GetCurrentGeometry3D())
       ->GetPlaneGeometry(0));
   unsigned int slicePosition = m_LastEventSender->GetSliceNavigationController()->GetSlice()->GetPos();
 
   /* A cleaner solution would be to add a contour marker for each slice info. It currently
    does not work as the contour markers expect that the plane is always the plane of slice 0.
    Had not the time to do it properly no. Should be solved by T28146*/
   this->AddContourmarker(plane3, slicePosition);
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResults(const DataNode* workingNode, const std::vector<SliceInformation>& sliceList, bool writeSliceToVolume)
 {
   if (sliceList.empty())
   {
     return;
   }
 
   if (nullptr == workingNode)
   {
     mitkThrow() << "Cannot write slice to working node. Working node is invalid.";
   }
 
   auto* image = dynamic_cast<Image*>(workingNode->GetData());
 
   if (nullptr == image)
   {
     mitkThrow() << "Cannot write slice to working node. Working node does not contain an image.";
   }
 
   for (const auto& sliceInfo : sliceList)
   {
     if (writeSliceToVolume && nullptr != sliceInfo.plane && sliceInfo.slice.IsNotNull())
     {
       mitk::SegTool2D::WriteSliceToVolume(image, sliceInfo, true);
     }
   }
 
   mitk::SegTool2D::UpdateSurfaceInterpolation(sliceList, image, false);
 
   // also mark its node as modified (T27308). Can be removed if T27307
   // is properly solved
   if (workingNode != nullptr) workingNode->Modified();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::SegTool2D::WriteSliceToVolume(Image* workingImage, const PlaneGeometry* planeGeometry, const Image* slice, TimeStepType timeStep, bool allowUndo)
 {
   SliceInformation sliceInfo(slice, planeGeometry, timeStep);
   WriteSliceToVolume(workingImage, sliceInfo , allowUndo);
 }
 
 void mitk::SegTool2D::WriteSliceToVolume(Image* workingImage, const SliceInformation &sliceInfo, bool allowUndo)
 {
   if (nullptr == workingImage)
   {
     mitkThrow() << "Cannot write slice to working node. Working node does not contain an image.";
   }
 
   DiffSliceOperation* undoOperation = nullptr;
 
   if (allowUndo)
   {
     /*============= BEGIN undo/redo feature block ========================*/
     // Create undo operation by caching the not yet modified slices
     mitk::Image::Pointer originalSlice = GetAffectedImageSliceAs2DImage(sliceInfo.plane, workingImage, sliceInfo.timestep);
     undoOperation =
       new DiffSliceOperation(workingImage,
         originalSlice,
         dynamic_cast<SlicedGeometry3D*>(originalSlice->GetGeometry()),
         sliceInfo.timestep,
         sliceInfo.plane);
     /*============= END undo/redo feature block ========================*/
   }
 
   // Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk
   // reslicer
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
   // Set the slice as 'input'
   // casting const away is needed and OK as long the OverwriteMode of
   // mitkVTKImageOverwrite is true.
   // Reason: because then the input slice is not touched but
   // used to overwrite the input of the ExtractSliceFilter.
   auto noneConstSlice = const_cast<Image*>(sliceInfo.slice.GetPointer());
   reslice->SetInputSlice(noneConstSlice->GetVtkImageData());
 
   // set overwrite mode to true to write back to the image volume
   reslice->SetOverwriteMode(true);
   reslice->Modified();
 
   mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput(workingImage);
   extractor->SetTimeStep(sliceInfo.timestep);
   extractor->SetWorldGeometry(sliceInfo.plane);
   extractor->SetVtkOutputRequest(false);
   extractor->SetResliceTransformByGeometry(workingImage->GetGeometry(sliceInfo.timestep));
 
   extractor->Modified();
   extractor->Update();
 
   // the image was modified within the pipeline, but not marked so
   workingImage->Modified();
   workingImage->GetVtkImageData()->Modified();
 
   if (allowUndo)
   {
     /*============= BEGIN undo/redo feature block ========================*/
     // specify the redo operation with the edited slice
     auto* doOperation =
       new DiffSliceOperation(workingImage,
         extractor->GetOutput(),
         dynamic_cast<SlicedGeometry3D*>(sliceInfo.slice->GetGeometry()),
         sliceInfo.timestep,
         sliceInfo.plane);
 
     // create an operation event for the undo stack
     OperationEvent* undoStackItem =
       new OperationEvent(DiffSliceOperationApplier::GetInstance(), doOperation, undoOperation, "Segmentation");
 
     // add it to the undo controller
     UndoStackItem::IncCurrObjectEventId();
     UndoStackItem::IncCurrGroupEventId();
     UndoController::GetCurrentUndoModel()->SetOperationEvent(undoStackItem);
     /*============= END undo/redo feature block ========================*/
   }
 
 }
 
 
 void mitk::SegTool2D::SetShowMarkerNodes(bool status)
 {
   m_ShowMarkerNodes = status;
 }
 
 void mitk::SegTool2D::SetEnable3DInterpolation(bool enabled)
 {
   m_SurfaceInterpolationEnabled = enabled;
 }
 
 
 int mitk::SegTool2D::AddContourmarker(const PlaneGeometry* planeGeometry, unsigned int sliceIndex)
 {
   if (planeGeometry == nullptr)
     return -1;
 
   us::ServiceReference<PlanePositionManagerService> serviceRef =
     us::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
   PlanePositionManagerService *service = us::GetModuleContext()->GetService(serviceRef);
 
   unsigned int size = service->GetNumberOfPlanePositions();
   unsigned int id = service->AddNewPlanePosition(planeGeometry, sliceIndex);
 
   mitk::PlanarCircle::Pointer contourMarker = mitk::PlanarCircle::New();
   mitk::Point2D p1;
   planeGeometry->Map(planeGeometry->GetCenter(), p1);
   mitk::Point2D p2 = p1;
   p2[0] -= planeGeometry->GetSpacing()[0];
   p2[1] -= planeGeometry->GetSpacing()[1];
   contourMarker->PlaceFigure(p1);
   contourMarker->SetCurrentControlPoint(p1);
   contourMarker->SetPlaneGeometry(planeGeometry->Clone());
 
   std::stringstream markerStream;
   auto workingNode = this->GetWorkingDataNode();
 
   markerStream << m_Contourmarkername;
   markerStream << " ";
   markerStream << id + 1;
 
   DataNode::Pointer rotatedContourNode = DataNode::New();
 
   rotatedContourNode->SetData(contourMarker);
   rotatedContourNode->SetProperty("name", StringProperty::New(markerStream.str()));
   rotatedContourNode->SetProperty("isContourMarker", BoolProperty::New(true));
   rotatedContourNode->SetBoolProperty("PlanarFigureInitializedWindow", true, m_LastEventSender);
   rotatedContourNode->SetProperty("includeInBoundingBox", BoolProperty::New(false));
   rotatedContourNode->SetProperty("helper object", mitk::BoolProperty::New(!m_ShowMarkerNodes));
   rotatedContourNode->SetProperty("planarfigure.drawcontrolpoints", BoolProperty::New(false));
   rotatedContourNode->SetProperty("planarfigure.drawname", BoolProperty::New(false));
   rotatedContourNode->SetProperty("planarfigure.drawoutline", BoolProperty::New(false));
   rotatedContourNode->SetProperty("planarfigure.drawshadow", BoolProperty::New(false));
 
   if (planeGeometry)
   {
     if (id == size)
     {
       this->GetToolManager()->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
     else
     {
       mitk::NodePredicateProperty::Pointer isMarker =
         mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true));
 
       mitk::DataStorage::SetOfObjects::ConstPointer markers =
         this->GetToolManager()->GetDataStorage()->GetDerivations(workingNode, isMarker);
 
       for (auto iter = markers->begin(); iter != markers->end(); ++iter)
       {
         std::string nodeName = (*iter)->GetName();
         unsigned int t = nodeName.find_last_of(" ");
         unsigned int markerId = atof(nodeName.substr(t + 1).c_str()) - 1;
         if (id == markerId)
         {
           return id;
         }
       }
       this->GetToolManager()->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
   }
   return id;
 }
 
 void mitk::SegTool2D::InteractiveSegmentationBugMessage(const std::string &message) const
 {
   MITK_ERROR << "********************************************************************************" << std::endl
              << " " << message << std::endl
              << "********************************************************************************" << std::endl
              << "  " << std::endl
              << " If your image is rotated or the 2D views don't really contain the patient image, try to press the "
                 "button next to the image selection. "
              << std::endl
              << "  " << std::endl
              << " Please file a BUG REPORT: " << std::endl
              << " https://phabricator.mitk.org/" << std::endl
              << " Contain the following information:" << std::endl
              << "  - What image were you working on?" << std::endl
              << "  - Which region of the image?" << std::endl
              << "  - Which tool did you use?" << std::endl
              << "  - What did you do?" << std::endl
              << "  - What happened (not)? What did you expect?" << std::endl;
 }
 
 void mitk::SegTool2D::WritePreviewOnWorkingImage(
   Image *targetSlice, const Image *sourceSlice, const Image *workingImage, int paintingPixelValue)
 {
   if (nullptr == targetSlice)
   {
     mitkThrow() << "Cannot write preview on working image. Target slice does not point to a valid instance.";
   }
 
   if (nullptr == sourceSlice)
   {
     mitkThrow() << "Cannot write preview on working image. Source slice does not point to a valid instance.";
   }
 
   if (nullptr == workingImage)
   {
     mitkThrow() << "Cannot write preview on working image. Working image does not point to a valid instance.";
   }
 
   auto constVtkSource = sourceSlice->GetVtkImageData();
   /*Need to const cast because Vtk interface does not support const correctly.
    (or I am not experienced enough to use it correctly)*/
   auto nonConstVtkSource = const_cast<vtkImageData*>(constVtkSource);
 
   ContourModelUtils::FillSliceInSlice(nonConstVtkSource, targetSlice->GetVtkImageData(), workingImage, paintingPixelValue, 1.0);
 }
diff --git a/Modules/Segmentation/Interactions/mitkTool.cpp b/Modules/Segmentation/Interactions/mitkTool.cpp
index e17746d67a..fb9721e97c 100644
--- a/Modules/Segmentation/Interactions/mitkTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkTool.cpp
@@ -1,348 +1,348 @@
 /*============================================================================
 
 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 "mitkTool.h"
 
 #include <mitkAnatomicalStructureColorPresets.h>
 #include "mitkDisplayInteractor.h"
 #include "mitkDisplayActionEventBroadcast.h"
 #include "mitkImageReadAccessor.h"
 #include "mitkImageWriteAccessor.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkProperties.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include <mitkDICOMSegmentationPropertyHelper.cpp>
 #include <mitkToolManager.h>
 
 // us
 #include <usGetModuleContext.h>
 #include <usModuleResource.h>
 
 // itk
 #include <itkObjectFactory.h>
 
 mitk::Tool::Tool(const char *type, const us::Module *interactorModule)
-  : m_EventConfig("DisplayConfigMITK.xml"),
+  : m_EventConfig(""),
     m_ToolManager(nullptr),
     m_PredicateImages(NodePredicateDataType::New("Image")), // for reference images
     m_PredicateDim3(NodePredicateDimension::New(3, 1)),
     m_PredicateDim4(NodePredicateDimension::New(4, 1)),
     m_PredicateDimension(mitk::NodePredicateOr::New(m_PredicateDim3, m_PredicateDim4)),
     m_PredicateImage3D(NodePredicateAnd::New(m_PredicateImages, m_PredicateDimension)),
     m_PredicateBinary(NodePredicateProperty::New("binary", BoolProperty::New(true))),
     m_PredicateNotBinary(NodePredicateNot::New(m_PredicateBinary)),
     m_PredicateSegmentation(NodePredicateProperty::New("segmentation", BoolProperty::New(true))),
     m_PredicateNotSegmentation(NodePredicateNot::New(m_PredicateSegmentation)),
     m_PredicateHelper(NodePredicateProperty::New("helper object", BoolProperty::New(true))),
     m_PredicateNotHelper(NodePredicateNot::New(m_PredicateHelper)),
     m_PredicateImageColorful(NodePredicateAnd::New(m_PredicateNotBinary, m_PredicateNotSegmentation)),
     m_PredicateImageColorfulNotHelper(NodePredicateAnd::New(m_PredicateImageColorful, m_PredicateNotHelper)),
     m_PredicateReference(NodePredicateAnd::New(m_PredicateImage3D, m_PredicateImageColorfulNotHelper)),
     m_IsSegmentationPredicate(
       NodePredicateAnd::New(NodePredicateOr::New(m_PredicateBinary, m_PredicateSegmentation), m_PredicateNotHelper)),
     m_InteractorType(type),
     m_DisplayInteractorConfigs(),
     m_InteractorModule(interactorModule)
 {
 }
 
 mitk::Tool::~Tool()
 {
 }
 
 bool mitk::Tool::CanHandle(const BaseData* referenceData, const BaseData* /*workingData*/) const
 {
   if (referenceData == nullptr)
     return false;
 
   return true;
 }
 
 void mitk::Tool::InitializeStateMachine()
 {
   if (m_InteractorType.empty())
     return;
 
   try
   {
     auto isThisModule = nullptr == m_InteractorModule;
 
     auto module = isThisModule
       ? us::GetModuleContext()->GetModule()
       : m_InteractorModule;
 
     LoadStateMachine(m_InteractorType + ".xml", module);
     SetEventConfig(isThisModule ? "SegmentationToolsConfig.xml" : m_InteractorType + "Config.xml", module);
   }
   catch (const std::exception &e)
   {
     MITK_ERROR << "Could not load statemachine pattern " << m_InteractorType << ".xml with exception: " << e.what();
   }
 }
 
 void mitk::Tool::Notify(InteractionEvent *interactionEvent, bool isHandled)
 {
   // to use the state machine pattern,
   // the event is passed to the state machine interface to be handled
   if (!isHandled)
   {
     this->HandleEvent(interactionEvent, nullptr);
   }
 }
 
 void mitk::Tool::ConnectActionsAndFunctions()
 {
 }
 
 bool mitk::Tool::FilterEvents(InteractionEvent *, DataNode *)
 {
   return true;
 }
 
 const char *mitk::Tool::GetGroup() const
 {
   return "default";
 }
 
 void mitk::Tool::SetToolManager(ToolManager *manager)
 {
   m_ToolManager = manager;
 }
 
 mitk::ToolManager* mitk::Tool::GetToolManager() const
 {
   return m_ToolManager;
 }
 
 mitk::DataStorage* mitk::Tool::GetDataStorage() const
 {
   if (nullptr != m_ToolManager)
   {
     return m_ToolManager->GetDataStorage();
   }
   return nullptr;
 }
 
 void mitk::Tool::Activated()
 {
   // As a legacy solution the display interaction of the new interaction framework is disabled here to avoid conflicts
   // with tools
   // Note: this only affects InteractionEventObservers (formerly known as Listeners) all DataNode specific interaction
   // will still be enabled
   m_DisplayInteractorConfigs.clear();
   std::vector<us::ServiceReference<InteractionEventObserver>> listEventObserver =
     us::GetModuleContext()->GetServiceReferences<InteractionEventObserver>();
   for (auto it = listEventObserver.begin(); it != listEventObserver.end(); ++it)
   {
     auto displayInteractor = dynamic_cast<DisplayInteractor*>(us::GetModuleContext()->GetService<InteractionEventObserver>(*it));
     if (displayInteractor != nullptr)
     {
       // remember the original configuration
       m_DisplayInteractorConfigs.insert(std::make_pair(*it, displayInteractor->GetEventConfig()));
       // here the alternative configuration is loaded
-      displayInteractor->SetEventConfig(m_EventConfig.c_str());
+      displayInteractor->AddEventConfig(m_EventConfig.c_str());
     }
 
     auto displayActionEventBroadcast = dynamic_cast<DisplayActionEventBroadcast*>(us::GetModuleContext()->GetService<InteractionEventObserver>(*it));
     if (displayActionEventBroadcast != nullptr)
     {
       // remember the original configuration
       m_DisplayInteractorConfigs.insert(std::make_pair(*it, displayActionEventBroadcast->GetEventConfig()));
       // here the alternative configuration is loaded
-      displayActionEventBroadcast->SetEventConfig(m_EventConfig.c_str());
+      displayActionEventBroadcast->AddEventConfig(m_EventConfig.c_str());
     }
   }
 }
 
 void mitk::Tool::Deactivated()
 {
   // Re-enabling InteractionEventObservers that have been previously disabled for legacy handling of Tools
   // in new interaction framework
   for (auto it = m_DisplayInteractorConfigs.begin(); it != m_DisplayInteractorConfigs.end(); ++it)
   {
     if (it->first)
     {
       auto displayInteractor = static_cast<DisplayInteractor*>(us::GetModuleContext()->GetService<InteractionEventObserver>(it->first));
       if (displayInteractor != nullptr)
       {
         // here the regular configuration is loaded again
         displayInteractor->SetEventConfig(it->second);
       }
 
       auto displayActionEventBroadcast = dynamic_cast<DisplayActionEventBroadcast*>(us::GetModuleContext()->GetService<InteractionEventObserver>(it->first));
       if (displayActionEventBroadcast != nullptr)
       {
         // here the regular configuration is loaded again
         displayActionEventBroadcast->SetEventConfig(it->second);
       }
     }
   }
   m_DisplayInteractorConfigs.clear();
 }
 
 itk::Object::Pointer mitk::Tool::GetGUI(const std::string &toolkitPrefix, const std::string &toolkitPostfix)
 {
   itk::Object::Pointer object;
 
   std::string classname = this->GetNameOfClass();
   std::string guiClassname = toolkitPrefix + classname + toolkitPostfix;
 
   std::list<itk::LightObject::Pointer> allGUIs = itk::ObjectFactoryBase::CreateAllInstance(guiClassname.c_str());
   for (auto iter = allGUIs.begin(); iter != allGUIs.end(); ++iter)
   {
     if (object.IsNull())
     {
       object = dynamic_cast<itk::Object *>(iter->GetPointer());
     }
     else
     {
       MITK_ERROR << "There is more than one GUI for " << classname << " (several factories claim ability to produce a "
                  << guiClassname << " ) " << std::endl;
       return nullptr; // people should see and fix this error
     }
   }
 
   return object;
 }
 
 mitk::NodePredicateBase::ConstPointer mitk::Tool::GetReferenceDataPreference() const
 {
   return m_PredicateReference.GetPointer();
 }
 
 mitk::NodePredicateBase::ConstPointer mitk::Tool::GetWorkingDataPreference() const
 {
   return m_IsSegmentationPredicate.GetPointer();
 }
 
 mitk::DataNode::Pointer mitk::Tool::CreateEmptySegmentationNode(const Image *original,
                                                                 const std::string &organName,
                                                                 const mitk::Color &color) const
 {
   // we NEED a reference image for size etc.
   if (!original)
     return nullptr;
 
   // actually create a new empty segmentation
   PixelType pixelType(mitk::MakeScalarPixelType<DefaultSegmentationDataType>());
   LabelSetImage::Pointer segmentation = LabelSetImage::New();
 
   if (original->GetDimension() == 2)
   {
     const unsigned int dimensions[] = {original->GetDimension(0), original->GetDimension(1), 1};
     segmentation->Initialize(pixelType, 3, dimensions);
     segmentation->AddLayer();
   }
   else
   {
     segmentation->Initialize(original);
   }
 
   mitk::Label::Pointer label = mitk::Label::New();
   label->SetName(organName);
   label->SetColor(color);
   label->SetValue(1);
   segmentation->GetActiveLabelSet()->AddLabel(label);
   segmentation->GetActiveLabelSet()->SetActiveLabel(1);
 
   unsigned int byteSize = sizeof(mitk::Label::PixelType);
 
   if (segmentation->GetDimension() < 4)
   {
     for (unsigned int dim = 0; dim < segmentation->GetDimension(); ++dim)
     {
       byteSize *= segmentation->GetDimension(dim);
     }
 
     mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(0));
 
     memset(writeAccess.GetData(), 0, byteSize);
   }
   else
   {
     // if we have a time-resolved image we need to set memory to 0 for each time step
     for (unsigned int dim = 0; dim < 3; ++dim)
     {
       byteSize *= segmentation->GetDimension(dim);
     }
 
     for (unsigned int volumeNumber = 0; volumeNumber < segmentation->GetDimension(3); volumeNumber++)
     {
       mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(volumeNumber));
 
       memset(writeAccess.GetData(), 0, byteSize);
     }
   }
 
   if (original->GetTimeGeometry())
   {
     TimeGeometry::Pointer originalGeometry = original->GetTimeGeometry()->Clone();
     segmentation->SetTimeGeometry(originalGeometry);
   }
   else
   {
     Tool::ErrorMessage("Original image does not have a 'Time sliced geometry'! Cannot create a segmentation.");
     return nullptr;
   }
 
   return CreateSegmentationNode(segmentation, organName, color);
 }
 
 mitk::DataNode::Pointer mitk::Tool::CreateSegmentationNode(Image *image,
                                                            const std::string &organName,
                                                            const mitk::Color &color) const
 {
   if (!image)
     return nullptr;
 
   // decorate the datatreenode with some properties
   DataNode::Pointer segmentationNode = DataNode::New();
   segmentationNode->SetData(image);
 
   // name
   segmentationNode->SetProperty("name", StringProperty::New(organName));
 
   // visualization properties
   segmentationNode->SetProperty("binary", BoolProperty::New(true));
   segmentationNode->SetProperty("color", ColorProperty::New(color));
   mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
   lut->SetType(mitk::LookupTable::MULTILABEL);
   mitk::LookupTableProperty::Pointer lutProp = mitk::LookupTableProperty::New();
   lutProp->SetLookupTable(lut);
   segmentationNode->SetProperty("LookupTable", lutProp);
   segmentationNode->SetProperty("texture interpolation", BoolProperty::New(false));
   segmentationNode->SetProperty("layer", IntProperty::New(10));
   segmentationNode->SetProperty("levelwindow", LevelWindowProperty::New(LevelWindow(0.5, 1)));
   segmentationNode->SetProperty("opacity", FloatProperty::New(0.3));
   segmentationNode->SetProperty("segmentation", BoolProperty::New(true));
   segmentationNode->SetProperty("reslice interpolation",
                                 VtkResliceInterpolationProperty::New()); // otherwise -> segmentation appears in 2
                                                                          // slices sometimes (only visual effect, not
                                                                          // different data)
   // For MITK-3M3 release, the volume of all segmentations should be shown
   segmentationNode->SetProperty("showVolume", BoolProperty::New(true));
 
   return segmentationNode;
 }
 
 us::ModuleResource mitk::Tool::GetIconResource() const
 {
   // Each specific tool should load its own resource. This one will be invalid
   return us::ModuleResource();
 }
 
 us::ModuleResource mitk::Tool::GetCursorIconResource() const
 {
   // Each specific tool should load its own resource. This one will be invalid
   return us::ModuleResource();
 }