diff --git a/Core/Code/Interactions/mitkEventFactory.cpp b/Core/Code/Interactions/mitkEventFactory.cpp
index 31a2e08c7a..762bf34974 100755
--- a/Core/Code/Interactions/mitkEventFactory.cpp
+++ b/Core/Code/Interactions/mitkEventFactory.cpp
@@ -1,224 +1,230 @@
 /*===================================================================
 
  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 "mitkEventFactory.h"
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <mitkMousePressEvent.h>
+#include <mitkMouseDoubleClickEvent.h>
 #include <mitkMouseMoveEvent.h>
 #include <mitkMouseReleaseEvent.h>
 #include <mitkMouseWheelEvent.h>
 #include <mitkInteractionKeyEvent.h>
 #include <mitkInteractionEventConst.h>
 #include <mitkInteractionPositionEvent.h>
 #include <mitkInternalEvent.h>
 
 namespace
 {
   std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems)
   {
     std::stringstream ss(s);
     std::string item;
     while (std::getline(ss, item, delim))
     {
       elems.push_back(item);
     }
     return elems;
   }
 
   std::vector<std::string> split(const std::string &s, char delim)
   {
     std::vector < std::string > elems;
     return split(s, delim, elems);
   }
 }
 
 mitk::InteractionEvent::Pointer mitk::EventFactory::CreateEvent(PropertyList::Pointer list)
 {
 //
   std::string eventClass, eventVariant;
   list->GetStringProperty(InteractionEventConst::xmlParameterEventClass().c_str(), eventClass);
   list->GetStringProperty(InteractionEventConst::xmlParameterEventVariant().c_str(), eventVariant);
 
 // Query all possible attributes, if they are not present, set their default values.
 // Position Events & Key Events
   std::string strModifiers;
   InteractionEvent::ModifierKeys modifiers = InteractionEvent::NoKey;
   std::string strEventButton;
   InteractionEvent::MouseButtons eventButton = InteractionEvent::NoButton;
   std::string strButtonState;
   InteractionEvent::MouseButtons buttonState = InteractionEvent::NoButton;
   std::string strKey;
   std::string key;
   std::string strWheelDelta;
   int wheelDelta;
   std::string strSignalName = "";
 
   Point2D pos;
   pos.Fill(0);
 
 // Parse modifier information
   if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyModifier().c_str(), strModifiers))
   {
     std::vector<std::string> mods = split(strModifiers, ',');
     for (std::vector<std::string>::iterator it = mods.begin(); it != mods.end(); ++it)
     {
       std::transform((*it).begin(), (*it).end(), (*it).begin(), ::toupper);
       if (*it == "CTRL")
       {
         modifiers = modifiers | InteractionEvent::ControlKey;
       }
       else if (*it == "ALT")
       {
         modifiers = modifiers | InteractionEvent::AltKey;
       }
       else if (*it == "SHIFT")
       {
         modifiers = modifiers | InteractionEvent::ShiftKey;
       }
       else
       {
         MITK_WARN<< "mitkEventFactory: Invalid event modifier in config file :" << (*it);
       }
     }
   }
 
 // Set EventButton
   if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyEventButton().c_str(), strEventButton))
   {
     std::transform(strEventButton.begin(), strEventButton.end(), strEventButton.begin(), ::toupper);
     if (strEventButton == "MIDDLEMOUSEBUTTON")
     {
       eventButton = InteractionEvent::MiddleMouseButton;
     }
     else if (strEventButton == "LEFTMOUSEBUTTON")
     {
       eventButton = InteractionEvent::LeftMouseButton;
     }
     else if (strEventButton == "RIGHTMOUSEBUTTON")
     {
       eventButton = InteractionEvent::RightMouseButton;
     }
     else
     {
       MITK_WARN<< "mitkEventFactory: Invalid event button in config file: " << strEventButton;
     }
   }
 
 // Parse ButtonStates
   if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyButtonState().c_str(), strButtonState))
   {
     std::vector<std::string> mods = split(strButtonState, ',');
     for (std::vector<std::string>::iterator it = mods.begin(); it != mods.end(); ++it)
     {
       std::transform((*it).begin(), (*it).end(), (*it).begin(), ::toupper);
       if (*it == "MIDDLEMOUSEBUTTON")
       {
         buttonState = buttonState | InteractionEvent::MiddleMouseButton;
       }
       else if (*it == "LEFTMOUSEBUTTON")
       {
         buttonState = buttonState | InteractionEvent::LeftMouseButton;
       }
       else if (*it == "RIGHTMOUSEBUTTON")
       {
         buttonState = buttonState | InteractionEvent::RightMouseButton;
       }
       else
       {
         MITK_WARN<< "mitkEventFactory: Invalid event buttonstate in config file:" << (*it);
       }
     }
   }
 
 // Key
   if (!list->GetStringProperty(InteractionEventConst::xmlEventPropertyKey().c_str(), strKey))
   {
     key = "";
   }
   else
   {
     key = strKey;
   }
 // WheelDelta
   if (!list->GetStringProperty(InteractionEventConst::xmlEventPropertyScrollDirection().c_str(), strWheelDelta))
   {
     wheelDelta = 0;
   }
   else
   {
     std::transform(strWheelDelta.begin(), strWheelDelta.end(), strWheelDelta.begin(), ::toupper);
     if (strWheelDelta == "DOWN")
     {
       wheelDelta = -1;
     }
     else
     {
       wheelDelta = 1;
     }
   }
 // Internal Signals Name
   list->GetStringProperty(InteractionEventConst::xmlEventPropertySignalName().c_str(), strSignalName);
 
   /*
    * Here the objects are created
    */
 
   mitk::InteractionEvent::Pointer event;
   std::transform(eventClass.begin(), eventClass.end(), eventClass.begin(), ::toupper);
 
   if (eventClass == "MOUSEPRESSEVENT")
   {
     // buttonstates incorporate the event button (as in Qt)
     buttonState = buttonState | eventButton;
     event = MousePressEvent::New(NULL, pos, buttonState, modifiers, eventButton);
   }
+  else if (eventClass == "MOUSEDOUBLECLICKEVENT")
+  {
+    buttonState = buttonState | eventButton;
+    event = MouseDoubleClickEvent::New(NULL, pos, buttonState, modifiers, eventButton);
+  }
   else if (eventClass == "MOUSEMOVEEVENT")
   {
     event = MouseMoveEvent::New(NULL, pos, buttonState, modifiers);
   }
   else if (eventClass == "MOUSERELEASEEVENT")
   {
     event = MouseReleaseEvent::New(NULL, pos, buttonState, modifiers, eventButton);
   }
   else if (eventClass == "INTERACTIONKEYEVENT")
   {
     event = InteractionKeyEvent::New(NULL, key, modifiers);
   }
   else if (eventClass == "MOUSEWHEELEVENT")
   {
     event = MouseWheelEvent::New(NULL, pos, buttonState, modifiers, wheelDelta);
   }
   else if (eventClass == "INTERACTIONPOSITIONEVENT")
   {
     event = InteractionPositionEvent::New(NULL, pos);
   }
   else if (eventClass == "INTERNALEVENT")
   {
     event = InternalEvent::New(NULL, NULL, strSignalName);
   }
   else if (eventClass == "INTERACTIONEVENT")
   {
     event = InteractionEvent::New(NULL);
   }
   if (event.IsNull())
   {
     MITK_WARN<< "Event couldn't be constructed. Please check your StateMachine patterns and config files\n for the following event class, which is not valid: " << eventClass;
     return NULL;
   }
   return event;
 }
diff --git a/Core/Code/Interactions/mitkMouseDoubleClickEvent.cpp b/Core/Code/Interactions/mitkMouseDoubleClickEvent.cpp
new file mode 100644
index 0000000000..70103198f7
--- /dev/null
+++ b/Core/Code/Interactions/mitkMouseDoubleClickEvent.cpp
@@ -0,0 +1,77 @@
+/*===================================================================
+
+ 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 "mitkException.h"
+#include "mitkMouseDoubleClickEvent.h"
+
+mitk::MouseDoubleClickEvent::MouseDoubleClickEvent(mitk::BaseRenderer* baseRenderer,
+    const mitk::Point2D& mousePosition,
+    MouseButtons buttonStates,
+    ModifierKeys modifiers,
+    MouseButtons eventButton)
+: InteractionPositionEvent(baseRenderer, mousePosition)
+, m_EventButton(eventButton)
+, m_ButtonStates(buttonStates)
+, m_Modifiers( modifiers)
+{
+}
+
+mitk::InteractionEvent::MouseButtons mitk::MouseDoubleClickEvent::GetEventButton() const
+{
+  return m_EventButton;
+}
+
+void mitk::MouseDoubleClickEvent::SetEventButton(MouseButtons buttons)
+{
+  m_EventButton = buttons;
+}
+
+mitk::InteractionEvent::ModifierKeys mitk::MouseDoubleClickEvent::GetModifiers() const
+{
+  return m_Modifiers;
+}
+
+mitk::InteractionEvent::MouseButtons mitk::MouseDoubleClickEvent::GetButtonStates() const
+{
+  return m_ButtonStates;
+}
+
+void mitk::MouseDoubleClickEvent::SetModifiers(ModifierKeys modifiers)
+{
+  m_Modifiers = modifiers;
+}
+
+void mitk::MouseDoubleClickEvent::SetButtonStates(MouseButtons buttons)
+{
+  m_ButtonStates = buttons;
+}
+
+mitk::MouseDoubleClickEvent::~MouseDoubleClickEvent()
+{
+}
+
+bool mitk::MouseDoubleClickEvent::IsEqual(const mitk::InteractionEvent& interactionEvent) const
+{
+  const mitk::MouseDoubleClickEvent& mpe = static_cast<const mitk::MouseDoubleClickEvent&>(interactionEvent);
+  return (this->GetEventButton() == mpe.GetEventButton() && this->GetModifiers() == mpe.GetModifiers()
+          && this->GetButtonStates() == mpe.GetButtonStates() &&
+          Superclass::IsEqual(interactionEvent));
+}
+
+bool mitk::MouseDoubleClickEvent::IsSuperClassOf(const InteractionEvent::Pointer& baseClass) const
+{
+  return (dynamic_cast<MouseDoubleClickEvent*>(baseClass.GetPointer()) != NULL) ;
+}
diff --git a/Core/Code/Interactions/mitkMouseDoubleClickEvent.h b/Core/Code/Interactions/mitkMouseDoubleClickEvent.h
new file mode 100644
index 0000000000..408fb5878b
--- /dev/null
+++ b/Core/Code/Interactions/mitkMouseDoubleClickEvent.h
@@ -0,0 +1,63 @@
+/*===================================================================
+
+ 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 MITKMouseDoubleClickEvent_H_
+#define MITKMouseDoubleClickEvent_H_
+
+#include "itkObject.h"
+#include "itkObjectFactory.h"
+#include "mitkCommon.h"
+#include "mitkInteractionEventConst.h"
+#include "mitkInteractionPositionEvent.h"
+#include "mitkBaseRenderer.h"
+#include "mitkInteractionEvent.h"
+
+#include <MitkExports.h>
+
+namespace mitk
+{
+
+  class MITK_CORE_EXPORT MouseDoubleClickEvent: public InteractionPositionEvent
+  {
+
+  public:
+    mitkClassMacro(MouseDoubleClickEvent,InteractionPositionEvent)
+    mitkNewMacro5Param(Self, BaseRenderer*, const Point2D& , MouseButtons , ModifierKeys, MouseButtons)
+
+    ModifierKeys GetModifiers() const;
+    MouseButtons GetButtonStates() const;
+    void SetModifiers(ModifierKeys modifiers);
+    void SetButtonStates(MouseButtons buttons);
+    MouseButtons GetEventButton() const;
+    void SetEventButton(MouseButtons buttons);
+
+    virtual bool IsSuperClassOf(const InteractionEvent::Pointer& baseClass) const;
+
+  protected:
+    MouseDoubleClickEvent(BaseRenderer*, const Point2D& = Point2D(), MouseButtons buttonStates = NoButton,
+                    ModifierKeys modifiers = NoKey, MouseButtons eventButton = NoButton);
+    virtual ~MouseDoubleClickEvent();
+
+    virtual bool IsEqual(const InteractionEvent&) const;
+
+  private:
+    MouseButtons m_EventButton;
+    MouseButtons m_ButtonStates;
+    ModifierKeys m_Modifiers;
+  };
+} /* namespace mitk */
+
+#endif /* MITKMouseDoubleClickEvent_H_ */
diff --git a/Core/Code/files.cmake b/Core/Code/files.cmake
index 68c903a914..2476d69eb7 100644
--- a/Core/Code/files.cmake
+++ b/Core/Code/files.cmake
@@ -1,363 +1,364 @@
 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
 
   Rendering/mitkLocalStorageHandler.h
 
   IO/mitkPixelTypeTraits.h
 )
 
 set(CPP_FILES
   Algorithms/mitkBaseDataSource.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
   DataManagement/mitkPointSetShapeProperty.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/mitkInteractionEventConst.cpp
   Interactions/mitkInteractionPositionEvent.cpp
   Interactions/mitkInteractionKeyEvent.cpp
   Interactions/mitkMousePressEvent.cpp
   Interactions/mitkMouseMoveEvent.cpp
   Interactions/mitkMouseReleaseEvent.cpp
   Interactions/mitkMouseWheelEvent.cpp
+  Interactions/mitkMouseDoubleClickEvent.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/mitkPointSetVtkMapper2D.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
 
 Shaders/mitkShaderLighting.xml
 
 mitkLevelWindowPresets.xml
 )
diff --git a/Modules/Qmitk/QmitkRenderWindow.cpp b/Modules/Qmitk/QmitkRenderWindow.cpp
index e86f813537..9247f9d5b2 100644
--- a/Modules/Qmitk/QmitkRenderWindow.cpp
+++ b/Modules/Qmitk/QmitkRenderWindow.cpp
@@ -1,542 +1,560 @@
 /*===================================================================
 
  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 "mitkMouseDoubleClickEvent.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::mouseDoubleClickEvent( QMouseEvent *me )
+{
+  mitk::MouseDoubleClickEvent::Pointer mPressEvent = mitk::MouseDoubleClickEvent::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::InteractionEvent::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) const
 {
 
   mitk::Point2D point;
   point[0] = me->x();
   point[1] = me->y();
   return point;
 }
 
 mitk::Point2D QmitkRenderWindow::GetMousePosition(QWheelEvent* we) const
 {
   mitk::Point2D point;
   point[0] = we->x();
   point[1] = we->y();
   return point;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetEventButton(QMouseEvent* me) const
 {
   mitk::InteractionEvent::MouseButtons eventButton;
   switch (me->button())
   {
   case Qt::LeftButton:
     eventButton = mitk::InteractionEvent::LeftMouseButton;
     break;
   case Qt::RightButton:
     eventButton = mitk::InteractionEvent::RightMouseButton;
     break;
   case Qt::MidButton:
     eventButton = mitk::InteractionEvent::MiddleMouseButton;
     break;
   default:
     eventButton = mitk::InteractionEvent::NoButton;
     break;
   }
   return eventButton;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QMouseEvent* me) const
 {
   mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
 
   if (me->buttons() & Qt::LeftButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
   }
   if (me->buttons() & Qt::RightButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
   }
   if (me->buttons() & Qt::MidButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
   }
   return buttonState;
 }
 
 mitk::InteractionEvent::ModifierKeys QmitkRenderWindow::GetModifiers(QMouseEvent* me) const
 {
   mitk::InteractionEvent::ModifierKeys modifiers = mitk::InteractionEvent::NoKey;
 
   if (me->modifiers() & Qt::ALT)
   {
     modifiers = modifiers | mitk::InteractionEvent::AltKey;
   }
   if (me->modifiers() & Qt::CTRL)
   {
     modifiers = modifiers | mitk::InteractionEvent::ControlKey;
   }
   if (me->modifiers() & Qt::SHIFT)
   {
     modifiers = modifiers | mitk::InteractionEvent::ShiftKey;
   }
   return modifiers;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QWheelEvent* we) const
 {
   mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
 
   if (we->buttons() & Qt::LeftButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
   }
   if (we->buttons() & Qt::RightButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
   }
   if (we->buttons() & Qt::MidButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
   }
   return buttonState;
 }
 
 mitk::InteractionEvent::ModifierKeys QmitkRenderWindow::GetModifiers(QWheelEvent* we) const
 {
   mitk::InteractionEvent::ModifierKeys modifiers = mitk::InteractionEvent::NoKey;
 
   if (we->modifiers() & Qt::ALT)
   {
     modifiers = modifiers | mitk::InteractionEvent::AltKey;
   }
   if (we->modifiers() & Qt::CTRL)
   {
     modifiers = modifiers | mitk::InteractionEvent::ControlKey;
   }
   if (we->modifiers() & Qt::SHIFT)
   {
     modifiers = modifiers | mitk::InteractionEvent::ShiftKey;
   }
 
   return modifiers;
 }
 
 mitk::InteractionEvent::ModifierKeys QmitkRenderWindow::GetModifiers(QKeyEvent* ke) const
 {
   mitk::InteractionEvent::ModifierKeys modifiers = mitk::InteractionEvent::NoKey;
 
   if (ke->modifiers() & Qt::ShiftModifier)
     modifiers = modifiers | mitk::InteractionEvent::ShiftKey;
   if (ke->modifiers() & Qt::CTRL)
     modifiers = modifiers | mitk::InteractionEvent::ControlKey;
   if (ke->modifiers() & Qt::ALT)
     modifiers = modifiers | mitk::InteractionEvent::AltKey;
 
   return modifiers;
 }
 
 std::string QmitkRenderWindow::GetKeyLetter(QKeyEvent *ke) const
 {
   // 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::InteractionEvent::KeyReturn;
       break;
     case Qt::Key_Enter:
       key = mitk::InteractionEvent::KeyEnter;
       break;
     case Qt::Key_Escape:
       key = mitk::InteractionEvent::KeyEnter;
       break;
     case Qt::Key_Delete:
       key = mitk::InteractionEvent::KeyDelete;
       break;
     case Qt::Key_Up:
       key = mitk::InteractionEvent::KeyArrowUp;
       break;
     case Qt::Key_Down:
       key = mitk::InteractionEvent::KeyArrowDown;
       break;
     case Qt::Key_Left:
       key = mitk::InteractionEvent::KeyArrowLeft;
       break;
     case Qt::Key_Right:
       key = mitk::InteractionEvent::KeyArrowRight;
       break;
 
     case Qt::Key_F1:
       key = mitk::InteractionEvent::KeyF1;
       break;
     case Qt::Key_F2:
       key = mitk::InteractionEvent::KeyF2;
       break;
     case Qt::Key_F3:
       key = mitk::InteractionEvent::KeyF3;
       break;
     case Qt::Key_F4:
       key = mitk::InteractionEvent::KeyF4;
       break;
     case Qt::Key_F5:
       key = mitk::InteractionEvent::KeyF5;
       break;
     case Qt::Key_F6:
       key = mitk::InteractionEvent::KeyF6;
       break;
     case Qt::Key_F7:
       key = mitk::InteractionEvent::KeyF7;
       break;
     case Qt::Key_F8:
       key = mitk::InteractionEvent::KeyF8;
       break;
     case Qt::Key_F9:
       key = mitk::InteractionEvent::KeyF9;
       break;
     case Qt::Key_F10:
       key = mitk::InteractionEvent::KeyF10;
       break;
     case Qt::Key_F11:
       key = mitk::InteractionEvent::KeyF11;
       break;
     case Qt::Key_F12:
       key = mitk::InteractionEvent::KeyF12;
       break;
 
     case Qt::Key_End:
           key = mitk::InteractionEvent::KeyEnd;
           break;
     case Qt::Key_Home:
           key = mitk::InteractionEvent::KeyPos1;
           break;
     case Qt::Key_Insert:
           key = mitk::InteractionEvent::KeyInsert;
           break;
     case Qt::Key_PageDown:
           key = mitk::InteractionEvent::KeyPageDown;
           break;
     case Qt::Key_PageUp:
           key = mitk::InteractionEvent::KeyPageUp;
           break;
     case Qt::Key_Space:
           key = mitk::InteractionEvent::KeySpace;
           break;
     }
   }
   return key;
 }
 
 int QmitkRenderWindow::GetDelta(QWheelEvent* we) const
 {
   return we->delta();
 }
diff --git a/Modules/Qmitk/QmitkRenderWindow.h b/Modules/Qmitk/QmitkRenderWindow.h
index b41332a344..bfdb2d0804 100644
--- a/Modules/Qmitk/QmitkRenderWindow.h
+++ b/Modules/Qmitk/QmitkRenderWindow.h
@@ -1,180 +1,181 @@
 /*===================================================================
 
  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 QMITKRENDERWINDOW_H_HEADER_INCLUDED_C1C40D66
 #define QMITKRENDERWINDOW_H_HEADER_INCLUDED_C1C40D66
 
 #include "mitkRenderWindowBase.h"
 
 #include <QmitkExports.h>
 #include "QVTKWidget.h"
 #include "QmitkRenderWindowMenu.h"
 
 #include "mitkInteractionEventConst.h"
 
 
 class QmitkStdMultiWidget;
 class QDragEnterEvent;
 class QDropEvent;
 
 /**
  * \ingroup QmitkModule
  * \brief MITK implementation of the QVTKWidget
  */
 class QMITK_EXPORT QmitkRenderWindow: public QVTKWidget, public mitk::RenderWindowBase
 {
 Q_OBJECT
 
 public:
 
   QmitkRenderWindow(QWidget *parent = 0, QString name = "unnamed renderwindow", mitk::VtkPropRenderer* renderer = NULL,
       mitk::RenderingManager* renderingManager = NULL);
   virtual ~QmitkRenderWindow();
 
   /**
    * \brief Whether Qt events should be passed to parent (default: true)
    *
    * With introduction of the QVTKWidget the behaviour regarding Qt events changed.
    * QVTKWidget "accepts" Qt events like mouse clicks (i.e. set an "accepted" flag).
    * When this flag is set, Qt fininshed handling of this event -- otherwise it is
    * reached through to the widget's parent.
    *
    * This reaching through to the parent was implicitly required by QmitkMaterialWidget / QmitkMaterialShowCase.
    *QmitkStdMultiWidget
    * The default behaviour of QmitkRenderWindow is now to clear the "accepted" flag
    * of Qt events after they were handled by QVTKWidget. This way parents can also
    * handle events.
    *
    * If you don't want this behaviour, call SetResendQtEvents(true) on your render window.
    */
   virtual void SetResendQtEvents(bool resend);
 
   // Set Layout Index to define the Layout Type
   void SetLayoutIndex(unsigned int layoutIndex);
 
   // Get Layout Index to define the Layout Type
   unsigned int GetLayoutIndex();
 
   //MenuWidget need to update the Layout Design List when Layout had changed
   void LayoutDesignListChanged(int layoutDesignIndex);
 
   void HideRenderWindowMenu();
 
   //Activate or Deactivate MenuWidget.
   void ActivateMenuWidget(bool state, QmitkStdMultiWidget* stdMultiWidget = 0);
 
   bool GetActivateMenuWidgetFlag()
   {
     return m_MenuWidgetActivated;
   }
 
   // Get it from the QVTKWidget parent
   virtual vtkRenderWindow* GetVtkRenderWindow()
   {
     return GetRenderWindow();
   }
 
   virtual vtkRenderWindowInteractor* GetVtkRenderWindowInteractor()
   {
     return NULL;
   }
 
   void FullScreenMode(bool state);
 
 protected:
   // overloaded move handler
   virtual void moveEvent(QMoveEvent* event);
   // overloaded show handler
   void showEvent(QShowEvent* event);
   // overloaded resize handler
   virtual void resizeEvent(QResizeEvent* event);
   // overloaded paint handler
   virtual void paintEvent(QPaintEvent* event);
   // overloaded mouse press handler
   virtual void mousePressEvent(QMouseEvent* event);
+  // overloaded mouse double-click handler
+  virtual void mouseDoubleClickEvent( QMouseEvent *event );
   // overloaded mouse move handler
   virtual void mouseMoveEvent(QMouseEvent* event);
   // overloaded mouse release handler
   virtual void mouseReleaseEvent(QMouseEvent* event);
   // overloaded key press handler
   virtual void keyPressEvent(QKeyEvent* event);
   // overloaded enter handler
   virtual void enterEvent(QEvent*);
   // overloaded leave handler
   virtual void leaveEvent(QEvent*);
 
   /// \brief Simply says we accept the event type.
   virtual void dragEnterEvent(QDragEnterEvent *event);
 
   /// \brief If the dropped type is application/x-mitk-datanodes we process the request by converting to mitk::DataNode pointers and emitting the NodesDropped signal.
   virtual void dropEvent(QDropEvent * event);
 
 #ifndef QT_NO_WHEELEVENT
   // overload wheel mouse event
   virtual void wheelEvent(QWheelEvent*);
 #endif
 
   void AdjustRenderWindowMenuVisibility(const QPoint& pos);
 
 signals:
 
   void ResetView();
   // \brief int parameters are enum from QmitkStdMultiWidget
   void ChangeCrosshairRotationMode(int);
 
   void SignalLayoutDesignChanged(int layoutDesignIndex);
 
   void moved();
 
   void resized();
 
   /// \brief Emits a signal to say that this window has had the following nodes dropped on it.
   void NodesDropped(QmitkRenderWindow *thisWindow, std::vector<mitk::DataNode*> nodes);
 
 protected slots:
 
   void OnChangeLayoutDesign(int layoutDesignIndex);
 
   void OnWidgetPlaneModeChanged(int);
 
   void DeferredHideMenu();
 
 private:
 
   // Helper Functions to Convert Qt-Events to Mitk-Events
 
   mitk::Point2D GetMousePosition(QMouseEvent* me) const;
   mitk::Point2D GetMousePosition(QWheelEvent* we) const;
   mitk::InteractionEvent::MouseButtons GetEventButton(QMouseEvent* me) const;
   mitk::InteractionEvent::MouseButtons GetButtonState(QMouseEvent* me) const;
   mitk::InteractionEvent::ModifierKeys GetModifiers(QMouseEvent* me) const;
   mitk::InteractionEvent::MouseButtons GetButtonState(QWheelEvent* we) const;
   mitk::InteractionEvent::ModifierKeys GetModifiers(QWheelEvent* we) const;
   mitk::InteractionEvent::ModifierKeys GetModifiers(QKeyEvent* ke) const;
   std::string GetKeyLetter(QKeyEvent* ke) const;
   int GetDelta(QWheelEvent* we) const;
-
   bool m_ResendQtEvents;
 
   QmitkRenderWindowMenu* m_MenuWidget;
 
   bool m_MenuWidgetActivated;
 
   unsigned int m_LayoutIndex;
 
 };
 
 #endif