diff --git a/Core/Code/Rendering/mitkRenderWindowBase.cpp b/Core/Code/Rendering/mitkRenderWindowBase.cpp
index eb49f375da..cc000d23c6 100644
--- a/Core/Code/Rendering/mitkRenderWindowBase.cpp
+++ b/Core/Code/Rendering/mitkRenderWindowBase.cpp
@@ -1,194 +1,205 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-07-05 09:49:37 +0200 (Mo, 05 Jul 2010) $
 Version:   $Revision: 24298 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #include "mitkRenderWindowBase.h"
 #include "mitkDisplayPositionEvent.h"
 #include "mitkVtkLayerController.h"
 #include "mitkRenderingManager.h"
 #include "vtkRenderer.h"
 
 
-mitk::RenderWindowBase::RenderWindowBase( ) : m_ProcessWheelEvents(true)
+mitk::RenderWindowBase::RenderWindowBase( ) 
+: m_ProcessWheelEvents(true),
+m_InvertScrollingDirection(false)
 {
 
 }
 
 /*
 * "Member functions, including virtual functions (10.3), can be called during construction or destruction (12.6.2). When a
 * virtual function is called directly or indirectly from a constructor (including from the mem-initializer for a data member) or from
 * a destructor, and the object to which the call applies is the object under construction or destruction, the function called is
 * the one defined in the constructor or destructor’s own class or in one of its bases, but not a function overriding it in a class
 * derived from the constructor or destructor’s class, or overriding it in one of the other base classes of the most derived object[..]"
 
 * or short: within constructors and destructors classes are not polymorph.
 */
 void mitk::RenderWindowBase::Initialize( mitk::RenderingManager* renderingManager, const char* name )
 {
   if ( renderingManager == NULL )
   {
     renderingManager = mitk::RenderingManager::GetInstance();
   }
   
   if(m_Renderer.IsNull())
   {
       m_Renderer = mitk::VtkPropRenderer::New( name , GetVtkRenderWindow(), renderingManager );
   }
 
   m_Renderer->InitRenderer(this->GetVtkRenderWindow());
 
   mitk::BaseRenderer::AddInstance(GetVtkRenderWindow(),m_Renderer);
 
   renderingManager->AddRenderWindow(GetVtkRenderWindow());
 
   m_RenderProp = vtkMitkRenderProp::New();
   m_RenderProp->SetPropRenderer(m_Renderer);
   m_Renderer->GetVtkRenderer()->AddViewProp(m_RenderProp);
 
   if((this->GetVtkRenderWindow()->GetSize()[0] > 10)
       && (this->GetVtkRenderWindow()->GetSize()[1] > 10))
     m_Renderer->InitSize(this->GetVtkRenderWindow()->GetSize()[0], this->GetVtkRenderWindow()->GetSize()[1]);
 
   m_InResize = false;  
 }
 
 void mitk::RenderWindowBase::Destroy()
 {
   m_Renderer->GetRenderingManager()->RemoveRenderWindow(GetVtkRenderWindow());
   mitk::BaseRenderer::RemoveInstance(GetVtkRenderWindow());
   m_Renderer->GetVtkRenderer()->RemoveViewProp(m_RenderProp);
   m_RenderProp->Delete();
 }
 
 mitk::RenderWindowBase::~RenderWindowBase()
 {
 
 }
 
 void mitk::RenderWindowBase::mousePressMitkEvent(mitk::MouseEvent *me)
 {
   if (m_Renderer.IsNotNull())
     m_Renderer->MousePressEvent(me);
 }
 
 void mitk::RenderWindowBase::mouseReleaseMitkEvent(mitk::MouseEvent *me)
 {
   if(m_Renderer.IsNotNull())
     m_Renderer->MouseReleaseEvent(me);
 }
 
 void mitk::RenderWindowBase::mouseMoveMitkEvent(mitk::MouseEvent *me)
 {
   if (m_Renderer.IsNotNull()) 
      m_Renderer->MouseMoveEvent(me);
 }
 
 void mitk::RenderWindowBase::wheelMitkEvent(mitk::WheelEvent *we)
 {
   if ( !m_ProcessWheelEvents )
     return;
  
   if ( !GetSliceNavigationController()->GetSliceLocked() )
   {
     mitk::Stepper* stepper = GetSliceNavigationController()->GetSlice();
 
     if (stepper->GetSteps() <= 1)
     {
       stepper = GetSliceNavigationController()->GetTime();
     }
 
-    //if (we->orientation() * we->GetDelta()  > 0)
-    if (we->GetDelta()  > 0)
+    // get the desired delta
+    int delta = we->GetDelta();
+    if ( m_InvertScrollingDirection )
+      delta *= -1;  // If we want to invert the scrolling direction -> delta * -1
+
+    if ( delta < 0 )
     {
       stepper->Next();
     }
     else
     {
       stepper->Previous();
     }
 
     //also send to Renderer to send if to MITK interaction mechanism
     if(m_Renderer.IsNotNull()) 
       m_Renderer->WheelEvent(we);
     
   }
 }
 
 void mitk::RenderWindowBase::keyPressMitkEvent(mitk::KeyEvent* mke)
 {
   if (m_Renderer.IsNotNull())
     m_Renderer->KeyPressEvent(mke);
 }
 
 
 void mitk::RenderWindowBase::resizeMitkEvent(int width, int height)
 {
   if(m_InResize) //@FIXME CRITICAL probably related to VtkSizeBug
     return;
   m_InResize = true;
 
   if(m_Renderer.IsNotNull())
   {
     m_Renderer->Resize(width, height);
   }
 
   m_InResize = false;
 }
 
 
 mitk::SliceNavigationController * mitk::RenderWindowBase::GetSliceNavigationController()
 {
   return mitk::BaseRenderer::GetInstance(this->GetVtkRenderWindow())->GetSliceNavigationController();
 }
 
 mitk::CameraRotationController * mitk::RenderWindowBase::GetCameraRotationController()
 {
   return mitk::BaseRenderer::GetInstance(this->GetVtkRenderWindow())->GetCameraRotationController();
 }
 
 mitk::BaseController * mitk::RenderWindowBase::GetController()
 {
   mitk::BaseRenderer * renderer = mitk::BaseRenderer::GetInstance(GetVtkRenderWindow());
   switch ( renderer->GetMapperID() )
   {
     case mitk::BaseRenderer::Standard2D:
       return GetSliceNavigationController();
 
     case mitk::BaseRenderer::Standard3D:
       return GetCameraRotationController();
 
     default:
       return GetSliceNavigationController();
   }
 }
 
 mitk::VtkPropRenderer* mitk::RenderWindowBase::GetRenderer()
 {
   return m_Renderer;
 }
 
 
 
 void mitk::RenderWindowBase::SetProcessWheelEvents( bool state )
 {
   m_ProcessWheelEvents = state;
 }
 
 bool mitk::RenderWindowBase::GetProcessWheelEvents()
 {
   return m_ProcessWheelEvents;
 }
+
+void mitk::RenderWindowBase::SetInvertScrollingDirection( bool invert )
+{
+  m_InvertScrollingDirection = invert;
+}
\ No newline at end of file
diff --git a/Core/Code/Rendering/mitkRenderWindowBase.h b/Core/Code/Rendering/mitkRenderWindowBase.h
index dbb32b20c5..6773d0fd65 100644
--- a/Core/Code/Rendering/mitkRenderWindowBase.h
+++ b/Core/Code/Rendering/mitkRenderWindowBase.h
@@ -1,97 +1,101 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-06-30 15:12:34 +0200 (Mi, 30. Jun 2010) $
 Version:   $Revision: 24176 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef MITKRENDERWINDOWBASE_H_HEADER_INCLUDED_C1C40D66ASDF
 #define MITKRENDERWINDOWBASE_H_HEADER_INCLUDED_C1C40D66ASDF
 
 #include "mitkCommon.h"
 
 #include "mitkVtkPropRenderer.h"
 #include "vtkMitkRenderProp.h"
 #include "mitkSliceNavigationController.h"
 #include "mitkCameraRotationController.h"
 
 namespace mitk
 {
 
 /**
  * \brief Base class of MITK RenderWindows
  *
  * This class sets up the MITK rendering mechanism and it's integration into VTK.
  *
  * Currently, there are two specific implementations of this abstract class:
  * QmitkRenderWindow, inerhits from the QVTKWidget and is the matured way for MITK rendering
  * mitkRenderWindow is a new, QT-independent RenderWindow implementation
  *
  * \ingroup Renderer
  */
 class MITK_CORE_EXPORT RenderWindowBase
 {
   
 
 public:
   
   //mitkClassMacro(RenderWindowBase,itk::Object);
   //itkNewMacro(Self);
 
   
   virtual ~RenderWindowBase();
 
   void InitRenderer();
 
   virtual mitk::SliceNavigationController * GetSliceNavigationController();
   virtual mitk::CameraRotationController * GetCameraRotationController();
   virtual mitk::BaseController * GetController();
   virtual mitk::VtkPropRenderer* GetRenderer();
   virtual vtkRenderWindow* GetVtkRenderWindow() = 0;
   virtual vtkRenderWindowInteractor* GetVtkRenderWindowInteractor() = 0;
 
   
   void SetProcessWheelEvents( bool state );
 
   bool GetProcessWheelEvents();
 
+  void SetInvertScrollingDirection( bool );
+
   virtual void mousePressMitkEvent(mitk::MouseEvent *me);
   virtual void mouseReleaseMitkEvent(mitk::MouseEvent *me);
   virtual void mouseMoveMitkEvent(mitk::MouseEvent *me);
   virtual void wheelMitkEvent(mitk::WheelEvent *we);
   virtual void keyPressMitkEvent(mitk::KeyEvent* mke);
   virtual void resizeMitkEvent(int width, int height);
  
 protected:
   RenderWindowBase();
 
   // helper functions: within constructors and destructors classes are not polymorph.
   void Initialize( mitk::RenderingManager* renderingManager = NULL, const char* name = "unnamed renderer" );
   void Destroy();
 
   mitk::VtkPropRenderer::Pointer m_Renderer;
 
   vtkMitkRenderProp*             m_RenderProp;
 
   bool                           m_InResize;
 
   bool                           m_ProcessWheelEvents;
 
+  bool                           m_InvertScrollingDirection;
+
   private:
 
 };
 
 }
 
 #endif /* MITKRENDERWINDOWBASE_H_HEADER_INCLUDED_C1C40D66ASDF */