diff --git a/Core/Code/DataManagement/mitkPropertyList.cpp b/Core/Code/DataManagement/mitkPropertyList.cpp
index 4aa8c37cd3..2cbcd4a2ef 100644
--- a/Core/Code/DataManagement/mitkPropertyList.cpp
+++ b/Core/Code/DataManagement/mitkPropertyList.cpp
@@ -1,358 +1,352 @@
 /*===================================================================
 
 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 "mitkPropertyList.h"
 
 #include "mitkProperties.h"
 #include "mitkStringProperty.h"
 #include "mitkNumericTypes.h"
 
 
 mitk::BaseProperty* mitk::PropertyList::GetProperty(const std::string& propertyKey) const
 {
     PropertyMap::const_iterator it;
 
     it=m_Properties.find( propertyKey );
     if(it!=m_Properties.end())
       return it->second;
     else
         return NULL;
 }
 
 
 void mitk::PropertyList::SetProperty(const std::string& propertyKey, BaseProperty* property)
 {
   if (!property) return;
   //make sure that BaseProperty*, which may have just been created and never been
   //assigned to a SmartPointer, is registered/unregistered properly. If we do not
   //do that, it will a) not deleted in case it is identical to the old one or
   //b) possibly deleted when temporarily added to a smartpointer somewhere below.
   BaseProperty::Pointer tmpSmartPointerToProperty = property;
 
   PropertyMap::iterator it( m_Properties.find( propertyKey ) );
 
   // Is a property with key @a propertyKey contained in the list?
   if( it != m_Properties.end() )
   {
     // yes
     //is the property contained in the list identical to the new one?
     if( it->second->operator==(*property) )
     {
       // yes? do nothing and return.
       return;
     }
 
     if (it->second->AssignProperty(*property))
     {
       // The assignment was successfull
       this->Modified();
     }
     else
     {
       MITK_ERROR << "In " __FILE__ ", l." << __LINE__
                  << ": Trying to set existing property " << it->first << " of type " << it->second->GetNameOfClass()
                  << " to a property with different type " << property->GetNameOfClass() << "."
                  << " Use ReplaceProperty() instead."
                  << std::endl;
     }
     return;
   }
 
   //no? add it.
-  PropertyMapElementType newProp;
-  newProp.first = propertyKey;
-  newProp.second = property;
-  m_Properties.insert ( newProp );
+  m_Properties.insert( PropertyMap::value_type(propertyKey, property) );
   this->Modified();
 }
 
 
 void mitk::PropertyList::ReplaceProperty(const std::string& propertyKey, BaseProperty* property)
 {
   if (!property) return;
 
   PropertyMap::iterator it( m_Properties.find( propertyKey ) );
 
   // Is a property with key @a propertyKey contained in the list?
   if( it != m_Properties.end() )
   {
     it->second=NULL;
     m_Properties.erase(it);
   }
 
   //no? add/replace it.
-  PropertyMapElementType newProp;
-  newProp.first = propertyKey;
-  newProp.second = property;
-  m_Properties.insert ( newProp );
+  m_Properties.insert( PropertyMap::value_type(propertyKey, property) );
   Modified();
 }
 
 
 mitk::PropertyList::PropertyList()
 {
 }
 
 mitk::PropertyList::PropertyList(const mitk::PropertyList& other)
   : itk::Object()
 {
   for (PropertyMap::const_iterator i = other.m_Properties.begin();
        i != other.m_Properties.end(); ++i)
   {
     m_Properties.insert(std::make_pair(i->first, i->second->Clone()));
   }
 }
 
 
 mitk::PropertyList::~PropertyList()
 {
   Clear();
 }
 
 
 /**
  * Consider the list as changed when any of the properties has changed recently.
  */
 unsigned long mitk::PropertyList::GetMTime() const
 {
   for ( PropertyMap::const_iterator it = m_Properties.begin() ;
         it != m_Properties.end();
         ++it )
   {
     if( it->second.IsNull() )
     {
       itkWarningMacro(<< "Property '" << it->first <<"' contains nothing (NULL).");
       continue;
     }
     if( Superclass::GetMTime() < it->second->GetMTime() )
     {
       Modified();
       break;
     }
   }
 
   return Superclass::GetMTime();
 }
 
 
 bool mitk::PropertyList::DeleteProperty(const std::string& propertyKey)
 {
   PropertyMap::iterator it;
   it=m_Properties.find( propertyKey );
 
   if(it!=m_Properties.end())
   {
     it->second=NULL;
     m_Properties.erase(it);
     Modified();
     return true;
   }
   return false;
 }
 
 
 void mitk::PropertyList::Clear()
 {
   PropertyMap::iterator it = m_Properties.begin(), end = m_Properties.end();
   while(it!=end)
   {
     it->second = NULL;
     ++it;
   }
   m_Properties.clear();
 }
 
 itk::LightObject::Pointer mitk::PropertyList::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
   result->UnRegister();
   return result;
 }
 
 void mitk::PropertyList::ConcatenatePropertyList(PropertyList *pList, bool replace)
 {
   if (pList)
   {
     const PropertyMap* propertyMap = pList->GetMap();
 
     for ( PropertyMap::const_iterator iter = propertyMap->begin(); // m_PropertyList is created in the constructor, so we don't check it here
           iter != propertyMap->end();
           ++iter )
     {
       const std::string key = iter->first;
       BaseProperty* value = iter->second;
       if (replace)
       {
         ReplaceProperty( key.c_str(), value );
       }
       else
       {
         SetProperty( key.c_str(), value );
       }
     }
   }
 }
 
 bool mitk::PropertyList::GetBoolProperty(const char* propertyKey, bool& boolValue) const
 {
   BoolProperty *gp = dynamic_cast<BoolProperty*>( GetProperty(propertyKey) );
   if ( gp != NULL )
   {
     boolValue = gp->GetValue();
     return true;
   }
   return false;
   // Templated Method does not work on Macs
   //return GetPropertyValue<bool>(propertyKey, boolValue);
 }
 
 
 bool mitk::PropertyList::GetIntProperty(const char* propertyKey, int &intValue) const
 {
   IntProperty *gp = dynamic_cast<IntProperty*>( GetProperty(propertyKey) );
   if ( gp != NULL )
   {
     intValue = gp->GetValue();
     return true;
   }
   return false;
   // Templated Method does not work on Macs
   //return GetPropertyValue<int>(propertyKey, intValue);
 }
 
 
 bool mitk::PropertyList::GetFloatProperty(const char* propertyKey, float &floatValue) const
 {
   FloatProperty *gp = dynamic_cast<FloatProperty*>( GetProperty(propertyKey) );
   if ( gp != NULL )
   {
     floatValue = gp->GetValue();
     return true;
   }
   return false;
   // Templated Method does not work on Macs
   //return GetPropertyValue<float>(propertyKey, floatValue);
 }
 
 
 bool mitk::PropertyList::GetStringProperty(const char* propertyKey, std::string& stringValue) const
 {
   StringProperty* sp= dynamic_cast<StringProperty*>(GetProperty(propertyKey));
   if ( sp != NULL )
   {
     stringValue = sp->GetValue();
     return true;
   }
   return false;
 }
 
 
 void mitk::PropertyList::SetIntProperty(const char* propertyKey, int intValue)
 {
   SetProperty(propertyKey, mitk::IntProperty::New(intValue));
 }
 
 
 void mitk::PropertyList::SetBoolProperty( const char* propertyKey, bool boolValue)
 {
   SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
 }
 
 
 void mitk::PropertyList::SetFloatProperty( const char* propertyKey, float floatValue)
 {
   SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
 }
 
 
 void mitk::PropertyList::SetStringProperty( const char* propertyKey, const char* stringValue)
 {
   SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
 }
 
 void mitk::PropertyList::Set( const char* propertyKey, bool boolValue )
 {
     this->SetBoolProperty( propertyKey, boolValue );
 }
 
 void mitk::PropertyList::Set( const char* propertyKey, int intValue )
 {
     this->SetIntProperty(propertyKey, intValue);
 }
 
 void mitk::PropertyList::Set( const char* propertyKey, float floatValue )
 {
     this->SetFloatProperty(propertyKey, floatValue);
 }
 
 void mitk::PropertyList::Set( const char* propertyKey, double doubleValue )
 {
     this->SetDoubleProperty(propertyKey, doubleValue);
 }
 
 void mitk::PropertyList::Set( const char* propertyKey, const char* stringValue )
 {
     this->SetStringProperty(propertyKey, stringValue);
 }
 
 void mitk::PropertyList::Set( const char* propertyKey, const std::string& stringValue )
 {
     this->SetStringProperty(propertyKey, stringValue.c_str());
 
 }
 
 bool mitk::PropertyList::Get( const char* propertyKey, bool& boolValue ) const
 {
     return this->GetBoolProperty( propertyKey, boolValue );
 }
 
 bool mitk::PropertyList::Get( const char* propertyKey, int &intValue ) const
 {
     return this->GetIntProperty(propertyKey, intValue);
 }
 
 bool mitk::PropertyList::Get( const char* propertyKey, float &floatValue ) const
 {
     return this->GetFloatProperty( propertyKey, floatValue );
 }
 
 bool mitk::PropertyList::Get( const char* propertyKey, double &doubleValue ) const
 {
     return this->GetDoubleProperty( propertyKey, doubleValue );
 }
 
 bool mitk::PropertyList::Get( const char* propertyKey, std::string& stringValue ) const
 {
     return this->GetStringProperty( propertyKey, stringValue );
 }
 
 bool mitk::PropertyList::GetDoubleProperty( const char* propertyKey, double &doubleValue ) const
 {
     DoubleProperty *gp = dynamic_cast<DoubleProperty*>( GetProperty(propertyKey) );
     if ( gp != NULL )
     {
         doubleValue = gp->GetValue();
         return true;
     }
     return false;
 
 }
 
 void mitk::PropertyList::SetDoubleProperty( const char* propertyKey, double doubleValue )
 {
     SetProperty(propertyKey, mitk::DoubleProperty::New(doubleValue));
 }
diff --git a/Core/Code/Rendering/mitkBaseRenderer.cpp b/Core/Code/Rendering/mitkBaseRenderer.cpp
index 667358ad0e..ab4e59ff0a 100644
--- a/Core/Code/Rendering/mitkBaseRenderer.cpp
+++ b/Core/Code/Rendering/mitkBaseRenderer.cpp
@@ -1,904 +1,904 @@
 /*===================================================================
 
  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 "mitkBaseRenderer.h"
 #include "mitkMapper.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkKeyEvent.h"
 
 // Geometries
 #include "mitkPlaneGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 
 // Controllers
 #include "mitkCameraController.h"
 #include "mitkSliceNavigationController.h"
 #include "mitkCameraRotationController.h"
 #include "mitkVtkInteractorCameraController.h"
 
 #ifdef MITK_USE_TD_MOUSE
 #include "mitkTDMouseVtkCameraController.h"
 #else
 #include "mitkCameraController.h"
 #endif
 
 #include "mitkVtkLayerController.h"
 
 // Events // TODO: INTERACTION_LEGACY
 #include "mitkEventMapper.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkPositionEvent.h"
 #include "mitkDisplayPositionEvent.h"
 #include "mitkProperties.h"
 #include "mitkWeakPointerProperty.h"
 #include "mitkInteractionConst.h"
 #include "mitkOverlayManager.h"
 
 // VTK
 #include <vtkLinearTransform.h>
 #include <vtkRenderer.h>
 #include <vtkRenderWindow.h>
 #include <vtkCamera.h>
 
 #include <vtkProperty.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkActor.h>
 
 mitk::BaseRenderer::BaseRendererMapType mitk::BaseRenderer::baseRendererMap;
 
 mitk::BaseRenderer* mitk::BaseRenderer::GetInstance(vtkRenderWindow * renWin)
 {
   for (BaseRendererMapType::iterator mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); mapit++)
   {
     if ((*mapit).first == renWin)
       return (*mapit).second;
   }
   return NULL;
 }
 
 void mitk::BaseRenderer::AddInstance(vtkRenderWindow* renWin, BaseRenderer* baseRenderer)
 {
   if (renWin == NULL || baseRenderer == NULL)
     return;
 
   // ensure that no BaseRenderer is managed twice
   mitk::BaseRenderer::RemoveInstance(renWin);
 
   baseRendererMap.insert(BaseRendererMapType::value_type(renWin, baseRenderer));
 }
 
 void mitk::BaseRenderer::RemoveInstance(vtkRenderWindow* renWin)
 {
   BaseRendererMapType::iterator mapit = baseRendererMap.find(renWin);
   if (mapit != baseRendererMap.end())
     baseRendererMap.erase(mapit);
 }
 
 mitk::BaseRenderer* mitk::BaseRenderer::GetByName(const std::string& name)
 {
   for (BaseRendererMapType::iterator mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); mapit++)
   {
     if ((*mapit).second->m_Name == name)
       return (*mapit).second;
   }
   return NULL;
 }
 
 vtkRenderWindow* mitk::BaseRenderer::GetRenderWindowByName(const std::string& name)
 {
   for (BaseRendererMapType::iterator mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); mapit++)
   {
     if ((*mapit).second->m_Name == name)
       return (*mapit).first;
   }
   return NULL;
 }
 
 mitk::BaseRenderer::BaseRenderer(const char* name, vtkRenderWindow * renWin, mitk::RenderingManager* rm,RenderingMode::Type renderingMode)
   : m_RenderWindow(NULL)
   , m_VtkRenderer(NULL)
   , m_MapperID(defaultMapper)
   , m_DataStorage(NULL)
   , m_RenderingManager(rm)
   , m_LastUpdateTime(0)
   , m_CameraController(NULL)
   , m_SliceNavigationController(NULL)
   , m_CameraRotationController(NULL)
   /*, m_Size()*/
   , m_Focused(false)
   , m_WorldGeometry(NULL)
   , m_WorldTimeGeometry(NULL)
   , m_CurrentWorldGeometry(NULL)
   , m_CurrentWorldPlaneGeometry(NULL)
   , m_DisplayGeometry(NULL)
   , m_Slice(0)
   , m_TimeStep()
   , m_CurrentWorldPlaneGeometryUpdateTime()
   , m_DisplayGeometryUpdateTime()
   , m_TimeStepUpdateTime()
   , m_KeepDisplayedRegion(true)
   , m_WorldGeometryData(NULL)
   , m_DisplayGeometryData(NULL)
   , m_CurrentWorldPlaneGeometryData(NULL)
   , m_WorldGeometryNode(NULL)
   , m_DisplayGeometryNode(NULL)
   , m_CurrentWorldPlaneGeometryNode(NULL)
   , m_DisplayGeometryTransformTime(0)
   , m_CurrentWorldPlaneGeometryTransformTime(0)
   , m_Name(name)
   /*, m_Bounds()*/
   , m_EmptyWorldGeometry(true)
   , m_NumberOfVisibleLODEnabledMappers(0)
 {
   m_Bounds[0] = 0;
   m_Bounds[1] = 0;
   m_Bounds[2] = 0;
   m_Bounds[3] = 0;
   m_Bounds[4] = 0;
   m_Bounds[5] = 0;
 
   if (name != NULL)
   {
     m_Name = name;
   }
   else
   {
     m_Name = "unnamed renderer";
     itkWarningMacro(<< "Created unnamed renderer. Bad for serialization. Please choose a name.");
   }
 
   if (renWin != NULL)
   {
     m_RenderWindow = renWin;
     m_RenderWindow->Register(NULL);
   }
   else
   {
     itkWarningMacro(<< "Created mitkBaseRenderer without vtkRenderWindow present.");
   }
 
   m_Size[0] = 0;
   m_Size[1] = 0;
 
   //instances.insert( this );
 
   //adding this BaseRenderer to the List of all BaseRenderer
   // TODO: INTERACTION_LEGACY
   m_RenderingManager->GetGlobalInteraction()->AddFocusElement(this);
 
   m_BindDispatcherInteractor = new mitk::BindDispatcherInteractor( GetName() );
 
   WeakPointerProperty::Pointer rendererProp = WeakPointerProperty::New((itk::Object*) this);
 
   m_CurrentWorldPlaneGeometry = mitk::PlaneGeometry::New();
 
   m_CurrentWorldPlaneGeometryData = mitk::PlaneGeometryData::New();
   m_CurrentWorldPlaneGeometryData->SetPlaneGeometry(m_CurrentWorldPlaneGeometry);
   m_CurrentWorldPlaneGeometryNode = mitk::DataNode::New();
   m_CurrentWorldPlaneGeometryNode->SetData(m_CurrentWorldPlaneGeometryData);
   m_CurrentWorldPlaneGeometryNode->GetPropertyList()->SetProperty("renderer", rendererProp);
   m_CurrentWorldPlaneGeometryNode->GetPropertyList()->SetProperty("layer", IntProperty::New(1000));
 
   m_CurrentWorldPlaneGeometryNode->SetProperty("reslice.thickslices", mitk::ResliceMethodProperty::New());
   m_CurrentWorldPlaneGeometryNode->SetProperty("reslice.thickslices.num", mitk::IntProperty::New(1));
 
   m_CurrentWorldPlaneGeometryTransformTime = m_CurrentWorldPlaneGeometryNode->GetVtkTransform()->GetMTime();
 
   m_DisplayGeometry = mitk::DisplayGeometry::New();
   m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldPlaneGeometry);
   m_DisplayGeometryData = mitk::PlaneGeometryData::New();
   m_DisplayGeometryData->SetPlaneGeometry(m_DisplayGeometry);
   m_DisplayGeometryNode = mitk::DataNode::New();
   m_DisplayGeometryNode->SetData(m_DisplayGeometryData);
   m_DisplayGeometryNode->GetPropertyList()->SetProperty("renderer", rendererProp);
   m_DisplayGeometryTransformTime = m_DisplayGeometryNode->GetVtkTransform()->GetMTime();
 
   mitk::SliceNavigationController::Pointer sliceNavigationController = mitk::SliceNavigationController::New("navigation");
   sliceNavigationController->SetRenderer(this);
   sliceNavigationController->ConnectGeometrySliceEvent(this);
   sliceNavigationController->ConnectGeometryUpdateEvent(this);
   sliceNavigationController->ConnectGeometryTimeEvent(this, false);
   m_SliceNavigationController = sliceNavigationController;
 
   m_CameraRotationController = mitk::CameraRotationController::New();
   m_CameraRotationController->SetRenderWindow(m_RenderWindow);
   m_CameraRotationController->AcquireCamera();
 
 //if TD Mouse Interaction is activated, then call TDMouseVtkCameraController instead of VtkInteractorCameraController
 #ifdef MITK_USE_TD_MOUSE
   m_CameraController = mitk::TDMouseVtkCameraController::New();
 #else
   m_CameraController = mitk::CameraController::New(NULL);
 #endif
 
   m_VtkRenderer = vtkRenderer::New();
 
   if( renderingMode == RenderingMode::DepthPeeling )
   {
     m_VtkRenderer->SetUseDepthPeeling(1);
     m_VtkRenderer->SetMaximumNumberOfPeels(8);
     m_VtkRenderer->SetOcclusionRatio(0.0);
   }
 
   if (mitk::VtkLayerController::GetInstance(m_RenderWindow) == NULL)
   {
     mitk::VtkLayerController::AddInstance(m_RenderWindow, m_VtkRenderer);
-    mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer);
   }
-  else
-    mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer);
+  mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer);
 }
 
 mitk::BaseRenderer::~BaseRenderer()
 {
   if (m_OverlayManager.IsNotNull())
   {
     m_OverlayManager->RemoveBaseRenderer(this);
   }
 
   if (m_VtkRenderer != NULL)
   {
     m_VtkRenderer->Delete();
     m_VtkRenderer = NULL;
   }
 
   if (m_CameraController.IsNotNull())
     m_CameraController->SetRenderer(NULL);
 
   m_RenderingManager->GetGlobalInteraction()->RemoveFocusElement(this);
 
   mitk::VtkLayerController::RemoveInstance(m_RenderWindow);
 
   RemoveAllLocalStorages();
 
   m_DataStorage = NULL;
 
   if (m_BindDispatcherInteractor != NULL)
   {
     delete m_BindDispatcherInteractor;
   }
 
   if (m_RenderWindow != NULL)
   {
     m_RenderWindow->Delete();
     m_RenderWindow = NULL;
   }
 
 }
 
 void mitk::BaseRenderer::RemoveAllLocalStorages()
 {
   this->InvokeEvent(mitk::BaseRenderer::RendererResetEvent());
 
   std::list<mitk::BaseLocalStorageHandler*>::iterator it;
   for (it = m_RegisteredLocalStorageHandlers.begin(); it != m_RegisteredLocalStorageHandlers.end(); it++)
     (*it)->ClearLocalStorage(this, false);
   m_RegisteredLocalStorageHandlers.clear();
 }
 
 void mitk::BaseRenderer::RegisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh)
 {
   m_RegisteredLocalStorageHandlers.push_back(lsh);
 }
 
 mitk::Dispatcher::Pointer mitk::BaseRenderer::GetDispatcher() const
 {
   return m_BindDispatcherInteractor->GetDispatcher();
 }
 
 mitk::Point3D mitk::BaseRenderer::Map2DRendererPositionTo3DWorldPosition(const Point2D& mousePosition) const
 {
   Point2D p_mm;
   Point3D position;
   if (m_MapperID == 1)
   {
     GetDisplayGeometry()->DisplayToWorld(mousePosition, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
   }
   else if (m_MapperID == 2)
   {
     PickWorldPoint(mousePosition, position);
   }
   return position;
 }
 
 void mitk::BaseRenderer::UnregisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh)
 {
   m_RegisteredLocalStorageHandlers.remove(lsh);
 }
 
 void mitk::BaseRenderer::SetDataStorage(DataStorage* storage)
 {
   if (storage != NULL)
   {
     m_DataStorage = storage;
     m_BindDispatcherInteractor->SetDataStorage(m_DataStorage);
     this->Modified();
   }
 }
 
 const mitk::BaseRenderer::MapperSlotId mitk::BaseRenderer::defaultMapper = 1;
 
 void mitk::BaseRenderer::Paint()
 {
 }
 
 void mitk::BaseRenderer::Initialize()
 {
 }
 
 void mitk::BaseRenderer::Resize(int w, int h)
 {
   m_Size[0] = w;
   m_Size[1] = h;
 
   if (m_CameraController)
     m_CameraController->Resize(w, h); //(formerly problematic on windows: vtkSizeBug)
 
   GetDisplayGeometry()->SetSizeInDisplayUnits(w, h, m_KeepDisplayedRegion);
 }
 
 void mitk::BaseRenderer::InitRenderer(vtkRenderWindow* renderwindow)
 {
-  if (m_RenderWindow != NULL)
-  {
-    m_RenderWindow->Delete();
-  }
-  m_RenderWindow = renderwindow;
-  if (m_RenderWindow != NULL)
+  if (m_RenderWindow != renderwindow)
   {
-    m_RenderWindow->Register(NULL);
+    if (m_RenderWindow != NULL)
+    {
+      m_RenderWindow->Delete();
+    }
+    m_RenderWindow = renderwindow;
+    if (m_RenderWindow != NULL)
+    {
+      m_RenderWindow->Register(NULL);
+    }
   }
-
   RemoveAllLocalStorages();
 
   if (m_CameraController.IsNotNull())
   {
     m_CameraController->SetRenderer(this);
   }
 
 }
 
 void mitk::BaseRenderer::InitSize(int w, int h)
 {
   m_Size[0] = w;
   m_Size[1] = h;
   GetDisplayGeometry()->SetSizeInDisplayUnits(w, h, false);
   GetDisplayGeometry()->Fit();
 }
 
 void mitk::BaseRenderer::SetSlice(unsigned int slice)
 {
   if (m_Slice != slice)
   {
     m_Slice = slice;
     if (m_WorldTimeGeometry.IsNotNull())
     {
       SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
       if (slicedWorldGeometry != NULL)
       {
         if (m_Slice >= slicedWorldGeometry->GetSlices())
           m_Slice = slicedWorldGeometry->GetSlices() - 1;
         SetCurrentWorldPlaneGeometry(slicedWorldGeometry->GetPlaneGeometry(m_Slice));
         SetCurrentWorldGeometry(slicedWorldGeometry);
       }
     }
     else
       Modified();
   }
 }
 
 void mitk::BaseRenderer::SetOverlayManager(itk::SmartPointer<OverlayManager> overlayManager)
 {
   if(overlayManager.IsNull())
     return;
 
   if(this->m_OverlayManager.IsNotNull())
   {
     if(this->m_OverlayManager.GetPointer() == overlayManager.GetPointer())
     {
       return;
     }
     else
     {
       this->m_OverlayManager->RemoveBaseRenderer(this);
     }
   }
   this->m_OverlayManager = overlayManager;
   this->m_OverlayManager->AddBaseRenderer(this); //TODO
 }
 
 itk::SmartPointer<mitk::OverlayManager> mitk::BaseRenderer::GetOverlayManager()
 {
   if(this->m_OverlayManager.IsNull())
   {
     m_OverlayManager = mitk::OverlayManager::New();
     m_OverlayManager->AddBaseRenderer(this);
   }
   return this->m_OverlayManager;
 }
 
 void mitk::BaseRenderer::SetTimeStep(unsigned int timeStep)
 {
   if (m_TimeStep != timeStep)
   {
     m_TimeStep = timeStep;
     m_TimeStepUpdateTime.Modified();
 
     if (m_WorldTimeGeometry.IsNotNull())
     {
       if (m_TimeStep >= m_WorldTimeGeometry->CountTimeSteps())
         m_TimeStep = m_WorldTimeGeometry->CountTimeSteps() - 1;
       SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
       if (slicedWorldGeometry != NULL)
       {
         SetCurrentWorldPlaneGeometry(slicedWorldGeometry->GetPlaneGeometry(m_Slice));
         SetCurrentWorldGeometry(slicedWorldGeometry);
       }
     }
     else
       Modified();
   }
 }
 
 int mitk::BaseRenderer::GetTimeStep(const mitk::BaseData* data) const
 {
   if ((data == NULL) || (data->IsInitialized() == false))
   {
     return -1;
   }
   return data->GetTimeGeometry()->TimePointToTimeStep(GetTime());
 }
 
 mitk::ScalarType mitk::BaseRenderer::GetTime() const
 {
   if (m_WorldTimeGeometry.IsNull())
   {
     return 0;
   }
   else
   {
     ScalarType timeInMS = m_WorldTimeGeometry->TimeStepToTimePoint(GetTimeStep());
     if (timeInMS == itk::NumericTraits<mitk::ScalarType>::NonpositiveMin())
       return 0;
     else
       return timeInMS;
   }
 }
 
 void mitk::BaseRenderer::SetWorldTimeGeometry(mitk::TimeGeometry* geometry)
 {
   assert(geometry != NULL);
 
   itkDebugMacro("setting WorldTimeGeometry to " << geometry);
   if (m_WorldTimeGeometry != geometry)
   {
     if (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() == 0)
       return;
 
     m_WorldTimeGeometry = geometry;
     itkDebugMacro("setting WorldTimeGeometry to " << m_WorldTimeGeometry);
 
     if (m_TimeStep >= m_WorldTimeGeometry->CountTimeSteps())
         m_TimeStep = m_WorldTimeGeometry->CountTimeSteps() - 1;
 
     BaseGeometry* geometry3d;
     geometry3d = m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep);
     SetWorldGeometry3D(geometry3d);
   }
 }
 
 void mitk::BaseRenderer::SetWorldGeometry3D(mitk::BaseGeometry* geometry)
 {
   itkDebugMacro("setting WorldGeometry3D to " << geometry);
 
   if (m_WorldGeometry != geometry)
   {
     if (geometry->GetBoundingBox()->GetDiagonalLength2() == 0)
       return;
 
     m_WorldGeometry = geometry;
     SlicedGeometry3D* slicedWorldGeometry;
     slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(geometry);
 
     PlaneGeometry::Pointer geometry2d;
     if (slicedWorldGeometry != NULL)
     {
       if (m_Slice >= slicedWorldGeometry->GetSlices() && (m_Slice != 0))
         m_Slice = slicedWorldGeometry->GetSlices() - 1;
       geometry2d = slicedWorldGeometry->GetPlaneGeometry(m_Slice);
       if (geometry2d.IsNull())
       {
         PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
         plane->InitializeStandardPlane(slicedWorldGeometry);
         geometry2d = plane;
       }
       SetCurrentWorldGeometry(slicedWorldGeometry);
     }
     else
     {
       geometry2d = dynamic_cast<PlaneGeometry*>(geometry);
       if (geometry2d.IsNull())
       {
         PlaneGeometry::Pointer plane = PlaneGeometry::New();
         plane->InitializeStandardPlane(geometry);
         geometry2d = plane;
       }
       SetCurrentWorldGeometry(geometry);
     }
     SetCurrentWorldPlaneGeometry(geometry2d); // calls Modified()
   }
   if (m_CurrentWorldPlaneGeometry.IsNull())
     itkWarningMacro("m_CurrentWorldPlaneGeometry is NULL");
 }
 
 void mitk::BaseRenderer::SetDisplayGeometry(mitk::DisplayGeometry* geometry2d)
 {
   itkDebugMacro("setting DisplayGeometry to " << geometry2d);
   if (m_DisplayGeometry != geometry2d)
   {
     m_DisplayGeometry = geometry2d;
     m_DisplayGeometryData->SetPlaneGeometry(m_DisplayGeometry);
     m_DisplayGeometryUpdateTime.Modified();
     Modified();
   }
 }
 
 void mitk::BaseRenderer::SetCurrentWorldPlaneGeometry(mitk::PlaneGeometry* geometry2d)
 {
   if (m_CurrentWorldPlaneGeometry != geometry2d)
   {
     m_CurrentWorldPlaneGeometry = geometry2d;
     m_CurrentWorldPlaneGeometryData->SetPlaneGeometry(m_CurrentWorldPlaneGeometry);
     m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldPlaneGeometry);
     m_CurrentWorldPlaneGeometryUpdateTime.Modified();
     Modified();
   }
 }
 
 void mitk::BaseRenderer::SendUpdateSlice()
 {
   m_DisplayGeometryUpdateTime.Modified();
   m_CurrentWorldPlaneGeometryUpdateTime.Modified();
 }
 
 void mitk::BaseRenderer::SetCurrentWorldGeometry(mitk::BaseGeometry* geometry)
 {
   m_CurrentWorldGeometry = geometry;
   if (geometry == NULL)
   {
     m_Bounds[0] = 0;
     m_Bounds[1] = 0;
     m_Bounds[2] = 0;
     m_Bounds[3] = 0;
     m_Bounds[4] = 0;
     m_Bounds[5] = 0;
     m_EmptyWorldGeometry = true;
     return;
   }
   BoundingBox::Pointer boundingBox = m_CurrentWorldGeometry->CalculateBoundingBoxRelativeToTransform(NULL);
   const BoundingBox::BoundsArrayType& worldBounds = boundingBox->GetBounds();
   m_Bounds[0] = worldBounds[0];
   m_Bounds[1] = worldBounds[1];
   m_Bounds[2] = worldBounds[2];
   m_Bounds[3] = worldBounds[3];
   m_Bounds[4] = worldBounds[4];
   m_Bounds[5] = worldBounds[5];
   if (boundingBox->GetDiagonalLength2() <= mitk::eps)
     m_EmptyWorldGeometry = true;
   else
     m_EmptyWorldGeometry = false;
 }
 
 void mitk::BaseRenderer::UpdateOverlays()
 {
   if(m_OverlayManager.IsNotNull())
   {
     m_OverlayManager->UpdateOverlays(this);
   }
 }
 
 void mitk::BaseRenderer::SetGeometry(const itk::EventObject & geometrySendEvent)
 {
   const SliceNavigationController::GeometrySendEvent* sendEvent =
       dynamic_cast<const SliceNavigationController::GeometrySendEvent *>(&geometrySendEvent);
 
   assert(sendEvent!=NULL);
   SetWorldTimeGeometry(sendEvent->GetTimeGeometry());
 }
 
 void mitk::BaseRenderer::UpdateGeometry(const itk::EventObject & geometryUpdateEvent)
 {
   const SliceNavigationController::GeometryUpdateEvent* updateEvent =
       dynamic_cast<const SliceNavigationController::GeometryUpdateEvent*>(&geometryUpdateEvent);
 
   if (updateEvent == NULL)
     return;
 
   if (m_CurrentWorldGeometry.IsNotNull())
   {
     SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_CurrentWorldGeometry.GetPointer());
     if (slicedWorldGeometry)
     {
       PlaneGeometry* geometry2D = slicedWorldGeometry->GetPlaneGeometry(m_Slice);
 
       SetCurrentWorldPlaneGeometry(geometry2D); // calls Modified()
     }
   }
 }
 
 void mitk::BaseRenderer::SetGeometrySlice(const itk::EventObject & geometrySliceEvent)
 {
   const SliceNavigationController::GeometrySliceEvent* sliceEvent =
       dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(&geometrySliceEvent);
 
   assert(sliceEvent!=NULL);
   SetSlice(sliceEvent->GetPos());
 }
 
 void mitk::BaseRenderer::SetGeometryTime(const itk::EventObject & geometryTimeEvent)
 {
   const SliceNavigationController::GeometryTimeEvent * timeEvent =
       dynamic_cast<const SliceNavigationController::GeometryTimeEvent *>(&geometryTimeEvent);
 
   assert(timeEvent!=NULL);
   SetTimeStep(timeEvent->GetPos());
 }
 
 const double* mitk::BaseRenderer::GetBounds() const
 {
   return m_Bounds;
 }
 
 void mitk::BaseRenderer::MousePressEvent(mitk::MouseEvent *me)
 {
   //set the Focus on the renderer
   /*bool success =*/m_RenderingManager->GetGlobalInteraction()->SetFocus(this);
   /*
    if (! success)
    mitk::StatusBar::GetInstance()->DisplayText("Warning! from mitkBaseRenderer.cpp: Couldn't focus this BaseRenderer!");
    */
 
   //if (m_CameraController)
   //{
   //  if(me->GetButtonState()!=512) // provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
   //    m_CameraController->MousePressEvent(me);
   //}
   if (m_MapperID == 1)
   {
     Point2D p(me->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID > 1)  //==2 for 3D and ==5 for stencil
   {
     Point2D p(me->GetDisplayPosition());
 
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     me->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(me, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::MouseReleaseEvent(mitk::MouseEvent *me)
 {
   //if (m_CameraController)
   //{
   //  if(me->GetButtonState()!=512) // provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
   //    m_CameraController->MouseReleaseEvent(me);
   //}
 
   if (m_MapperID == 1)
   {
     Point2D p(me->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID == 2)
   {
     Point2D p(me->GetDisplayPosition());
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     me->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(me, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::MouseMoveEvent(mitk::MouseEvent *me)
 {
   //if (m_CameraController)
   //{
   //  if((me->GetButtonState()<=512) || (me->GetButtonState()>=516))// provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
   //    m_CameraController->MouseMoveEvent(me);
   //}
   if (m_MapperID == 1)
   {
     Point2D p(me->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID == 2)
   {
     Point2D p(me->GetDisplayPosition());
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     me->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(me, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::PickWorldPoint(const mitk::Point2D& displayPoint, mitk::Point3D& worldPoint) const
 {
   mitk::Point2D worldPoint2D;
   GetDisplayGeometry()->DisplayToWorld(displayPoint, worldPoint2D);
   GetDisplayGeometry()->Map(worldPoint2D, worldPoint);
 }
 
 void mitk::BaseRenderer::WheelEvent(mitk::WheelEvent * we)
 {
   if (m_MapperID == 1)
   {
     Point2D p(we->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::PositionEvent event(this, we->GetType(), we->GetButton(), we->GetButtonState(), mitk::Key_unknown, p, position);
     mitk::EventMapper::MapEvent(we, m_RenderingManager->GetGlobalInteraction());
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID == 2)
   {
     Point2D p(we->GetDisplayPosition());
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     we->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(we, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::KeyPressEvent(mitk::KeyEvent *ke)
 {
   if (m_MapperID == 1)
   {
     Point2D p(ke->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::KeyEvent event(this, ke->GetType(), ke->GetButton(), ke->GetButtonState(), ke->GetKey(), ke->GetText(), p);
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID == 2)
   {
     Point2D p(ke->GetDisplayPosition());
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     ke->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(ke, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::DrawOverlayMouse(mitk::Point2D& itkNotUsed(p2d))
 {
   MITK_INFO<<"BaseRenderer::DrawOverlayMouse()- should be inconcret implementation OpenGLRenderer."<<std::endl;
 }
 
 void mitk::BaseRenderer::RequestUpdate()
 {
   m_RenderingManager->RequestUpdate(this->m_RenderWindow);
 }
 
 void mitk::BaseRenderer::ForceImmediateUpdate()
 {
   m_RenderingManager->ForceImmediateUpdate(this->m_RenderWindow);
 }
 
 unsigned int mitk::BaseRenderer::GetNumberOfVisibleLODEnabledMappers() const
 {
   return m_NumberOfVisibleLODEnabledMappers;
 }
 
 mitk::RenderingManager* mitk::BaseRenderer::GetRenderingManager() const
 {
   return m_RenderingManager.GetPointer();
 }
 
 /*!
  Sets the new Navigation controller
  */
 void mitk::BaseRenderer::SetSliceNavigationController(mitk::SliceNavigationController *SlicenavigationController)
 {
   if (SlicenavigationController == NULL)
     return;
 
   //disconnect old from globalinteraction
   m_RenderingManager->GetGlobalInteraction()->RemoveListener(SlicenavigationController);
 
   //copy worldgeometry
   SlicenavigationController->SetInputWorldTimeGeometry(SlicenavigationController->GetCreatedWorldGeometry());
   SlicenavigationController->Update();
 
   //set new
   m_SliceNavigationController = SlicenavigationController;
   m_SliceNavigationController->SetRenderer(this);
 
   if (m_SliceNavigationController.IsNotNull())
   {
     m_SliceNavigationController->ConnectGeometrySliceEvent(this);
     m_SliceNavigationController->ConnectGeometryUpdateEvent(this);
     m_SliceNavigationController->ConnectGeometryTimeEvent(this, false);
   }
 }
 
 /*!
  Sets the new camera controller and deletes the vtkRenderWindowInteractor in case of the VTKInteractorCameraController
  */
 void mitk::BaseRenderer::SetCameraController(CameraController* cameraController)
 {
   mitk::VtkInteractorCameraController::Pointer vtkInteractorCameraController =
       dynamic_cast<mitk::VtkInteractorCameraController*>(cameraController);
   if (vtkInteractorCameraController.IsNotNull())
     MITK_INFO<<"!!!WARNING!!!: RenderWindow interaction events are no longer handled via CameraController (See Bug #954)."<<std::endl;
   m_CameraController->SetRenderer(NULL);
   m_CameraController = NULL;
   m_CameraController = cameraController;
   m_CameraController->SetRenderer(this);
 }
 
 void mitk::BaseRenderer::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   os << indent << " MapperID: " << m_MapperID << std::endl;
   os << indent << " Slice: " << m_Slice << std::endl;
   os << indent << " TimeStep: " << m_TimeStep << std::endl;
 
   os << indent << " WorldGeometry: ";
   if (m_WorldGeometry.IsNull())
     os << "NULL" << std::endl;
   else
     m_WorldGeometry->Print(os, indent);
 
   os << indent << " CurrentWorldPlaneGeometry: ";
   if (m_CurrentWorldPlaneGeometry.IsNull())
     os << "NULL" << std::endl;
   else
     m_CurrentWorldPlaneGeometry->Print(os, indent);
 
   os << indent << " CurrentWorldPlaneGeometryUpdateTime: " << m_CurrentWorldPlaneGeometryUpdateTime << std::endl;
   os << indent << " CurrentWorldPlaneGeometryTransformTime: " << m_CurrentWorldPlaneGeometryTransformTime << std::endl;
 
   os << indent << " DisplayGeometry: ";
   if (m_DisplayGeometry.IsNull())
     os << "NULL" << std::endl;
   else
     m_DisplayGeometry->Print(os, indent);
 
   os << indent << " DisplayGeometryTransformTime: " << m_DisplayGeometryTransformTime << std::endl;
   Superclass::PrintSelf(os, indent);
 }
diff --git a/MITKConfig.cmake.in b/MITKConfig.cmake.in
index ec716edc82..2c3716efcb 100644
--- a/MITKConfig.cmake.in
+++ b/MITKConfig.cmake.in
@@ -1,212 +1,214 @@
 
 # Update the CMake module path
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "@MITK_SOURCE_DIR@/CMake")
 
 set(CppMicroServices_DIR "@CppMicroServices_DIR@")
 
 # Include MITK macros
 include(MacroParseArguments)
 include(mitkFunctionCheckMitkCompatibility)
 include(mitkFunctionOrganizeSources)
 include(mitkFunctionCreateWindowsBatchScript)
 include(mitkFunctionInstallProvisioningFiles)
 include(mitkFunctionInstallAutoLoadModules)
 include(mitkFunctionGetLibrarySearchPaths)
 include(mitkFunctionUseModules)
 include(mitkMacroCreateModuleConf)
 include(mitkFunctionCheckModuleDependencies)
 include(mitkFunctionCreateModule)
 include(mitkMacroCreateExecutable)
 include(mitkMacroCheckModule)
 include(mitkMacroCreateModuleTests)
 include(mitkFunctionAddCustomModuleTest)
 include(mitkMacroUseModule)
 include(mitkMacroMultiplexPicType)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroGenerateToolsLibrary)
 include(mitkMacroCreateCTKPlugin)
 include(mitkMacroGetPMDPlatformString)
 
 # Standard CMake macros
 include(FeatureSummary)
 
 # The MITK version number
 set(MITK_VERSION_MAJOR "@MITK_VERSION_MAJOR@")
 set(MITK_VERSION_MINOR "@MITK_VERSION_MINOR@")
 set(MITK_VERSION_PATCH "@MITK_VERSION_PATCH@")
 set(MITK_VERSION_STRING "@MITK_VERSION_STRING@")
 
 # MITK compiler flags
 set(MITK_C_FLAGS "@MITK_C_FLAGS@")
 set(MTTK_C_FLAGS_DEBUG "@MITK_C_FLAGS_DEBUG@")
 set(MITK_C_FLAGS_RELEASE "@MITK_C_FLAGS_RELEASE@")
 set(MITK_CXX_FLAGS "@MITK_CXX_FLAGS@")
 set(MTTK_CXX_FLAGS_DEBUG "@MITK_CXX_FLAGS_DEBUG@")
 set(MITK_CXX_FLAGS_RELEASE "@MITK_CXX_FLAGS_RELEASE@")
 
 set(MITK_EXE_LINKER_FLAGS "@MITK_EXE_LINKER_FLAGS@")
 set(MITK_SHARED_LINKER_FLAGS "@MITK_SHARED_LINKER_FLAGS@")
 set(MITK_MODULE_LINKER_FLAGS "@MITK_MODULE_LINKER_FLAGS@")
 
 # Internal version numbers, used for approximate compatibility checks
 # of a MITK development version (non-release).
 set(MITK_VERSION_PLUGIN_SYSTEM 2) # dropped legacy BlueBerry plug-in CMake support
 
 # MITK specific variables
 set(MITK_SOURCE_DIR "@MITK_SOURCE_DIR@")
 set(MITK_BINARY_DIR "@MITK_BINARY_DIR@")
 set(MITK_CMAKE_DIR "@MITK_CMAKE_DIR@")
 set(UTILITIES_DIR "@UTILITIES_DIR@")
 set(REGISTER_QFUNCTIONALITY_CPP_IN "@REGISTER_QFUNCTIONALITY_CPP_IN@")
 set(MITK_DOXYGEN_TAGFILE_NAME "@MITK_DOXYGEN_TAGFILE_NAME@")
 
 set(MITK_MODULES_PACKAGE_DEPENDS_DIR "@MITK_MODULES_PACKAGE_DEPENDS_DIR@")
 if(MODULES_PACKAGE_DEPENDS_DIRS)
   list(APPEND MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
   list(REMOVE_DUPLICATES MODULES_PACKAGE_DEPENDS_DIRS)
 else()
   set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
 endif()
 
 if(MODULES_CONF_DIRS)
   list(APPEND MODULES_CONF_DIRS "@MODULES_CONF_DIRS@")
   list(REMOVE_DUPLICATES MODULES_CONF_DIRS)
 else()
   set(MODULES_CONF_DIRS "@MODULES_CONF_DIRS@")
 endif()
 
 set(MODULES_CONF_DIRNAME "@MODULES_CONF_DIRNAME@")
 
 foreach(_module @MITK_MODULE_NAMES@)
   set(${_module}_CONFIG_FILE "@MITK_BINARY_DIR@/@MODULES_CONF_DIRNAME@/${_module}Config.cmake")
 endforeach()
 
 # External projects
 set(CTK_DIR "@CTK_DIR@")
 set(ANN_DIR "@ANN_DIR@")
 set(CppUnit_DIR "@CppUnit_DIR@")
 set(Eigen_DIR "@Eigen_DIR@")
 set(GLEW_DIR "@GLEW_DIR@")
 set(tinyxml_DIR "@tinyxml_DIR@")
 set(ITK_DIR "@ITK_DIR@")
 set(VTK_DIR "@VTK_DIR@")
 set(DCMTK_DIR "@DCMTK_DIR@")
 set(GDCM_DIR "@GDCM_DIR@")
 set(BOOST_ROOT "@BOOST_ROOT@")
 set(OpenCV_DIR "@OpenCV_DIR@")
 set(Poco_DIR "@Poco_DIR@")
 set(SOFA_DIR "@SOFA_DIR@")
 set(Qwt_DIR "@Qwt_DIR@")
 set(Qxt_DIR "@Qxt_DIR@")
 set(ACVD_DIR "@ACVD_DIR@")
 set(MITK_QMAKE_EXECUTABLE "@QT_QMAKE_EXECUTABLE@")
 set(MITK_DATA_DIR "@MITK_DATA_DIR@")
 set(SimpleITK_DIR "@SimpleITK_DIR@")
 set(Python_DIR "@Python_DIR@")
 
 # External SDK directories
 set(MITK_PMD_SDK_DIR @MITK_PMD_SDK_DIR@)
 
 # MITK use variables
 set(MITK_USE_QT @MITK_USE_QT@)
 set(MITK_USE_Qt4 @MITK_USE_Qt4@)
 set(MITK_USE_Qt5 @MITK_USE_Qt5@)
 set(MITK_DESIRED_QT_VERSION @DESIRED_QT_VERSION@)
 set(MITK_USE_BLUEBERRY @MITK_USE_BLUEBERRY@)
 set(MITK_USE_SYSTEM_Boost @MITK_USE_SYSTEM_Boost@)
 set(MITK_USE_Boost @MITK_USE_Boost@)
 set(MITK_USE_Boost_LIBRARIES @MITK_USE_Boost_LIBRARIES@)
 set(MITK_USE_CTK @MITK_USE_CTK@)
 set(MITK_USE_DCMTK @MITK_USE_DCMTK@)
 set(MITK_USE_OpenCV @MITK_USE_OpenCV@)
 set(MITK_USE_SOFA @MITK_USE_SOFA@)
 set(MITK_USE_Python @MITK_USE_Python@)
 set(MITK_USE_SimpleITK @MITK_USE_SimpleITK@)
 set(MITK_USE_ACVD @MITK_USE_ACVD@)
 
 if(MITK_USE_Qt4)
   set(MITK_QT4_MINIMUM_VERSION @MITK_QT4_MINIMUM_VERSION@)
   find_package(Qt4 ${MITK_QT4_MINIMUM_VERSION} REQUIRED)
 elseif(MITK_USE_Qt5)
   set(MITK_QT5_MINIMUM_VERSION @MITK_QT5_MINIMUM_VERSION@)
   find_package(Qt5Core ${MITK_QT5_MINIMUM_VERSION} REQUIRED)
 endif()
 
 # MITK ToF use variables
 
 set(MITK_TOF_PMDCAMCUBE_AVAILABLE @MITK_USE_TOF_PMDCAMCUBE@)
 if(MITK_TOF_PMDCAMCUBE_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_PMDCAMCUBE "Enable support for PMD Cam Cube" @MITK_USE_TOF_PMDCAMCUBE@)
   mark_as_advanced(MITK_USE_TOF_PMDCAMCUBE)
 endif()
 
 set(MITK_TOF_PMDCAMBOARD_AVAILABLE @MITK_USE_TOF_PMDCAMBOARD@)
 if(MITK_TOF_PMDCAMBOARD_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_PMDCAMBOARD "Enable support for PMD Cam Board" @MITK_USE_TOF_PMDCAMBOARD@)
   mark_as_advanced(MITK_USE_TOF_PMDCAMBOARD)
 endif()
 
 set(MITK_TOF_PMDO3_AVAILABLE @MITK_USE_TOF_PMDO3@)
 if(MITK_TOF_PMDO3_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_PMDO3 "Enable support for PMD =3" @MITK_USE_TOF_PMDO3@)
   mark_as_advanced(MITK_USE_TOF_PMDO3)
 endif()
 
 set(MITK_TOF_KINECT_AVAILABLE @MITK_USE_TOF_KINECT@)
 if(MITK_TOF_KINECT_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_KINECT "Enable support for Kinect" @MITK_USE_TOF_KINECT@)
   mark_as_advanced(MITK_USE_TOF_KINECT)
 endif()
 
 set(MITK_TOF_MESASR4000_AVAILABLE @MITK_USE_TOF_MESASR4000@)
 if(MITK_TOF_MESASR4000_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_MESASR4000 "Enable support for MESA SR4000" @MITK_USE_TOF_MESASR4000@)
   mark_as_advanced(MITK_USE_TOF_MESASR4000)
 endif()
 
 if(MITK_USE_IGT)
   #include("${MITK_DIR}/mitkIGTConfig.cmake")
 endif()
 
 # Install rules for ToF libraries loaded at runtime
-include("@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake")
+if(EXISTS "@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake")
+  include("@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake")
+endif()
 
 if(NOT MITK_EXPORTS_FILE_INCLUDED)
   if(EXISTS "@MITK_EXPORTS_FILE@")
     set(MITK_EXPORTS_FILE_INCLUDED 1)
     include("@MITK_EXPORTS_FILE@")
   endif()
 endif()
 
 # BlueBerry support
 if(MITK_USE_BLUEBERRY)
 
   set(BlueBerry_DIR "@MITK_BINARY_DIR@/BlueBerry")
 
   # Don't include the BlueBerry exports file, since the targets are
   # also exported in the MITK exports file
   set(BB_PLUGIN_EXPORTS_FILE_INCLUDED 1)
   find_package(BlueBerry)
 
   if(NOT BlueBerry_FOUND)
     message(SEND_ERROR "MITK does not seem to be configured with BlueBerry support. Set MITK_USE_BLUEBERRY to ON in your MITK build configuration.")
   endif()
 
   set(MITK_PLUGIN_USE_FILE "@MITK_PLUGIN_USE_FILE@")
   if(MITK_PLUGIN_USE_FILE)
     if(EXISTS "${MITK_PLUGIN_USE_FILE}")
       include("${MITK_PLUGIN_USE_FILE}")
     endif()
   endif()
 
   set(MITK_PLUGIN_PROVISIONING_FILE "@MITK_EXTAPP_PROVISIONING_FILE@")
   set(MITK_PROVISIONING_FILES
       "${BLUEBERRY_PLUGIN_PROVISIONING_FILE}"
       "${MITK_PLUGIN_PROVISIONING_FILE}")
 
 endif()
 
 # Set properties on exported targets
 @MITK_EXPORTED_TARGET_PROPERTIES@
diff --git a/Modules/QmlItems/QmlMitkRenderWindowItem.cpp b/Modules/QmlItems/QmlMitkRenderWindowItem.cpp
index 22f4af8222..10687b2046 100644
--- a/Modules/QmlItems/QmlMitkRenderWindowItem.cpp
+++ b/Modules/QmlItems/QmlMitkRenderWindowItem.cpp
@@ -1,405 +1,379 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/legal
-**
-** This file is part of the demonstration applications of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and Digia.  For licensing terms and
-** conditions see http://qt.digia.com/licensing.  For further information
-** use the contact form at http://qt.digia.com/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Digia gives you certain additional
-** rights.  These rights are described in the Digia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
+/*===================================================================
 
+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 "QmlMitkRenderWindowItem.h"
 
 #include <vtkOpenGLExtensionManager.h>
 
 #include <QVTKInteractor.h>
 #include<vtkEventQtSlotConnect.h>
 #include <vtkGenericOpenGLRenderWindow.h>
 #include <QVTKInteractorAdapter.h>
 
 // MITK event types
 #include "mitkMousePressEvent.h"
 #include "mitkMouseMoveEvent.h"
 #include "mitkMouseDoubleClickEvent.h"
 #include "mitkMouseReleaseEvent.h"
 #include "mitkInteractionKeyEvent.h"
 #include "mitkMouseWheelEvent.h"
 #include "mitkInternalEvent.h"
 #include "mitkPlaneGeometryDataMapper2D.h"
 
 #include "QmlMitkBigRenderLock.h"
 
 #define INTERACTION_LEGACY // TODO: remove INTERACTION_LEGACY!
 
 #if defined INTERACTION_LEGACY
   #include "InteractionLegacy/QmitkEventAdapter.h"
   #include "mitkGlobalInteraction.h"
 #endif
 
 QmlMitkRenderWindowItem* QmlMitkRenderWindowItem::GetInstanceForVTKRenderWindow( vtkRenderWindow* rw )
 {
   return GetInstances()[rw];
 }
 
 QMap<vtkRenderWindow*, QmlMitkRenderWindowItem*>& QmlMitkRenderWindowItem::GetInstances()
 {
   static QMap<vtkRenderWindow*, QmlMitkRenderWindowItem*> s_Instances;
   return s_Instances;
 }
 
 
 QmlMitkRenderWindowItem
 ::QmlMitkRenderWindowItem(QQuickItem* parent,
                           const QString& name,
                           mitk::VtkPropRenderer* /*renderer*/,
                           mitk::RenderingManager* renderingManager)
 : QVTKQuickItem(parent)
 {
   mitk::RenderWindowBase::Initialize( renderingManager, name.toStdString().c_str() );
 
   /* from QmitkRenderWindow. Required?
   setFocusPolicy(Qt::StrongFocus);
   setMouseTracking(true);
   */
 
   GetInstances()[QVTKQuickItem::GetRenderWindow()] = this;
 }
 
 // called from QVTKQuickItem when window is painted for the first time!
 void QmlMitkRenderWindowItem::init()
 {
   QVTKQuickItem::init();
 
   mitk::DataStorage::Pointer m_DataStorage = mitk::RenderWindowBase::GetRenderer()->GetDataStorage();
   if (m_DataStorage.IsNotNull())
   {
     mitk::RenderingManager::GetInstance()->InitializeViews( m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll()) );
   }
 
   // TODO the following code needs to be moved to a multi-widget item
   if ( mitk::RenderWindowBase::GetRenderer()->GetMapperID() == mitk::BaseRenderer::Standard2D )
   {
     this->SetCrossHairPositioningOnClick(true);
   }
 
   if ( mitk::RenderWindowBase::GetRenderer()->GetMapperID() == mitk::BaseRenderer::Standard2D
       && m_DataStorage.IsNotNull() )
   {
 
     mitk::DataNode::Pointer planeNode = mitk::RenderWindowBase::GetRenderer()->GetCurrentWorldGeometry2DNode();
     switch ( mitk::RenderWindowBase::GetRenderer()->GetSliceNavigationController()->GetDefaultViewDirection() )
     {
       case mitk::SliceNavigationController::Axial:
         planeNode->SetColor(1.0,0.0,0.0);
         break;
       case mitk::SliceNavigationController::Sagittal:
         planeNode->SetColor(0.0,1.0,0.0);
         break;
       case mitk::SliceNavigationController::Frontal:
         planeNode->SetColor(0.0,0.0,1.0);
         break;
       default:
         planeNode->SetColor(1.0,1.0,0.0);
     }
     planeNode->SetProperty("layer", mitk::IntProperty::New(1000) );
     planeNode->SetProperty("visible", mitk::BoolProperty::New(true) );
     planeNode->SetProperty("helper object", mitk::BoolProperty::New(true) );
 
     mitk::PlaneGeometryDataMapper2D::Pointer mapper = mitk::PlaneGeometryDataMapper2D::New();
     mapper->SetDatastorageAndGeometryBaseNode( m_DataStorage, m_PlaneNodeParent );
     planeNode->SetMapper( mitk::BaseRenderer::Standard2D, mapper );
 
     m_DataStorage->Add( planeNode, m_PlaneNodeParent );
   }
 }
 
 void QmlMitkRenderWindowItem::InitView( mitk::BaseRenderer::MapperSlotId mapperID,
                                         mitk::SliceNavigationController::ViewDirection viewDirection )
 {
   m_MapperID = mapperID;
   m_ViewDirection = viewDirection;
 }
 
 
 void QmlMitkRenderWindowItem::SetDataStorage(mitk::DataStorage::Pointer storage)
 {
   m_DataStorage = storage;
 }
 
 mitk::Point2D QmlMitkRenderWindowItem::GetMousePosition(QMouseEvent* me) const
 {
 
   mitk::Point2D point;
   point[0] = me->x();
   point[1] = me->y();
   return point;
 }
 
 mitk::Point2D QmlMitkRenderWindowItem::GetMousePosition(QWheelEvent* we) const
 {
   mitk::Point2D point;
   point[0] = we->x();
   point[1] = we->y();
   return point;
 }
 
 mitk::InteractionEvent::MouseButtons QmlMitkRenderWindowItem::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 QmlMitkRenderWindowItem::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 QmlMitkRenderWindowItem::GetModifiers(QInputEvent* 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 QmlMitkRenderWindowItem::GetButtonState(QWheelEvent* we) const
 {
   mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
 
   if (we->buttons() & Qt::LeftButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
   }
   if (we->buttons() & Qt::RightButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
   }
   if (we->buttons() & Qt::MidButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
   }
   return buttonState;
 }
 
 
 void QmlMitkRenderWindowItem::mousePressEvent(QMouseEvent* me)
 {
   mitk::Point2D mousePosition = GetMousePosition(me);
   mitk::Point3D worldPosition = mitk::RenderWindowBase::GetRenderer()->Map2DRendererPositionTo3DWorldPosition(mousePosition);
   mitk::MousePressEvent::Pointer mPressEvent =
     mitk::MousePressEvent::New(mitk::RenderWindowBase::GetRenderer(), mousePosition, worldPosition, GetButtonState(me), GetModifiers(me), GetEventButton(me));
 
 #if defined INTERACTION_LEGACY
   bool modernInteractorHandledEvent =
 #endif
   mitk::RenderWindowBase::HandleEvent(mPressEvent.GetPointer());
 #if defined INTERACTION_LEGACY
   if (!modernInteractorHandledEvent)
   {
     mitk::MouseEvent myevent(QmitkEventAdapter::AdaptMouseEvent(mitk::RenderWindowBase::GetRenderer(), me));
     mitk::RenderWindowBase::mousePressMitkEvent(&myevent);
   }
 #endif
 
   QVTKQuickItem::mousePressEvent(me);
 
 //  if (m_ResendQtEvents)
 //    me->ignore();
 }
 
 void QmlMitkRenderWindowItem::mouseReleaseEvent(QMouseEvent* me)
 {
   mitk::Point2D mousePosition = GetMousePosition(me);
   mitk::Point3D worldPosition = mitk::RenderWindowBase::GetRenderer()->Map2DRendererPositionTo3DWorldPosition(mousePosition);
   mitk::MouseReleaseEvent::Pointer mReleaseEvent =
     mitk::MouseReleaseEvent::New(mitk::RenderWindowBase::GetRenderer(), mousePosition, worldPosition, GetButtonState(me), GetModifiers(me), GetEventButton(me));
 
 #if defined INTERACTION_LEGACY
   bool modernInteractorHandledEvent =
 #endif
   mitk::RenderWindowBase::HandleEvent(mReleaseEvent.GetPointer());
 #if defined INTERACTION_LEGACY
   if (!modernInteractorHandledEvent)
   {
     mitk::MouseEvent myevent(QmitkEventAdapter::AdaptMouseEvent(mitk::RenderWindowBase::GetRenderer(), me));
     mitk::RenderWindowBase::mouseReleaseMitkEvent(&myevent);
   }
 #endif
 
   QVTKQuickItem::mouseReleaseEvent(me);
 
 //  if (m_ResendQtEvents)
 //    me->ignore();
 }
 
 void QmlMitkRenderWindowItem::mouseMoveEvent(QMouseEvent* me)
 {
   mitk::Point2D mousePosition = GetMousePosition(me);
   mitk::Point3D worldPosition = mitk::RenderWindowBase::GetRenderer()->Map2DRendererPositionTo3DWorldPosition(mousePosition);
   mitk::MouseMoveEvent::Pointer mMoveEvent =
     mitk::MouseMoveEvent::New(mitk::RenderWindowBase::GetRenderer(), mousePosition, worldPosition, GetButtonState(me), GetModifiers(me));
 
 #if defined INTERACTION_LEGACY
   bool modernInteractorHandledEvent =
 #endif
   mitk::RenderWindowBase::HandleEvent(mMoveEvent.GetPointer());
 #if defined INTERACTION_LEGACY
   if (!modernInteractorHandledEvent)
   {
     mitk::MouseEvent myevent(QmitkEventAdapter::AdaptMouseEvent(mitk::RenderWindowBase::GetRenderer(), me));
     mitk::RenderWindowBase::mouseMoveMitkEvent(&myevent);
   }
 #endif
 
   QVTKQuickItem::mouseMoveEvent(me);
 
 // TODO: why was this not put here initially? What is special about mouse move?
 //  if (m_ResendQtEvents)
 //    me->ignore();
 }
 
 void QmlMitkRenderWindowItem::wheelEvent(QWheelEvent *we)
 {
   mitk::Point2D mousePosition = GetMousePosition(we);
   mitk::Point3D worldPosition = mitk::RenderWindowBase::GetRenderer()->Map2DRendererPositionTo3DWorldPosition(mousePosition);
   mitk::MouseWheelEvent::Pointer mWheelEvent =
     mitk::MouseWheelEvent::New(mitk::RenderWindowBase::GetRenderer(), mousePosition, worldPosition, GetButtonState(we), GetModifiers(we), we->delta());
 
 #if defined INTERACTION_LEGACY
   bool modernInteractorHandledEvent =
 #endif
   mitk::RenderWindowBase::HandleEvent(mWheelEvent.GetPointer());
 #if defined INTERACTION_LEGACY
   if (!modernInteractorHandledEvent)
   { // TODO: INTERACTION_LEGACY
     mitk::WheelEvent myevent(QmitkEventAdapter::AdaptWheelEvent(mitk::RenderWindowBase::GetRenderer(), we));
     mitk::RenderWindowBase::wheelMitkEvent(&myevent);
   }
 #endif
 
   QVTKQuickItem::wheelEvent(we);
 
 //  if (m_ResendQtEvents)
 //    we->ignore();
 }
 
 
 void QmlMitkRenderWindowItem::prepareForRender()
 {
 //  Adjust camera is kaputt wenn nicht der renderingmanager dem vtkprop bescheid sagt!
 //  this is just a workaround
   QmlMitkBigRenderLock::GetMutex().lock();
   mitk::RenderWindowBase::GetRenderer()->ForceImmediateUpdate();
 }
 
 void QmlMitkRenderWindowItem::cleanupAfterRender()
 {
   QmlMitkBigRenderLock::GetMutex().unlock();
 }
 
 void QmlMitkRenderWindowItem::SetCrossHairPositioningOnClick(bool enabled)
 {
   if (enabled)
   {
     mitk::GlobalInteraction::GetInstance()->AddListener( mitk::RenderWindowBase::GetSliceNavigationController() );
   }
   else
   {
     mitk::GlobalInteraction::GetInstance()->RemoveListener( mitk::RenderWindowBase::GetSliceNavigationController() );
   }
 }
 
 void QmlMitkRenderWindowItem::SetPlaneNodeParent( mitk::DataNode::Pointer node )
 {
   m_PlaneNodeParent = node;
 }
 
 void QmlMitkRenderWindowItem::geometryChanged(const QRectF & newGeometry, const QRectF & oldGeometry)
 {
   QVTKQuickItem::geometryChanged(newGeometry, oldGeometry);
 
   this->resizeMitkEvent( newGeometry.width(), newGeometry.height() );
 }
 
 vtkRenderWindow* QmlMitkRenderWindowItem::GetVtkRenderWindow()
 {
   return QVTKQuickItem::GetRenderWindow();
 }
 
 vtkRenderWindowInteractor* QmlMitkRenderWindowItem::GetVtkRenderWindowInteractor()
 {
   return QVTKQuickItem::GetInteractor();
 }
 
 
diff --git a/Modules/QmlItems/QmlMitkRenderWindowItem.h b/Modules/QmlItems/QmlMitkRenderWindowItem.h
index 67e6328b83..93815e14a0 100644
--- a/Modules/QmlItems/QmlMitkRenderWindowItem.h
+++ b/Modules/QmlItems/QmlMitkRenderWindowItem.h
@@ -1,87 +1,102 @@
+/*===================================================================
+
+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 QmlMitkRenderWindowItem_h
 #define QmlMitkRenderWindowItem_h
 
 #include <QVTKQuickItem.h>
 
 #include "mitkRenderWindowBase.h"
 
 #include <QTimer>
 
 #include "MitkQmlItemsExports.h"
 
 /**
   \brief QML replacement for QmitkRenderWindow.
 
   A proof-of-concept render window. Currently exclusively
   for use in the QuickRender demo application.
 
   \warning Subject to change.
 */
 class MitkQmlItems_EXPORT QmlMitkRenderWindowItem : public QVTKQuickItem, public mitk::RenderWindowBase
 {
     Q_OBJECT
 
 public:
     static QmlMitkRenderWindowItem* GetInstanceForVTKRenderWindow( vtkRenderWindow* rw );
 
     QmlMitkRenderWindowItem(QQuickItem* parent = 0,
                             const QString& name = "QML render window",
                             mitk::VtkPropRenderer* renderer = NULL,
                             mitk::RenderingManager* renderingManager = NULL);
 
     virtual vtkRenderWindow* GetVtkRenderWindow();
     virtual vtkRenderWindowInteractor* GetVtkRenderWindowInteractor();
 
     void SetDataStorage(mitk::DataStorage::Pointer storage);
 
     void InitView( mitk::BaseRenderer::MapperSlotId mapperID,
                    mitk::SliceNavigationController::ViewDirection viewDirection );
 
     void SetPlaneNodeParent( mitk::DataNode::Pointer node );
 
     void SetCrossHairPositioningOnClick(bool enabled);
 
 signals:
 
 public slots:
 
 protected slots:
 
 protected:
 
   virtual void init();
   virtual void prepareForRender();
   virtual void cleanupAfterRender();
 
   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(QInputEvent* me) const;
   mitk::InteractionEvent::MouseButtons GetButtonState(QWheelEvent* we) const;
   void geometryChanged(const QRectF & newGeometry, const QRectF & oldGeometry); // !?
 
   virtual void mousePressEvent(QMouseEvent* e);
   virtual void mouseReleaseEvent(QMouseEvent* e);
   virtual void mouseMoveEvent(QMouseEvent* e);
   virtual void wheelEvent(QWheelEvent* e);
 
 private slots:
 
 private:
     mitk::DataStorage::Pointer m_DataStorage;
     mitk::DataNode::Pointer m_PlaneNodeParent;
 
     mitk::BaseRenderer::MapperSlotId m_MapperID;
     mitk::SliceNavigationController::ViewDirection m_ViewDirection;
 
 
     QTimer m_Animation;
 
     vtkSmartPointer<vtkEventQtSlotConnect> m_connect;
 
     static QMap<vtkRenderWindow*, QmlMitkRenderWindowItem*>& GetInstances();
 
 };
 
 #endif