diff --git a/Core/Code/Interactions/mitkInteractionEventConst.h b/Core/Code/Interactions/mitkInteractionEventConst.h
index f332d73487..cc06f391fd 100644
--- a/Core/Code/Interactions/mitkInteractionEventConst.h
+++ b/Core/Code/Interactions/mitkInteractionEventConst.h
@@ -1,131 +1,132 @@
 /*===================================================================
 
  The Medical Imaging Interaction Toolkit (MITK)
 
  Copyright (c) German Cancer Research Center,
  Division of Medical and Biological Informatics.
  All rights reserved.
 
  This software is distributed WITHOUT ANY WARRANTY; without
  even the implied warranty of MERCHANTABILITY or FITNESS FOR
  A PARTICULAR PURPOSE.
 
  See LICENSE.txt or http://www.mitk.org for details.
 
  ===================================================================*/
 
 #ifndef MITKINTERACTEVENTCONST_H
 #define MITKINTERACTEVENTCONST_H
 
 //##Documentation
 //## @file mitkInteractionEventConst.h
 //## @brief Constants to describe Mouse Events and special Key Events.
 
 #include <string>
 
 namespace mitk
 {
 
 //##ButtonState
 // Mouse/keyboard state values
   enum MouseButtons
   {
     NoButton = 0x0000,
     LeftMouseButton = 0x0001,
     RightMouseButton = 0x0002,
     MiddleMouseButton = 0x0004,
   };
 
   enum ModifierKeys
   {
     NoKey = 0x0000,
     ShiftKey = 0x0100,
     ControlKey = 0x0200,
     AltKey = 0x0400
   };
 
   /*
    * Allow bitwise OR operation on enums.
    */
   inline MouseButtons operator|(MouseButtons a, MouseButtons b)
   {
     return static_cast<MouseButtons>(static_cast<int>(a) | static_cast<int>(b));
   }
 
   inline MouseButtons& operator|=(MouseButtons& a, MouseButtons& b)
   {
     a = static_cast<MouseButtons>(static_cast<int>(a) | static_cast<int>(b));
     return a;
   }
 
   inline ModifierKeys operator|(ModifierKeys a, ModifierKeys b)
   {
     return static_cast<ModifierKeys>(static_cast<int>(a) | static_cast<int>(b));
   }
 
   inline ModifierKeys& operator|=(ModifierKeys& a, ModifierKeys& b)
   {
     a = static_cast<ModifierKeys>(static_cast<int>(a) | static_cast<int>(b));
     return a;
   }
 
   /**
    * KeyConstants Constants for special keys
    */
   // Special Keys
   const std::string KeyEsc = "Escape";
   const std::string KeyEnter = "Enter";
   const std::string KeyReturn = "Return";
   const std::string KeyDelete = "Delete";
   const std::string KeyArrowUp = "ArrowUp";
   const std::string KeyArrowDown = "ArrowDown";
   const std::string KeyArrowLeft = "ArrowLeft";
   const std::string KeyArrowRight = "ArrowRight";
 
   const std::string KeyF1 = "F1";
   const std::string KeyF2 = "F2";
   const std::string KeyF3 = "F3";
   const std::string KeyF4 = "F4";
   const std::string KeyF5 = "F5";
   const std::string KeyF6 = "F6";
   const std::string KeyF7 = "F7";
   const std::string KeyF8 = "F8";
   const std::string KeyF9 = "F9";
   const std::string KeyF10 = "F10";
   const std::string KeyF11 = "F11";
   const std::string KeyF12 = "F12";
 
   const std::string KeyPos1 = "Pos1";
-  const std::string KeyEend = "End";
+  const std::string KeyEnd = "End";
   const std::string KeyInsert = "Insert";
   const std::string KeyPageUp = "PageUp";
   const std::string KeyPageDown = "PageDown";
+  const std::string KeySpace = "Space";
   // End special keys
 
   // XML Tags
   const std::string xmlTagConfigRoot = "config";
   const std::string xmlTagParam = "param";
   const std::string xmlTagEventVariant = "event_variant";
   const std::string xmlTagAttribute = "attribute";
 
   // XML Param
   const std::string xmlParameterName = "name";
   const std::string xmlParameterValue = "value";
   const std::string xmlParameterEventVariant = "event_variant";
   const std::string xmlParameterEventClass = "class";
 
   // Event Description
   const std::string xmlEventPropertyModifier = "Modifiers";
   const std::string xmlEventPropertyEventButton = "EventButton";
   const std::string xmlEventPropertyButtonState = "ButtonState";
   const std::string xmlEventPropertyKey = "Key";
   const std::string xmlEventPropertyScrollDirection = "ScrollDirection";
   const std::string xmlEventPropertySignalName = "SignalName";
 
   // Predefined internal events/signals
   const std::string IntDeactivateMe = "DeactivateMe";
   const std::string IntLeaveWidget = "LeaveWidget";
   const std::string IntEnterWidget = "EnterWidget";
 
 }     //namespace mitk
 #endif //ifndef MITKINTERACTEVENTCONST_H
diff --git a/Core/Code/Resources/Interactions/DisplayConfigMITK.xml b/Core/Code/Resources/Interactions/DisplayConfigMITK.xml
index 025b59f5fc..78cb9e148c 100644
--- a/Core/Code/Resources/Interactions/DisplayConfigMITK.xml
+++ b/Core/Code/Resources/Interactions/DisplayConfigMITK.xml
@@ -1,43 +1,41 @@
 <!--
 * - MITK : The original interaction scheme
-*   - left mouse button   : setting the cross position in the MPR view
 *   - middle mouse button : panning
 *   - right mouse button  : zooming
 *   - wheel               : scrolling
 -->
 <config>
   <!-- Zoom sensitivity -->
   <param name="zoomFactor" value="5"/>
   <!-- Zoom either by moving mouse leftright or updown -->
   <param name="zoomDirection" value="leftright"/>
   <!-- react to an event, even tough is was already processed by a DataInteractor-->
   <param name="alwaysReact" value="false"/>
   <!-- Moving -->
   <event_variant class="MousePressEvent" name="StartMove">
     <attribute name="EventButton" value="MiddleMouseButton"/>
   </event_variant>
   <event_variant class="MouseReleaseEvent" name="EndMoving">
     <attribute name="EventButton" value="MiddleMouseButton"/>
   </event_variant>
   <event_variant class="MouseMoveEvent" name="Moving">
     <attribute name="ButtonState" value="MiddleMouseButton"/>
   </event_variant>
   <!-- Zooming -->
   <event_variant class="MousePressEvent" name="StartZoom">
     <attribute name="EventButton" value="RightMouseButton"/>
   </event_variant>
    <event_variant class="MouseMoveEvent" name="Zooming">
     <attribute name="ButtonState" value="RightMouseButton"/>
   </event_variant>
   <event_variant class="MouseReleaseEvent" name="EndZooming">
     <attribute name="EventButton" value="RightMouseButton"/>
   </event_variant>
-  <!-- PlaneUP and -Down are described twice, this means the transition
-  can be triggered by both events -->
+  <!-- Scrolling through planes -->
   <event_variant class="MouseWheelEvent" name="PlaneUP">
     <attribute name="ScrollDirection" value="up"/>
   </event_variant>
   <event_variant class="MouseWheelEvent" name="PlaneDown">
     <attribute name="ScrollDirection" value="down"/>
   </event_variant>
 </config>
diff --git a/Core/Code/Resources/Interactions/DisplayConfigMITK.xml b/Core/Code/Resources/Interactions/Legacy/DisplayConfigMITKTools.xml
similarity index 69%
copy from Core/Code/Resources/Interactions/DisplayConfigMITK.xml
copy to Core/Code/Resources/Interactions/Legacy/DisplayConfigMITKTools.xml
index 025b59f5fc..df1a4adc97 100644
--- a/Core/Code/Resources/Interactions/DisplayConfigMITK.xml
+++ b/Core/Code/Resources/Interactions/Legacy/DisplayConfigMITKTools.xml
@@ -1,43 +1,49 @@
 <!--
-* - MITK : The original interaction scheme
-*   - left mouse button   : setting the cross position in the MPR view
+* - MITK : The legacy handling for Tools.
+    Describes which events should trigger an event_variant.
+    The corresponding event_variants and their actions are declared in DisplayConfig.xml (in /Resources/Interactions).
+    If no event_variant is specified here, this action is disabled during the activation of a tool.
+    So if an action here conflicts with you tool you can comment out this section.
+    ! Alternatively you can also just change the event description, so that the actions are triggered by different mouse/key events
+    during Tool use. !
+    Refer to 'How to create a Config-File' http://docs.mitk.org/nightly-qt4/Step10Page.html for details.
+
 *   - middle mouse button : panning
 *   - right mouse button  : zooming
 *   - wheel               : scrolling
 -->
 <config>
   <!-- Zoom sensitivity -->
   <param name="zoomFactor" value="5"/>
   <!-- Zoom either by moving mouse leftright or updown -->
   <param name="zoomDirection" value="leftright"/>
   <!-- react to an event, even tough is was already processed by a DataInteractor-->
   <param name="alwaysReact" value="false"/>
   <!-- Moving -->
   <event_variant class="MousePressEvent" name="StartMove">
     <attribute name="EventButton" value="MiddleMouseButton"/>
   </event_variant>
   <event_variant class="MouseReleaseEvent" name="EndMoving">
     <attribute name="EventButton" value="MiddleMouseButton"/>
   </event_variant>
   <event_variant class="MouseMoveEvent" name="Moving">
     <attribute name="ButtonState" value="MiddleMouseButton"/>
   </event_variant>
   <!-- Zooming -->
   <event_variant class="MousePressEvent" name="StartZoom">
     <attribute name="EventButton" value="RightMouseButton"/>
   </event_variant>
    <event_variant class="MouseMoveEvent" name="Zooming">
     <attribute name="ButtonState" value="RightMouseButton"/>
   </event_variant>
   <event_variant class="MouseReleaseEvent" name="EndZooming">
     <attribute name="EventButton" value="RightMouseButton"/>
   </event_variant>
-  <!-- PlaneUP and -Down are described twice, this means the transition
-  can be triggered by both events -->
+  <!-- Scrolling trough planes -->
   <event_variant class="MouseWheelEvent" name="PlaneUP">
     <attribute name="ScrollDirection" value="up"/>
   </event_variant>
   <event_variant class="MouseWheelEvent" name="PlaneDown">
     <attribute name="ScrollDirection" value="down"/>
   </event_variant>
 </config>
diff --git a/Core/Code/files.cmake b/Core/Code/files.cmake
index 52c96fab6a..5ac0ab1c8c 100644
--- a/Core/Code/files.cmake
+++ b/Core/Code/files.cmake
@@ -1,362 +1,363 @@
 set(H_FILES
   Algorithms/itkImportMitkImageContainer.h
   Algorithms/itkImportMitkImageContainer.txx
   Algorithms/itkLocalVariationImageFilter.h
   Algorithms/itkLocalVariationImageFilter.txx
   Algorithms/itkMITKScalarImageToHistogramGenerator.h
   Algorithms/itkMITKScalarImageToHistogramGenerator.txx
   Algorithms/itkTotalVariationDenoisingImageFilter.h
   Algorithms/itkTotalVariationDenoisingImageFilter.txx
   Algorithms/itkTotalVariationSingleIterationImageFilter.h
   Algorithms/itkTotalVariationSingleIterationImageFilter.txx
   Algorithms/mitkBilateralFilter.h
   Algorithms/mitkBilateralFilter.cpp
   Algorithms/mitkInstantiateAccessFunctions.h
   Algorithms/mitkPixelTypeList.h
   # Preprocessor macros taken from Boost
   Algorithms/mitkPPArithmeticDec.h
   Algorithms/mitkPPArgCount.h
   Algorithms/mitkPPCat.h
   Algorithms/mitkPPConfig.h
   Algorithms/mitkPPControlExprIIf.h
   Algorithms/mitkPPControlIf.h
   Algorithms/mitkPPControlIIf.h
   Algorithms/mitkPPDebugError.h
   Algorithms/mitkPPDetailAutoRec.h
   Algorithms/mitkPPDetailDMCAutoRec.h
   Algorithms/mitkPPExpand.h
   Algorithms/mitkPPFacilitiesEmpty.h
   Algorithms/mitkPPFacilitiesExpand.h
   Algorithms/mitkPPLogicalBool.h
   Algorithms/mitkPPRepetitionDetailDMCFor.h
   Algorithms/mitkPPRepetitionDetailEDGFor.h
   Algorithms/mitkPPRepetitionDetailFor.h
   Algorithms/mitkPPRepetitionDetailMSVCFor.h
   Algorithms/mitkPPRepetitionFor.h
   Algorithms/mitkPPSeqElem.h
   Algorithms/mitkPPSeqForEach.h
   Algorithms/mitkPPSeqForEachProduct.h
   Algorithms/mitkPPSeq.h
   Algorithms/mitkPPSeqEnum.h
   Algorithms/mitkPPSeqSize.h
   Algorithms/mitkPPSeqToTuple.h
   Algorithms/mitkPPStringize.h
   Algorithms/mitkPPTupleEat.h
   Algorithms/mitkPPTupleElem.h
   Algorithms/mitkPPTupleRem.h
   Algorithms/mitkClippedSurfaceBoundsCalculator.h
   Algorithms/mitkExtractSliceFilter.h
   Algorithms/mitkConvert2Dto3DImageFilter.h
   Algorithms/mitkPlaneClipping.h
 
   Common/mitkExceptionMacro.h
   Common/mitkServiceBaseObject.h
   Common/mitkTestingMacros.h
 
   DataManagement/mitkImageAccessByItk.h
   DataManagement/mitkImageCast.h
   DataManagement/mitkImagePixelAccessor.h
   DataManagement/mitkImagePixelReadAccessor.h
   DataManagement/mitkImagePixelWriteAccessor.h
   DataManagement/mitkImageReadAccessor.h
   DataManagement/mitkImageWriteAccessor.h
   DataManagement/mitkITKImageImport.h
   DataManagement/mitkITKImageImport.txx
   DataManagement/mitkImageToItk.h
   DataManagement/mitkImageToItk.txx
 
   Interactions/mitkEventMapperAddOn.h
 
   Interfaces/mitkIDataNodeReader.h
 
   IO/mitkPixelTypeTraits.h
 )
 
 set(CPP_FILES
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkBaseProcess.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkCoreActivator.cpp
   Controllers/mitkFocusManager.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.cpp
   Controllers/mitkSlicesRotator.cpp
   Controllers/mitkSlicesSwiveller.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkInteractorCameraController.cpp
   Controllers/mitkVtkLayerController.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataStorage.cpp
   #DataManagement/mitkDataTree.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataNodeFactory.cpp
   #DataManagement/mitkDataTreeStorage.cpp
   DataManagement/mitkDisplayGeometry.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkGeometry2D.cpp
   DataManagement/mitkGeometry2DData.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkLandmarkBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModeOperation.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStateTransitionOperation.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTimeSlicedGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkVector.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkShaderProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkMaterial.cpp
   Interactions/mitkAction.cpp
   Interactions/mitkAffineInteractor.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
   Interactions/mitkCoordinateSupplier.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkDisplayInteractor.cpp
   Interactions/mitkDisplayPositionEvent.cpp
 #  Interactions/mitkDisplayVectorInteractorLevelWindow.cpp # legacy, prob even now unneeded
 #  Interactions/mitkDisplayVectorInteractorScroll.cpp
   Interactions/mitkEvent.cpp
   Interactions/mitkEventConfig.cpp
   Interactions/mitkEventDescription.cpp
   Interactions/mitkEventFactory.cpp
   Interactions/mitkInteractionEventHandler.cpp
   Interactions/mitkEventMapper.cpp
   Interactions/mitkEventStateMachine.cpp
   Interactions/mitkGlobalInteraction.cpp
   Interactions/mitkInteractor.cpp
   Interactions/mitkInternalEvent.cpp
   Interactions/mitkInteractionEvent.cpp
   Interactions/mitkInteractionPositionEvent.cpp
   Interactions/mitkInteractionKeyEvent.cpp
   Interactions/mitkMousePressEvent.cpp
   Interactions/mitkMouseMoveEvent.cpp
   Interactions/mitkMouseReleaseEvent.cpp
   Interactions/mitkMouseWheelEvent.cpp
   Interactions/mitkMouseModeSwitcher.cpp
   Interactions/mitkMouseMovePointSetInteractor.cpp
   Interactions/mitkMoveBaseDataInteractor.cpp
   Interactions/mitkNodeDepententPointSetInteractor.cpp
   Interactions/mitkPointSetDataInteractor.cpp
   Interactions/mitkPointSetInteractor.cpp
   Interactions/mitkPositionEvent.cpp
   Interactions/mitkPositionTracker.cpp
   Interactions/mitkStateMachineAction.cpp
   Interactions/mitkStateMachineState.cpp
   Interactions/mitkStateMachineTransition.cpp
   Interactions/mitkState.cpp
   Interactions/mitkStateMachineContainer.cpp
   Interactions/mitkStateEvent.cpp
   Interactions/mitkStateMachine.cpp
   Interactions/mitkStateMachineFactory.cpp
   Interactions/mitkTransition.cpp
   Interactions/mitkWheelEvent.cpp
   Interactions/mitkKeyEvent.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkCrosshairPositionEvent.cpp
 
   Interfaces/mitkInteractionEventObserver.cpp
   Interfaces/mitkIShaderRepository.cpp
 
   IO/mitkBaseDataIOFactory.cpp
   IO/mitkCoreDataNodeReader.cpp
   IO/mitkDicomSeriesReader.cpp
   IO/mitkFileReader.cpp
   IO/mitkFileSeriesReader.cpp
   IO/mitkFileWriter.cpp
   #IO/mitkIpPicGet.c
   IO/mitkImageGenerator.cpp
   IO/mitkImageWriter.cpp
   IO/mitkImageWriterFactory.cpp
   IO/mitkItkImageFileIOFactory.cpp
   IO/mitkItkImageFileReader.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkItkPictureWrite.cpp
   IO/mitkIOUtil.cpp
   IO/mitkLookupTableProperty.cpp
   IO/mitkOperation.cpp
   #IO/mitkPicFileIOFactory.cpp
   #IO/mitkPicFileReader.cpp
   #IO/mitkPicFileWriter.cpp
   #IO/mitkPicHelper.cpp
   #IO/mitkPicVolumeTimeSeriesIOFactory.cpp
   #IO/mitkPicVolumeTimeSeriesReader.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetIOFactory.cpp
   IO/mitkPointSetReader.cpp
   IO/mitkPointSetWriter.cpp
   IO/mitkPointSetWriterFactory.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSTLFileIOFactory.cpp
   IO/mitkSTLFileReader.cpp
   IO/mitkSurfaceVtkWriter.cpp
   IO/mitkSurfaceVtkWriterFactory.cpp
   IO/mitkVtkLoggingAdapter.cpp
   IO/mitkVtiFileIOFactory.cpp
   IO/mitkVtiFileReader.cpp
   IO/mitkVtkImageIOFactory.cpp
   IO/mitkVtkImageReader.cpp
   IO/mitkVtkSurfaceIOFactory.cpp
   IO/mitkVtkSurfaceReader.cpp
   IO/vtkPointSetXMLParser.cpp
   IO/mitkLog.cpp
   Rendering/mitkBaseRenderer.cpp
   Rendering/mitkVtkMapper.cpp
   Rendering/mitkRenderWindowFrame.cpp
   Rendering/mitkGeometry2DDataMapper2D.cpp
   Rendering/mitkGeometry2DDataVtkMapper3D.cpp
   Rendering/mitkGLMapper.cpp
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkManufacturerLogo.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkPointSetGLMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkPolyDataGLMapper2D.cpp
   Rendering/mitkSurfaceGLMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVolumeDataVtkMapper3D.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkShaderRepository.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
   Rendering/mitkRenderingTestHelper.cpp
 
   Common/mitkException.cpp
   Common/mitkCommon.h
   Common/mitkCoreObjectFactoryBase.cpp
   Common/mitkCoreObjectFactory.cpp
   Common/mitkCoreServices.cpp
 )
 
 list(APPEND CPP_FILES ${CppMicroServices_SOURCES})
 
 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/PointSet.xml
 Interactions/Legacy/StateMachine.xml
+Interactions/Legacy/DisplayConfigMITKTools.xml
 Interactions/PointSetConfig.xml
 Interactions/Tests/AddAndRemovePoints.xml
 Interactions/Tests/globalConfig.xml
 Interactions/Tests/StatemachineTest.xml
 Interactions/Tests/StatemachineConfigTest.xml
 
 Shaders/mitkShaderLighting.xml
 
 mitkLevelWindowPresets.xml
 )
diff --git a/Modules/MitkExt/Controllers/mitkToolManager.cpp b/Modules/MitkExt/Controllers/mitkToolManager.cpp
index da81a44c03..02ba2ad59b 100644
--- a/Modules/MitkExt/Controllers/mitkToolManager.cpp
+++ b/Modules/MitkExt/Controllers/mitkToolManager.cpp
@@ -1,567 +1,576 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkToolManager.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkCoreObjectFactory.h"
 
 #include <itkObjectFactoryBase.h>
 #include <itkCommand.h>
 
 #include <list>
 
 #include "mitkInteractionEventObserver.h"
+#include "mitkDisplayInteractor.h"
 // MicroServices
 #include "mitkGetModuleContext.h"
 #include "mitkModule.h"
 #include "mitkModuleRegistry.h"
 
 
 mitk::ToolManager::ToolManager(DataStorage* storage)
 :m_ActiveTool(NULL),
  m_ActiveToolID(-1),
  m_RegisteredClients(0),
  m_DataStorage(storage)
 {
   CoreObjectFactory::GetInstance(); // to make sure a CoreObjectFactory was instantiated (and in turn, possible tools are registered) - bug 1029
 
   // get a list of all known mitk::Tools
   std::list<itk::LightObject::Pointer> thingsThatClaimToBeATool = itk::ObjectFactoryBase::CreateAllInstance("mitkTool");
 
   // remember these tools
   for ( std::list<itk::LightObject::Pointer>::iterator iter = thingsThatClaimToBeATool.begin();
     iter != thingsThatClaimToBeATool.end();
     ++iter )
   {
     if ( Tool* tool = dynamic_cast<Tool*>( iter->GetPointer() ) )
     {
       tool->SetToolManager(this); // important to call right after instantiation
       tool->ErrorMessage += MessageDelegate1<mitk::ToolManager, std::string>( this, &ToolManager::OnToolErrorMessage );
       tool->GeneralMessage += MessageDelegate1<mitk::ToolManager, std::string>( this, &ToolManager::OnGeneralToolMessage );
       m_Tools.push_back( tool );
     }
   }
 
   //ActivateTool(0); // first one is default
 }
 
 mitk::ToolManager::~ToolManager()
 {
   for (DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
     (*dataIter)->RemoveObserver(m_WorkingDataObserverTags[(*dataIter)]);
 
   if(this->GetDataStorage() != NULL)
     this->GetDataStorage()->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<ToolManager, const mitk::DataNode*>
         ( this, &ToolManager::OnNodeRemoved ));
 
   if (m_ActiveTool)
   {
     m_ActiveTool->Deactivated();
     GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
 
     m_ActiveTool = NULL;
     m_ActiveToolID = -1; // no tool active
 
     ActiveToolChanged.Send();
 
   }
   for ( NodeTagMapType::iterator observerTagMapIter = m_ReferenceDataObserverTags.begin(); observerTagMapIter != m_ReferenceDataObserverTags.end(); ++observerTagMapIter )
   {
     observerTagMapIter->first->RemoveObserver( observerTagMapIter->second );
   }
 }
 
 void mitk::ToolManager::OnToolErrorMessage(std::string s)
 {
   this->ToolErrorMessage(s);
 }
 
 void mitk::ToolManager::OnGeneralToolMessage(std::string s)
 {
   this->GeneralToolMessage(s);
 }
 
 
 const mitk::ToolManager::ToolVectorTypeConst mitk::ToolManager::GetTools()
 {
   ToolVectorTypeConst resultList;
 
   for ( ToolVectorType::iterator iter = m_Tools.begin();
     iter != m_Tools.end();
     ++iter )
   {
     resultList.push_back( iter->GetPointer() );
   }
 
   return resultList;
 }
 
 mitk::Tool* mitk::ToolManager::GetToolById(int id)
 {
   try
   {
     return m_Tools.at(id);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 bool mitk::ToolManager::ActivateTool(int id)
 {
 
   if(this->GetDataStorage())
     {
       this->GetDataStorage()->RemoveNodeEvent.AddListener( mitk::MessageDelegate1<ToolManager, const mitk::DataNode*>
         ( this, &ToolManager::OnNodeRemoved ) );
     }
 
   //MITK_INFO << "ToolManager::ActivateTool("<<id<<")"<<std::endl;
   //if( GetToolById(id) == NULL ) return false; // NO, invalid IDs are actually used here. Parameter -1 or anything that does not exists will deactivate all tools!
 
   //If a tool is deactivated set the event notification policy of the global interaction to multiple again
   if (id == -1)
   {
     GlobalInteraction::GetInstance()->SetEventNotificationPolicy(GlobalInteraction::INFORM_MULTIPLE);
     // Re-enabling InteractionEventObservers that have been previously disabled for legacy handling of Tools
     // in new interaction framework
     std::list<mitk::ServiceReference> listEventObserver;
     ServiceTracker<InteractionEventObserver*>* eventObserverTracker= new ServiceTracker<InteractionEventObserver*>(GetModuleContext());
     eventObserverTracker->Open();
     eventObserverTracker->GetServiceReferences(listEventObserver); // query all registered interaction event observer
     for (std::list<mitk::ServiceReference>::iterator it = listEventObserver.begin(); it != listEventObserver.end(); ++it)
     {
       InteractionEventObserver* interactionEventObserver = eventObserverTracker->GetService(*it);
       if (interactionEventObserver != NULL) {
-        interactionEventObserver->Enable();  // re-enable the interaction
+        DisplayInteractor* displayInteractor = dynamic_cast<DisplayInteractor*>(interactionEventObserver);
+        if (displayInteractor != NULL) {
+          // here the regular configuration is loaded again
+          displayInteractor->LoadEventConfig("DisplayConfigMITK.xml","Mitk");
+        }
       }
     }
     eventObserverTracker->Close();
     delete eventObserverTracker;
   }
 
   if ( GetToolById( id ) == m_ActiveTool ) return true; // no change needed
 
   static int nextTool = -1;
   nextTool = id;
   //MITK_INFO << "ToolManager::ActivateTool("<<id<<"): nextTool = "<<nextTool<<std::endl;
 
   static bool inActivateTool = false;
   if (inActivateTool)
   {
     //MITK_INFO << "ToolManager::ActivateTool("<<id<<"): already inside ActivateTool somehow, returning now "<<std::endl;
     return true;
   }
   inActivateTool = true;
 
   while ( nextTool != m_ActiveToolID )
   {
     //MITK_INFO <<"ToolManager::ActivateTool: nextTool = " << nextTool << " (active tool = " << m_ActiveToolID<<")"<<std::endl;
     if (m_ActiveTool)
     {
       m_ActiveTool->Deactivated();
       GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
     }
 
     m_ActiveTool = GetToolById( nextTool );
     m_ActiveToolID = m_ActiveTool ? nextTool : -1; // current ID if tool is valid, otherwise -1
 
     ActiveToolChanged.Send();
 
     if (m_ActiveTool)
     {
       if (m_RegisteredClients > 0)
       {
         m_ActiveTool->Activated();
         GlobalInteraction::GetInstance()->AddListener( m_ActiveTool );
         //If a tool is activated set event notification policy to one
         GlobalInteraction::GetInstance()->SetEventNotificationPolicy(GlobalInteraction::INFORM_ONE);
         // 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
         std::list<mitk::ServiceReference> listEventObserver;
         ServiceTracker<InteractionEventObserver*>* eventObserverTracker= new ServiceTracker<InteractionEventObserver*>(GetModuleContext());
         eventObserverTracker->Open();
         eventObserverTracker->GetServiceReferences(listEventObserver);
         for (std::list<mitk::ServiceReference>::iterator it = listEventObserver.begin(); it != listEventObserver.end(); ++it)
         {
           InteractionEventObserver* interactionEventObserver = eventObserverTracker->GetService(*it);
           if (interactionEventObserver != NULL) {
-            interactionEventObserver->Disable();  // disable the interaction
+            DisplayInteractor* displayInteractor = dynamic_cast<DisplayInteractor*>(interactionEventObserver);
+            if (displayInteractor != NULL) {
+              // here the regular configuration is loaded again
+              displayInteractor->LoadEventConfig("Legacy/DisplayConfigMITKTools.xml","Mitk");
+            }
           }
         }
         eventObserverTracker->Close();
         delete eventObserverTracker;
       }
     }
   }
 
   inActivateTool = false;
   return (m_ActiveTool != NULL);
 }
 
 void mitk::ToolManager::SetReferenceData(DataVectorType data)
 {
   if (data != m_ReferenceData)
   {
     // remove observers from old nodes
     for ( DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
     {
       NodeTagMapType::iterator searchIter = m_ReferenceDataObserverTags.find( *dataIter );
       if ( searchIter != m_ReferenceDataObserverTags.end() )
       {
         //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
         (*dataIter)->RemoveObserver( searchIter->second );
       }
     }
 
     m_ReferenceData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_ReferenceDataObserverTags.clear();
     for ( DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
     {
 
 
       //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheReferenceDataDeleted );
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheReferenceDataDeletedConst );
       m_ReferenceDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
     }
 
     ReferenceDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::OnOneOfTheReferenceDataDeletedConst(const itk::Object* caller, const itk::EventObject& e)
 {
   OnOneOfTheReferenceDataDeleted( const_cast<itk::Object*>(caller), e );
 }
 
 void mitk::ToolManager::OnOneOfTheReferenceDataDeleted(itk::Object* caller, const itk::EventObject& itkNotUsed(e))
 {
   //MITK_INFO << "Deleted: " << (void*)caller << " Removing from reference data list." << std::endl;
   DataVectorType v;
 
   for (DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
   {
     //MITK_INFO << " In list: " << (void*)(*dataIter);
     if ( (void*)(*dataIter) != (void*)caller )
     {
       v.push_back( *dataIter );
       //MITK_INFO << " kept" << std::endl;
     }
     else
     {
       //MITK_INFO << " removed" << std::endl;
       m_ReferenceDataObserverTags.erase( *dataIter ); // no tag to remove anymore
     }
   }
   this->SetReferenceData( v );
 }
 
 void mitk::ToolManager::SetReferenceData(DataNode* data)
 {
   //MITK_INFO << "ToolManager::SetReferenceData(" << (void*)data << ")" << std::endl;
   DataVectorType v;
   if (data)
   {
     v.push_back(data);
   }
   SetReferenceData(v);
 }
 
 void mitk::ToolManager::SetWorkingData(DataVectorType data)
 {
   if ( data != m_WorkingData )
   {
     // remove observers from old nodes
     for ( DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
     {
       NodeTagMapType::iterator searchIter = m_WorkingDataObserverTags.find( *dataIter );
       if ( searchIter != m_WorkingDataObserverTags.end() )
       {
         //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
         (*dataIter)->RemoveObserver( searchIter->second );
       }
     }
 
     m_WorkingData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_WorkingDataObserverTags.clear();
     for ( DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
     {
       //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheWorkingDataDeleted );
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheWorkingDataDeletedConst );
       m_WorkingDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
     }
 
     WorkingDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::OnOneOfTheWorkingDataDeletedConst(const itk::Object* caller, const itk::EventObject& e)
 {
   OnOneOfTheWorkingDataDeleted( const_cast<itk::Object*>(caller), e );
 }
 
 void mitk::ToolManager::OnOneOfTheWorkingDataDeleted(itk::Object* caller, const itk::EventObject& itkNotUsed(e))
 {
   //MITK_INFO << "Deleted: " << (void*)caller << " Removing from reference data list." << std::endl;
   DataVectorType v;
 
   for (DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
   {
     //MITK_INFO << " In list: " << (void*)(*dataIter);
     if ( (void*)(*dataIter) != (void*)caller )
     {
       v.push_back( *dataIter );
       //MITK_INFO << " kept" << std::endl;
     }
     else
     {
       //MITK_INFO << " removed" << std::endl;
       m_WorkingDataObserverTags.erase( *dataIter ); // no tag to remove anymore
     }
   }
   this->SetWorkingData( v );
 }
 
 
 void mitk::ToolManager::SetWorkingData(DataNode* data)
 {
   DataVectorType v;
 
   if (data) // don't allow for NULL nodes
   {
     v.push_back(data);
   }
 
   SetWorkingData(v);
 }
 
 void mitk::ToolManager::SetRoiData(DataVectorType data)
 {
   if (data != m_RoiData)
   {
     // remove observers from old nodes
     for ( DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
     {
       NodeTagMapType::iterator searchIter = m_RoiDataObserverTags.find( *dataIter );
       if ( searchIter != m_RoiDataObserverTags.end() )
       {
         //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
         (*dataIter)->RemoveObserver( searchIter->second );
       }
     }
 
     m_RoiData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_RoiDataObserverTags.clear();
     for ( DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
     {
       //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheRoiDataDeleted );
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheRoiDataDeletedConst );
       m_RoiDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
     }
     RoiDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::SetRoiData(DataNode* data)
 {
   DataVectorType v;
 
   if(data)
   {
     v.push_back(data);
   }
   this->SetRoiData(v);
 }
 
 void mitk::ToolManager::OnOneOfTheRoiDataDeletedConst(const itk::Object* caller, const itk::EventObject& e)
 {
   OnOneOfTheRoiDataDeleted( const_cast<itk::Object*>(caller), e );
 }
 
 void mitk::ToolManager::OnOneOfTheRoiDataDeleted(itk::Object* caller, const itk::EventObject& itkNotUsed(e))
 {
   //MITK_INFO << "Deleted: " << (void*)caller << " Removing from roi data list." << std::endl;
   DataVectorType v;
 
   for (DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
   {
     //MITK_INFO << " In list: " << (void*)(*dataIter);
     if ( (void*)(*dataIter) != (void*)caller )
     {
       v.push_back( *dataIter );
       //MITK_INFO << " kept" << std::endl;
     }
     else
     {
       //MITK_INFO << " removed" << std::endl;
       m_RoiDataObserverTags.erase( *dataIter ); // no tag to remove anymore
     }
   }
   this->SetRoiData( v );
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetReferenceData()
 {
   return m_ReferenceData;
 }
 
 mitk::DataNode* mitk::ToolManager::GetReferenceData(int idx)
 {
   try
   {
     return m_ReferenceData.at(idx);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetWorkingData()
 {
   return m_WorkingData;
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetRoiData()
 {
   return m_RoiData;
 }
 
 mitk::DataNode* mitk::ToolManager::GetRoiData(int idx)
 {
   try
   {
     return m_RoiData.at(idx);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 mitk::DataStorage* mitk::ToolManager::GetDataStorage()
 {
   if ( m_DataStorage.IsNotNull() )
   {
     return m_DataStorage;
   }
   else
   {
     return NULL;
   }
 }
 
 void mitk::ToolManager::SetDataStorage(DataStorage& storage)
 {
   m_DataStorage = &storage;
 }
 
 
 
 mitk::DataNode* mitk::ToolManager::GetWorkingData(int idx)
 {
   try
   {
     return m_WorkingData.at(idx);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 int mitk::ToolManager::GetActiveToolID()
 {
   return m_ActiveToolID;
 }
 
 mitk::Tool* mitk::ToolManager::GetActiveTool()
 {
   return m_ActiveTool;
 }
 
 void mitk::ToolManager::RegisterClient()
 {
   if ( m_RegisteredClients < 1 )
   {
     if ( m_ActiveTool )
     {
       m_ActiveTool->Activated();
       GlobalInteraction::GetInstance()->AddListener( m_ActiveTool );
     }
   }
   ++m_RegisteredClients;
 }
 
 void mitk::ToolManager::UnregisterClient()
 {
   if ( m_RegisteredClients < 1) return;
 
   --m_RegisteredClients;
   if ( m_RegisteredClients < 1 )
   {
     if ( m_ActiveTool )
     {
       m_ActiveTool->Deactivated();
       GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
     }
   }
 }
 
 int mitk::ToolManager::GetToolID( const Tool* tool )
 {
   int id(0);
   for ( ToolVectorType::iterator iter = m_Tools.begin();
     iter != m_Tools.end();
     ++iter, ++id )
   {
     if ( tool == iter->GetPointer() )
     {
       return id;
     }
   }
   return -1;
 }
 
 
 void mitk::ToolManager::OnNodeRemoved(const mitk::DataNode* node)
 {
   //check if the data of the node is typeof Image
   /*if(dynamic_cast<mitk::Image*>(node->GetData()))
   {*/
     //check all storage vectors
     OnOneOfTheReferenceDataDeleted(const_cast<mitk::DataNode*>(node), itk::DeleteEvent());
     OnOneOfTheRoiDataDeleted(const_cast<mitk::DataNode*>(node),itk::DeleteEvent());
     OnOneOfTheWorkingDataDeleted(const_cast<mitk::DataNode*>(node),itk::DeleteEvent());
   //}
 }
 
diff --git a/Modules/Qmitk/QmitkRenderWindow.cpp b/Modules/Qmitk/QmitkRenderWindow.cpp
index c4ce398567..f9cf89a97d 100644
--- a/Modules/Qmitk/QmitkRenderWindow.cpp
+++ b/Modules/Qmitk/QmitkRenderWindow.cpp
@@ -1,539 +1,542 @@
 /*===================================================================
 
  The Medical Imaging Interaction Toolkit (MITK)
 
  Copyright (c) German Cancer Research Center,
  Division of Medical and Biological Informatics.
  All rights reserved.
 
  This software is distributed WITHOUT ANY WARRANTY; without
  even the implied warranty of MERCHANTABILITY or FITNESS FOR
  A PARTICULAR PURPOSE.
 
  See LICENSE.txt or http://www.mitk.org for details.
 
  ===================================================================*/
 
 #include "QmitkRenderWindow.h"
 
 #include <QCursor>
 #include <QMouseEvent>
 #include <QWheelEvent>
 #include <QKeyEvent>
 #include <QResizeEvent>
 #include <QTimer>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include "QmitkEventAdapter.h" // TODO: INTERACTION_LEGACY
 #include "mitkMousePressEvent.h"
 #include "mitkMouseMoveEvent.h"
 #include "mitkMouseReleaseEvent.h"
 #include "mitkInteractionKeyEvent.h"
 #include "mitkMouseWheelEvent.h"
 #include "mitkInternalEvent.h"
 
 #include "QmitkRenderWindowMenu.h"
 
 QmitkRenderWindow::QmitkRenderWindow(QWidget *parent,
     QString name,
     mitk::VtkPropRenderer* /*renderer*/,
     mitk::RenderingManager* renderingManager) :
     QVTKWidget(parent), m_ResendQtEvents(true), m_MenuWidget(NULL), m_MenuWidgetActivated(false), m_LayoutIndex(0)
 {
   Initialize(renderingManager, name.toStdString().c_str()); // Initialize mitkRenderWindowBase
 
   setFocusPolicy(Qt::StrongFocus);
   setMouseTracking(true);
 
 }
 
 QmitkRenderWindow::~QmitkRenderWindow()
 {
   Destroy(); // Destroy mitkRenderWindowBase
 
 }
 
 void QmitkRenderWindow::SetResendQtEvents(bool resend)
 {
   m_ResendQtEvents = resend;
 }
 
 void QmitkRenderWindow::SetLayoutIndex(unsigned int layoutIndex)
 {
   m_LayoutIndex = layoutIndex;
   if (m_MenuWidget)
     m_MenuWidget->SetLayoutIndex(layoutIndex);
 }
 
 unsigned int QmitkRenderWindow::GetLayoutIndex()
 {
   if (m_MenuWidget)
     return m_MenuWidget->GetLayoutIndex();
   else
     return 0;
 }
 
 void QmitkRenderWindow::LayoutDesignListChanged(int layoutDesignIndex)
 {
   if (m_MenuWidget)
     m_MenuWidget->UpdateLayoutDesignList(layoutDesignIndex);
 }
 
 void QmitkRenderWindow::mousePressEvent(QMouseEvent *me)
 {
 
   mitk::MousePressEvent::Pointer mPressEvent = mitk::MousePressEvent::New(m_Renderer, GetMousePosition(me), GetButtonState(me),
       GetModifiers(me), GetEventButton(me));
 
   if (!this->HandleEvent(mPressEvent.GetPointer()))
   { // TODO: INTERACTION_LEGACY
     mitk::MouseEvent myevent(QmitkEventAdapter::AdaptMouseEvent(m_Renderer, me));
     this->mousePressMitkEvent(&myevent);
   }
   QVTKWidget::mousePressEvent(me);
 
   if (m_ResendQtEvents)
     me->ignore();
 }
 
 void QmitkRenderWindow::mouseReleaseEvent(QMouseEvent *me)
 {
   mitk::MouseReleaseEvent::Pointer mReleaseEvent = mitk::MouseReleaseEvent::New(m_Renderer, GetMousePosition(me), GetButtonState(me),
       GetModifiers(me), GetEventButton(me));
 
   if (!this->HandleEvent(mReleaseEvent.GetPointer()))
   { // TODO: INTERACTION_LEGACY
     mitk::MouseEvent myevent(QmitkEventAdapter::AdaptMouseEvent(m_Renderer, me));
     this->mouseReleaseMitkEvent(&myevent);
   }
   QVTKWidget::mouseReleaseEvent(me);
 
   if (m_ResendQtEvents)
     me->ignore();
 }
 
 void QmitkRenderWindow::mouseMoveEvent(QMouseEvent *me)
 {
   this->AdjustRenderWindowMenuVisibility(me->pos());
 
   mitk::MouseMoveEvent::Pointer mMoveEvent = mitk::MouseMoveEvent::New(m_Renderer, GetMousePosition(me), GetButtonState(me),
       GetModifiers(me));
 
   if (!this->HandleEvent(mMoveEvent.GetPointer()))
   { // TODO: INTERACTION_LEGACY
     mitk::MouseEvent myevent(QmitkEventAdapter::AdaptMouseEvent(m_Renderer, me));
     this->mouseMoveMitkEvent(&myevent);
   }
   QVTKWidget::mouseMoveEvent(me);
 }
 
 void QmitkRenderWindow::wheelEvent(QWheelEvent *we)
 {
   mitk::MouseWheelEvent::Pointer mWheelEvent = mitk::MouseWheelEvent::New(m_Renderer, GetMousePosition(we), GetButtonState(we),
       GetModifiers(we), GetDelta(we));
 
   if (!this->HandleEvent(mWheelEvent.GetPointer()))
   { // TODO: INTERACTION_LEGACY
     mitk::WheelEvent myevent(QmitkEventAdapter::AdaptWheelEvent(m_Renderer, we));
     this->wheelMitkEvent(&myevent);
   }
   QVTKWidget::wheelEvent(we);
 
   if (m_ResendQtEvents)
     we->ignore();
 }
 
 void QmitkRenderWindow::keyPressEvent(QKeyEvent *ke)
 {
   mitk::ModifierKeys modifiers = GetModifiers(ke);
   std::string key = GetKeyLetter(ke);
 
   mitk::InteractionKeyEvent::Pointer keyEvent = mitk::InteractionKeyEvent::New(m_Renderer, key, modifiers);
   if (!this->HandleEvent(keyEvent.GetPointer()))
   { // TODO: INTERACTION_LEGACY
     QPoint cp = mapFromGlobal(QCursor::pos());
     mitk::KeyEvent mke(QmitkEventAdapter::AdaptKeyEvent(m_Renderer, ke, cp));
     this->keyPressMitkEvent(&mke);
     ke->accept();
   }
 
   QVTKWidget::keyPressEvent(ke);
 
   if (m_ResendQtEvents)
     ke->ignore();
 }
 
 void QmitkRenderWindow::enterEvent(QEvent *e)
 {
   // TODO implement new event
   QVTKWidget::enterEvent(e);
 }
 
 void QmitkRenderWindow::DeferredHideMenu()
 {
   MITK_DEBUG << "QmitkRenderWindow::DeferredHideMenu";
 
   if (m_MenuWidget)
     m_MenuWidget->HideMenu();
 }
 
 void QmitkRenderWindow::leaveEvent(QEvent *e)
 {
   mitk::InternalEvent::Pointer internalEvent = mitk::InternalEvent::New(this->m_Renderer, NULL, "LeaveRenderWindow");
 
   if (!this->HandleEvent(internalEvent.GetPointer()))
 
     // TODO implement new event
     MITK_DEBUG << "QmitkRenderWindow::leaveEvent";
 
   if (m_MenuWidget)
     m_MenuWidget->smoothHide();
 
   QVTKWidget::leaveEvent(e);
 }
 
 void QmitkRenderWindow::paintEvent(QPaintEvent* /*event*/)
 {
   //We are using our own interaction and thus have to call the rendering manually.
   this->GetRenderer()->GetRenderingManager()->RequestUpdate(GetRenderWindow());
 }
 
 void QmitkRenderWindow::resizeEvent(QResizeEvent* event)
 {
   this->resizeMitkEvent(event->size().width(), event->size().height());
 
   QVTKWidget::resizeEvent(event);
 
   emit resized();
 }
 
 void QmitkRenderWindow::moveEvent(QMoveEvent* event)
 {
   QVTKWidget::moveEvent(event);
 
   // after a move the overlays need to be positioned
   emit moved();
 }
 
 void QmitkRenderWindow::showEvent(QShowEvent* event)
 {
   QVTKWidget::showEvent(event);
 
   // this singleshot is necessary to have the overlays positioned correctly after initial show
   // simple call of moved() is no use here!!
   QTimer::singleShot(0, this, SIGNAL( moved() ));
 }
 
 void QmitkRenderWindow::ActivateMenuWidget(bool state, QmitkStdMultiWidget* stdMultiWidget)
 {
   m_MenuWidgetActivated = state;
 
   if (!m_MenuWidgetActivated && m_MenuWidget)
   {
     //disconnect Signal/Slot Connection
     disconnect(m_MenuWidget, SIGNAL( SignalChangeLayoutDesign(int) ), this, SLOT(OnChangeLayoutDesign(int)));
     disconnect(m_MenuWidget, SIGNAL( ResetView() ), this, SIGNAL( ResetView()));
     disconnect(m_MenuWidget, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SIGNAL( ChangeCrosshairRotationMode(int)));
 
     delete m_MenuWidget;
     m_MenuWidget = 0;
   }
   else if (m_MenuWidgetActivated && !m_MenuWidget)
   {
     //create render window MenuBar for split, close Window or set new setting.
     m_MenuWidget = new QmitkRenderWindowMenu(this, 0, m_Renderer, stdMultiWidget);
     m_MenuWidget->SetLayoutIndex(m_LayoutIndex);
 
     //create Signal/Slot Connection
     connect(m_MenuWidget, SIGNAL( SignalChangeLayoutDesign(int) ), this, SLOT(OnChangeLayoutDesign(int)));
     connect(m_MenuWidget, SIGNAL( ResetView() ), this, SIGNAL( ResetView()));
     connect(m_MenuWidget, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SIGNAL( ChangeCrosshairRotationMode(int)));
   }
 }
 
 void QmitkRenderWindow::AdjustRenderWindowMenuVisibility(const QPoint& /*pos*/)
 {
   if (m_MenuWidget)
   {
     m_MenuWidget->ShowMenu();
     m_MenuWidget->MoveWidgetToCorrectPos(1.0f);
   }
 }
 
 void QmitkRenderWindow::HideRenderWindowMenu()
 {
   // DEPRECATED METHOD
 }
 
 void QmitkRenderWindow::OnChangeLayoutDesign(int layoutDesignIndex)
 {
   emit SignalLayoutDesignChanged(layoutDesignIndex);
 }
 
 void QmitkRenderWindow::OnWidgetPlaneModeChanged(int mode)
 {
   if (m_MenuWidget)
     m_MenuWidget->NotifyNewWidgetPlanesMode(mode);
 }
 
 void QmitkRenderWindow::FullScreenMode(bool state)
 {
   if (m_MenuWidget)
     m_MenuWidget->ChangeFullScreenMode(state);
 }
 
 void QmitkRenderWindow::dragEnterEvent(QDragEnterEvent *event)
 {
   if (event->mimeData()->hasFormat("application/x-mitk-datanodes"))
   {
     event->accept();
   }
 }
 
 void QmitkRenderWindow::dropEvent(QDropEvent * event)
 {
   if (event->mimeData()->hasFormat("application/x-mitk-datanodes"))
   {
     QString arg = QString(event->mimeData()->data("application/x-mitk-datanodes").data());
     QStringList listOfDataNodes = arg.split(",");
     std::vector<mitk::DataNode*> vectorOfDataNodePointers;
 
     for (int i = 0; i < listOfDataNodes.size(); i++)
     {
       long val = listOfDataNodes[i].toLong();
       mitk::DataNode* node = static_cast<mitk::DataNode *>((void*) val);
       vectorOfDataNodePointers.push_back(node);
     }
 
     emit NodesDropped(this, vectorOfDataNodePointers);
   }
 }
 
 mitk::Point2D QmitkRenderWindow::GetMousePosition(QMouseEvent* me)
 {
 
   mitk::Point2D point;
   point[0] = me->x();
   point[1] = me->y();
   return point;
 }
 
 mitk::Point2D QmitkRenderWindow::GetMousePosition(QWheelEvent* we)
 {
   mitk::Point2D point;
   point[0] = we->x();
   point[1] = we->y();
   return point;
 }
 
 mitk::MouseButtons QmitkRenderWindow::GetEventButton(QMouseEvent* me)
 {
   mitk::MouseButtons eventButton;
   switch (me->button())
   {
   case Qt::LeftButton:
     eventButton = mitk::LeftMouseButton;
     break;
   case Qt::RightButton:
     eventButton = mitk::RightMouseButton;
     break;
   case Qt::MidButton:
     eventButton = mitk::MiddleMouseButton;
     break;
   default:
     eventButton = mitk::NoButton;
     break;
   }
   return eventButton;
 }
 
 mitk::MouseButtons QmitkRenderWindow::GetButtonState(QMouseEvent* me)
 {
   mitk::MouseButtons buttonState = mitk::NoButton;
 
   if (me->buttons() & Qt::LeftButton)
   {
     buttonState = buttonState | mitk::LeftMouseButton;
   }
   if (me->buttons() & Qt::RightButton)
   {
     buttonState = buttonState | mitk::RightMouseButton;
   }
   if (me->buttons() & Qt::MidButton)
   {
     buttonState = buttonState | mitk::MiddleMouseButton;
   }
   return buttonState;
 }
 
 mitk::ModifierKeys QmitkRenderWindow::GetModifiers(QMouseEvent* me)
 {
   mitk::ModifierKeys modifiers = mitk::NoKey;
 
   if (me->modifiers() & Qt::ALT)
   {
     modifiers = modifiers | mitk::AltKey;
   }
   if (me->modifiers() & Qt::CTRL)
   {
     modifiers = modifiers | mitk::ControlKey;
   }
   if (me->modifiers() & Qt::SHIFT)
   {
     modifiers = modifiers | mitk::ShiftKey;
   }
   return modifiers;
 }
 
 mitk::MouseButtons QmitkRenderWindow::GetButtonState(QWheelEvent* we)
 {
   mitk::MouseButtons buttonState = mitk::NoButton;
 
   if (we->buttons() & Qt::LeftButton)
   {
     buttonState = buttonState | mitk::RightMouseButton;
   }
   if (we->buttons() & Qt::RightButton)
   {
     buttonState = buttonState | mitk::LeftMouseButton;
   }
   if (we->buttons() & Qt::MidButton)
   {
     buttonState = buttonState | mitk::MiddleMouseButton;
   }
   return buttonState;
 }
 
 mitk::ModifierKeys QmitkRenderWindow::GetModifiers(QWheelEvent* we)
 {
   mitk::ModifierKeys modifiers = mitk::NoKey;
 
   if (we->modifiers() & Qt::ALT)
   {
     modifiers = modifiers | mitk::AltKey;
   }
   if (we->modifiers() & Qt::CTRL)
   {
     modifiers = modifiers | mitk::ControlKey;
   }
   if (we->modifiers() & Qt::SHIFT)
   {
     modifiers = modifiers | mitk::ShiftKey;
   }
 
   return modifiers;
 }
 
 mitk::ModifierKeys QmitkRenderWindow::GetModifiers(QKeyEvent* ke)
 {
   mitk::ModifierKeys modifiers = mitk::NoKey;
 
   if (ke->modifiers() & Qt::ShiftModifier)
     modifiers = modifiers | mitk::ShiftKey;
   if (ke->modifiers() & Qt::CTRL)
     modifiers = modifiers | mitk::ControlKey;
   if (ke->modifiers() & Qt::ALT)
     modifiers = modifiers | mitk::AltKey;
 
   return modifiers;
 }
 
 std::string QmitkRenderWindow::GetKeyLetter(QKeyEvent *ke)
 {
   // Converting Qt Key Event to string element.
   std::string key = "";
   int tkey = ke->key();
   if (tkey < 128)
   { //standard ascii letter
     key = (char) toupper(tkey);
   }
   else
   { // special keys
     switch (tkey)
     {
     case Qt::Key_Return:
       key = mitk::KeyReturn;
       break;
     case Qt::Key_Enter:
       key = mitk::KeyEnter;
       break;
     case Qt::Key_Escape:
       key = mitk::KeyEnter;
       break;
     case Qt::Key_Delete:
       key = mitk::KeyDelete;
       break;
     case Qt::Key_Up:
       key = mitk::KeyArrowUp;
       break;
     case Qt::Key_Down:
       key = mitk::KeyArrowDown;
       break;
     case Qt::Key_Left:
       key = mitk::KeyArrowLeft;
       break;
     case Qt::Key_Right:
       key = mitk::KeyArrowRight;
       break;
 
     case Qt::Key_F1:
       key = mitk::KeyF1;
       break;
     case Qt::Key_F2:
       key = mitk::KeyF2;
       break;
     case Qt::Key_F3:
       key = mitk::KeyF3;
       break;
     case Qt::Key_F4:
       key = mitk::KeyF4;
       break;
     case Qt::Key_F5:
       key = mitk::KeyF5;
       break;
     case Qt::Key_F6:
       key = mitk::KeyF6;
       break;
     case Qt::Key_F7:
       key = mitk::KeyF7;
       break;
     case Qt::Key_F8:
       key = mitk::KeyF8;
       break;
     case Qt::Key_F9:
       key = mitk::KeyF9;
       break;
     case Qt::Key_F10:
       key = mitk::KeyF10;
       break;
     case Qt::Key_F11:
       key = mitk::KeyF11;
       break;
     case Qt::Key_F12:
       key = mitk::KeyF12;
       break;
 
     case Qt::Key_End:
-          key = mitk::KeyEend;
+          key = mitk::KeyEnd;
           break;
     case Qt::Key_Home:
           key = mitk::KeyPos1;
           break;
     case Qt::Key_Insert:
           key = mitk::KeyInsert;
           break;
     case Qt::Key_PageDown:
           key = mitk::KeyPageDown;
           break;
     case Qt::Key_PageUp:
           key = mitk::KeyPageUp;
           break;
+    case Qt::Key_Space:
+          key = mitk::KeySpace;
+          break;
     }
   }
   return key;
 }
 
 int QmitkRenderWindow::GetDelta(QWheelEvent* we)
 {
   return we->delta();
 }