diff --git a/Applications/mitkWorkbench/mitkWorkbench.cpp b/Applications/mitkWorkbench/mitkWorkbench.cpp
index c24b629a2b..5784e0e8c0 100644
--- a/Applications/mitkWorkbench/mitkWorkbench.cpp
+++ b/Applications/mitkWorkbench/mitkWorkbench.cpp
@@ -1,150 +1,143 @@
 /*===================================================================
 
 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 <application/berryStarter.h>
 #include <Poco/Util/MapConfiguration.h>
 
 #include <QApplication>
 #include <QMessageBox>
 #include <QtSingleApplication>
-#include <QtGlobal>
-#include <QTime>
 
 #include <mitkCommon.h>
 #include <mitkException.h>
 
 class QtSafeApplication : public QtSingleApplication
 {
 
 public:
 
   QtSafeApplication(int& argc, char** argv) : QtSingleApplication(argc, argv)
   {}
 
   /**
    * Reimplement notify to catch unhandled exceptions and open an error message.
    *
    * @param receiver
    * @param event
    * @return
    */
   bool notify(QObject* receiver, QEvent* event)
   {
     QString msg;
     try
     {
       return QApplication::notify(receiver, event);
     }
     catch (mitk::Exception& e)
     {
       msg = QString("MITK Exception:\n\n")
             + QString("Desciption: ")
             + QString(e.GetDescription()) + QString("\n\n")
             + QString("Filename: ") + QString(e.GetFile()) + QString("\n\n")
             + QString("Line: ") + QString::number(e.GetLine());
     }
     catch (Poco::Exception& e)
     {
       msg = QString::fromStdString(e.displayText());
     }
     catch (std::exception& e)
     {
       msg = e.what();
     }
     catch (...)
     {
       msg = "Unknown exception";
     }
     MITK_ERROR << "An error occurred: " << msg.toStdString();
 
     QMessageBox msgBox;
     msgBox.setText("An error occurred. You should save all data and quit the program to prevent possible data loss.");
     msgBox.setDetailedText(msg);
     msgBox.setIcon(QMessageBox::Critical);
     msgBox.addButton(trUtf8("Exit immediately"), QMessageBox::YesRole);
     msgBox.addButton(trUtf8("Ignore"), QMessageBox::NoRole);
 
     int ret = msgBox.exec();
 
     switch(ret)
       {
       case 0:
         MITK_ERROR << "The program was closed.";
         this->closeAllWindows();
         break;
       case 1:
         MITK_ERROR << "The error was ignored by the user. The program may be in a corrupt state and don't behave like expected!";
         break;
       }
 
     return false;
   }
 
 };
 
 
 int main(int argc, char** argv)
 {
   // Create a QApplication instance first
   QtSafeApplication qSafeApp(argc, argv);
   qSafeApp.setApplicationName("MITK Workbench");
   qSafeApp.setOrganizationName("DKFZ");
 
   // This function checks if an instance is already running
   // and either sends a message to it (containing the command
   // line arguments) or checks if a new instance was forced by
   // providing the BlueBerry.newInstance command line argument.
   // In the latter case, a path to a temporary directory for
   // the new application's storage directory is returned.
   QString storageDir = handleNewAppInstance(&qSafeApp, argc, argv, "BlueBerry.newInstance");
 
   // These paths replace the .ini file and are tailored for installation
   // packages created with CPack. If a .ini file is presented, it will
   // overwrite the settings in MapConfiguration
   Poco::Path basePath(argv[0]);
   basePath.setFileName("");
 
   Poco::Path provFile(basePath);
   provFile.setFileName("mitkWorkbench.provisioning");
 
   Poco::Path extPath(basePath);
   extPath.pushDirectory("ExtBundles");
 
   std::string pluginDirs = extPath.toString();
 
   Poco::Util::MapConfiguration* extConfig(new Poco::Util::MapConfiguration());
   if (!storageDir.isEmpty())
   {
     extConfig->setString(berry::Platform::ARG_STORAGE_DIR, storageDir.toStdString());
   }
   extConfig->setString(berry::Platform::ARG_PLUGIN_DIRS, pluginDirs);
   extConfig->setString(berry::Platform::ARG_PROVISIONING, provFile.toString());
   extConfig->setString(berry::Platform::ARG_APPLICATION, "org.mitk.qt.extapplication");
 
   // Preload the org.mitk.gui.qt.ext plug-in (and hence also QmitkExt) to speed
   // up a clean-cache start. This also works around bugs in older gcc and glibc implementations,
   // which have difficulties with multiple dynamic opening and closing of shared libraries with
   // many global static initializers. It also helps if dependent libraries have weird static
   // initialization methods and/or missing de-initialization code.
   extConfig->setString(berry::Platform::ARG_PRELOAD_LIBRARY, "liborg_mitk_gui_qt_ext,libCTKDICOMCore:0.1");
 
-  // Seed the random number generator, once at startup.
-  QTime time = QTime::currentTime();
-  qsrand((uint)time.msec());
-
-  // Run the workbench.
   return berry::Starter::Run(argc, argv, extConfig);
 }
diff --git a/Core/Code/Controllers/mitkRenderingManager.cpp b/Core/Code/Controllers/mitkRenderingManager.cpp
index f5ec1caf5f..5069225c2c 100644
--- a/Core/Code/Controllers/mitkRenderingManager.cpp
+++ b/Core/Code/Controllers/mitkRenderingManager.cpp
@@ -1,1032 +1,1033 @@
 /*===================================================================
 
 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 "mitkRenderingManager.h"
 #include "mitkRenderingManagerFactory.h"
 #include "mitkBaseRenderer.h"
 #include "mitkGlobalInteraction.h"
 
 #include <vtkRenderWindow.h>
 
 #include <itkCommand.h>
 #include "mitkVector.h"
 #include <itkAffineGeometryFrame.h>
 #include <itkScalableAffineTransform.h>
 #include <mitkVtkPropRenderer.h>
 
 #include <algorithm>
 
 namespace mitk
 {
 
 RenderingManager::Pointer RenderingManager::s_Instance = 0;
 RenderingManagerFactory *RenderingManager::s_RenderingManagerFactory = 0;
 
 
 RenderingManager
 ::RenderingManager()
 : m_UpdatePending( false ),
   m_MaxLOD( 1 ),
   m_LODIncreaseBlocked( false ),
   m_LODAbortMechanismEnabled( false ),
   m_ClippingPlaneEnabled( false ),
   m_TimeNavigationController( SliceNavigationController::New("dummy") ),
   m_DataStorage( NULL ),
   m_ConstrainedPaddingZooming ( true )
 {
   m_ShadingEnabled.assign( 3, false );
   m_ShadingValues.assign( 4, 0.0 );
 
   m_GlobalInteraction = mitk::GlobalInteraction::GetInstance();
 
   InitializePropertyList();
 }
 
 
 RenderingManager
 ::~RenderingManager()
 {
   // Decrease reference counts of all registered vtkRenderWindows for
   // proper destruction
   RenderWindowVector::iterator it;
   for ( it = m_AllRenderWindows.begin(); it != m_AllRenderWindows.end(); ++it )
   {
     (*it)->UnRegister( NULL );
 
     RenderWindowCallbacksList::iterator callbacks_it = this->m_RenderWindowCallbacksList.find(*it);
 
     if (callbacks_it != this->m_RenderWindowCallbacksList.end())
     {
       (*it)->RemoveObserver(callbacks_it->second.commands[0u]);
       (*it)->RemoveObserver(callbacks_it->second.commands[1u]);
       (*it)->RemoveObserver(callbacks_it->second.commands[2u]);
     }
   }
 }
 
 
 void
 RenderingManager
 ::SetFactory( RenderingManagerFactory *factory )
 {
   s_RenderingManagerFactory = factory;
 }
 
 
 const RenderingManagerFactory *
 RenderingManager
 ::GetFactory()
 {
   return s_RenderingManagerFactory;
 }
 
 
 bool
 RenderingManager
 ::HasFactory()
 {
   if ( RenderingManager::s_RenderingManagerFactory )
   {
     return true;
   }
   else
   {
     return false;
   }
 }
 
 
 RenderingManager::Pointer
 RenderingManager
 ::New()
 {
   const RenderingManagerFactory* factory = GetFactory();
   if(factory == NULL)
     return NULL;
   return factory->CreateRenderingManager();
 }
 
 RenderingManager *
 RenderingManager
 ::GetInstance()
 {
   if ( !RenderingManager::s_Instance )
   {
     if ( s_RenderingManagerFactory )
     {
       s_Instance = s_RenderingManagerFactory->CreateRenderingManager();
     }
   }
 
   return s_Instance;
 }
 
 
 bool
 RenderingManager
 ::IsInstantiated()
 {
   if ( RenderingManager::s_Instance )
     return true;
   else
     return false;
 }
 
 
 void
 RenderingManager
 ::AddRenderWindow( vtkRenderWindow *renderWindow )
 {
   if ( renderWindow
     && (m_RenderWindowList.find( renderWindow ) == m_RenderWindowList.end()) )
   {
     m_RenderWindowList[renderWindow] = RENDERING_INACTIVE;
     m_AllRenderWindows.push_back( renderWindow );
 
     if ( m_DataStorage.IsNotNull() )
       mitk::BaseRenderer::GetInstance( renderWindow )->SetDataStorage( m_DataStorage.GetPointer() );
 
 
     // Register vtkRenderWindow instance
     renderWindow->Register( NULL );
 
     typedef itk::MemberCommand< RenderingManager > MemberCommandType;
 
     // Add callbacks for rendering abort mechanism
     //BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
     vtkCallbackCommand *startCallbackCommand = vtkCallbackCommand::New();
     startCallbackCommand->SetCallback(
       RenderingManager::RenderingStartCallback );
     renderWindow->AddObserver( vtkCommand::StartEvent, startCallbackCommand );
 
     vtkCallbackCommand *progressCallbackCommand = vtkCallbackCommand::New();
     progressCallbackCommand->SetCallback(
       RenderingManager::RenderingProgressCallback );
     renderWindow->AddObserver( vtkCommand::AbortCheckEvent, progressCallbackCommand );
 
     vtkCallbackCommand *endCallbackCommand = vtkCallbackCommand::New();
     endCallbackCommand->SetCallback(
       RenderingManager::RenderingEndCallback );
     renderWindow->AddObserver( vtkCommand::EndEvent, endCallbackCommand );
 
     RenderWindowCallbacks callbacks;
 
     callbacks.commands[0u] = startCallbackCommand;
     callbacks.commands[1u] = progressCallbackCommand;
     callbacks.commands[2u] = endCallbackCommand;
     this->m_RenderWindowCallbacksList[renderWindow] = callbacks;
 
     //Delete vtk variables correctly
     startCallbackCommand->Delete();
     progressCallbackCommand->Delete();
     endCallbackCommand->Delete();
 
   }
 }
 
 
 void
 RenderingManager
 ::RemoveRenderWindow( vtkRenderWindow *renderWindow )
 {
   if (m_RenderWindowList.erase( renderWindow ))
   {
     RenderWindowCallbacksList::iterator callbacks_it = this->m_RenderWindowCallbacksList.find(renderWindow);
     if(callbacks_it != this->m_RenderWindowCallbacksList.end())
     {
       renderWindow->RemoveObserver(callbacks_it->second.commands[0u]);
       renderWindow->RemoveObserver(callbacks_it->second.commands[1u]);
       renderWindow->RemoveObserver(callbacks_it->second.commands[2u]);
       this->m_RenderWindowCallbacksList.erase(callbacks_it);
     }
 
     RenderWindowVector::iterator rw_it = std::find( m_AllRenderWindows.begin(), m_AllRenderWindows.end(), renderWindow );
 
     if(rw_it != m_AllRenderWindows.end())
     {
       // Decrease reference count for proper destruction
       (*rw_it)->UnRegister(NULL);
       m_AllRenderWindows.erase( rw_it );
     }
   }
 }
 
 
 const RenderingManager::RenderWindowVector&
 RenderingManager
 ::GetAllRegisteredRenderWindows()
 {
   return m_AllRenderWindows;
 }
 
 
 void
 RenderingManager
 ::RequestUpdate( vtkRenderWindow *renderWindow )
 {
+
   // If the renderWindow is not valid, we do not want to inadvertantly create
   // an entry in the m_RenderWindowList map. It is possible if the user is
   // regularly calling AddRenderer and RemoveRenderer for a rendering update
   // to come into this method with a renderWindow pointer that is valid in the
   // sense that the window does exist within the application, but that
   // renderWindow has been temporarily removed from this RenderingManager for
   // performance reasons.
   if (m_RenderWindowList.find( renderWindow ) == m_RenderWindowList.end())
   {
     return;
   }
 
   m_RenderWindowList[renderWindow] = RENDERING_REQUESTED;
 
   if ( !m_UpdatePending )
   {
     m_UpdatePending = true;
     this->GenerateRenderingRequestEvent();
   }
 }
 
 
 void
 RenderingManager
 ::ForceImmediateUpdate( vtkRenderWindow *renderWindow )
 {
   // If the renderWindow is not valid, we do not want to inadvertantly create
   // an entry in the m_RenderWindowList map. It is possible if the user is
   // regularly calling AddRenderer and RemoveRenderer for a rendering update
   // to come into this method with a renderWindow pointer that is valid in the
   // sense that the window does exist within the application, but that
   // renderWindow has been temporarily removed from this RenderingManager for
   // performance reasons.
   if (m_RenderWindowList.find( renderWindow ) == m_RenderWindowList.end())
   {
     return;
   }
 
   // Erase potentially pending requests for this window
   m_RenderWindowList[renderWindow] = RENDERING_INACTIVE;
 
   m_UpdatePending = false;
 
   // Immediately repaint this window (implementation platform specific)
   // If the size is 0 it crahses
   int *size = renderWindow->GetSize();
   if ( 0 != size[0] && 0 != size[1] )
   {
     //prepare the camera etc. before rendering
     //Note: this is a very important step which should be called before the VTK render!
     //If you modify the camera anywhere else or after the render call, the scene cannot be seen.
     mitk::VtkPropRenderer *vPR =
         dynamic_cast<mitk::VtkPropRenderer*>(mitk::BaseRenderer::GetInstance( renderWindow ));
     if(vPR)
        vPR->PrepareRender();
     // Execute rendering
     renderWindow->Render();
   }
 }
 
 
 void
 RenderingManager
 ::RequestUpdateAll( RequestType type )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     int id = BaseRenderer::GetInstance(it->first)->GetMapperID();
     if ( (type == REQUEST_UPDATE_ALL)
       || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
       || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
     {
        this->RequestUpdate( it->first );
     }
   }
 }
 
 
 void
 RenderingManager
 ::ForceImmediateUpdateAll( RequestType type )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     int id = BaseRenderer::GetInstance(it->first)->GetMapperID();
     if ( (type == REQUEST_UPDATE_ALL)
       || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
       || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
     {
       // Immediately repaint this window (implementation platform specific)
       // If the size is 0, it crashes
       this->ForceImmediateUpdate(it->first);
 
   //    int *size = it->first->GetSize();
   //    if ( 0 != size[0] && 0 != size[1] )
   //    {
   //      //prepare the camera before rendering
   //      //Note: this is a very important step which should be called before the VTK render!
   //      //If you modify the camera anywhere else or after the render call, the scene cannot be seen.
   //      mitk::VtkPropRenderer *vPR =
   //          dynamic_cast<mitk::VtkPropRenderer*>(mitk::BaseRenderer::GetInstance( it->first ));
       //      if(vPR)
       //         vPR->PrepareRender();
       //      // Execute rendering
       //      it->first->Render();
       //    }
 
       //    it->second = RENDERING_INACTIVE;
     }
   }
 
   //m_UpdatePending = false;
 }
 
 
 //bool RenderingManager::InitializeViews( const mitk::DataStorage * storage, const DataNode* node = NULL, RequestType type, bool preserveRoughOrientationInWorldSpace )
 //{
 //  mitk::Geometry3D::Pointer geometry;
 //  if ( storage != NULL )
 //  {
 //    geometry = storage->ComputeVisibleBoundingGeometry3D(node, "visible", NULL, "includeInBoundingBox" );
 //
 //    if ( geometry.IsNotNull() )
 //    {
 //      // let's see if we have data with a limited live-span ...
 //      mitk::TimeBounds timebounds = geometry->GetTimeBounds();
 //      if ( timebounds[1] < mitk::ScalarTypeNumericTraits::max() )
 //      {
 //        mitk::ScalarType duration = timebounds[1]-timebounds[0];
 //
 //        mitk::TimeSlicedGeometry::Pointer timegeometry =
 //          mitk::TimeSlicedGeometry::New();
 //        timegeometry->InitializeEvenlyTimed(
 //          geometry, (unsigned int) duration );
 //        timegeometry->SetTimeBounds( timebounds );
 //
 //        timebounds[1] = timebounds[0] + 1.0;
 //        geometry->SetTimeBounds( timebounds );
 //
 //        geometry = timegeometry;
 //      }
 //    }
 //  }
 //
 //  // Use geometry for initialization
 //  return this->InitializeViews( geometry.GetPointer(), type );
 //}
 
 
 bool
 RenderingManager
 ::InitializeViews( const Geometry3D * dataGeometry, RequestType type, bool preserveRoughOrientationInWorldSpace )
 {
   MITK_DEBUG << "initializing views";
 
   bool boundingBoxInitialized = false;
 
   Geometry3D::ConstPointer geometry = dataGeometry;
 
   if (dataGeometry && preserveRoughOrientationInWorldSpace)
   {
 
     // clone the input geometry
     Geometry3D::Pointer modifiedGeometry = dynamic_cast<Geometry3D*>( dataGeometry->Clone().GetPointer() );
     assert(modifiedGeometry.IsNotNull());
 
     // construct an affine transform from it
     AffineGeometryFrame3D::TransformType::Pointer transform = AffineGeometryFrame3D::TransformType::New();
     assert( modifiedGeometry->GetIndexToWorldTransform() );
     transform->SetMatrix( modifiedGeometry->GetIndexToWorldTransform()->GetMatrix() );
     transform->SetOffset( modifiedGeometry->GetIndexToWorldTransform()->GetOffset() );
 
     // get transform matrix
     AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType& oldMatrix =
       const_cast< AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType& > ( transform->GetMatrix().GetVnlMatrix() );
     AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType newMatrix(oldMatrix);
 
     // get offset and bound
     Vector3D offset = modifiedGeometry->GetIndexToWorldTransform()->GetOffset();
     Geometry3D::BoundsArrayType oldBounds = modifiedGeometry->GetBounds();
     Geometry3D::BoundsArrayType newBounds = modifiedGeometry->GetBounds();
 
     // get rid of rotation other than pi/2 degree
     for ( unsigned int i = 0; i < 3; ++i )
     {
 
       // i-th column of the direction matrix
       Vector3D currentVector;
       currentVector[0] = oldMatrix(0,i);
       currentVector[1] = oldMatrix(1,i);
       currentVector[2] = oldMatrix(2,i);
 
       // matchingRow will store the row that holds the biggest
       // value in the column
       unsigned int matchingRow = 0;
 
       // maximum value in the column
       float max = std::numeric_limits<float>::min();
 
       // sign of the maximum value (-1 or 1)
       int sign = 1;
 
       // iterate through the column vector
       for (unsigned int dim = 0; dim < 3; ++dim)
       {
         if ( fabs(currentVector[dim]) > max )
         {
           matchingRow = dim;
           max = fabs(currentVector[dim]);
           if(currentVector[dim]<0)
             sign = -1;
           else
             sign = 1;
         }
       }
 
       // in case we found a negative maximum,
       // we negate the column and adjust the offset
       // (in order to run through the dimension in the opposite direction)
       if(sign == -1)
       {
         currentVector *= sign;
         offset += modifiedGeometry->GetAxisVector(i);
       }
 
 
       // matchingRow is now used as column index to place currentVector
       // correctly in the new matrix
       vnl_vector<ScalarType> newMatrixColumn(3);
       newMatrixColumn[0] = currentVector[0];
       newMatrixColumn[1] = currentVector[1];
       newMatrixColumn[2] = currentVector[2];
       newMatrix.set_column( matchingRow, newMatrixColumn );
 
       // if a column is moved, we also have to adjust the bounding
       // box accordingly, this is done here
       newBounds[2*matchingRow  ] = oldBounds[2*i  ];
       newBounds[2*matchingRow+1] = oldBounds[2*i+1];
     }
 
     // set the newly calculated bounds array
     modifiedGeometry->SetBounds(newBounds);
 
     // set new offset and direction matrix
     AffineGeometryFrame3D::TransformType::MatrixType newMatrixITK( newMatrix );
     transform->SetMatrix( newMatrixITK );
     transform->SetOffset( offset );
     modifiedGeometry->SetIndexToWorldTransform( transform );
     geometry = modifiedGeometry;
 
   }
 
   int warningLevel = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   if ( (geometry.IsNotNull() ) && (const_cast< mitk::BoundingBox * >(
     geometry->GetBoundingBox())->GetDiagonalLength2() > mitk::eps) )
   {
     boundingBoxInitialized = true;
   }
 
   if (geometry.IsNotNull() )
   {// make sure bounding box has an extent bigger than zero in any direction
     // clone the input geometry
     Geometry3D::Pointer modifiedGeometry = dynamic_cast<Geometry3D*>( dataGeometry->Clone().GetPointer() );
     assert(modifiedGeometry.IsNotNull());
     Geometry3D::BoundsArrayType newBounds = modifiedGeometry->GetBounds();
     for( unsigned int dimension = 0; ( 2 * dimension ) < newBounds.Size() ; dimension++ )
     {
       //check for equality but for an epsilon
       if( Equal( newBounds[ 2 * dimension ], newBounds[ 2 * dimension + 1 ] ) )
       {
         newBounds[ 2 * dimension + 1 ] += 1;
       }
     }
 
     // set the newly calculated bounds array
     modifiedGeometry->SetBounds(newBounds);
 
     geometry = modifiedGeometry;
   }
 
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     mitk::BaseRenderer *baseRenderer =
       mitk::BaseRenderer::GetInstance( it->first );
 
     baseRenderer->GetDisplayGeometry()->SetConstrainZoomingAndPanning(m_ConstrainedPaddingZooming);
 
     int id = baseRenderer->GetMapperID();
     if ( ((type == REQUEST_UPDATE_ALL)
       || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
       || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)))
       )
     {
       this->InternalViewInitialization( baseRenderer, geometry,
         boundingBoxInitialized, id );
     }
   }
 
   if ( boundingBoxInitialized )
   {
     m_TimeNavigationController->SetInputWorldGeometry( geometry );
   }
   m_TimeNavigationController->Update();
 
   this->RequestUpdateAll( type );
 
   vtkObject::SetGlobalWarningDisplay( warningLevel );
 
   // Inform listeners that views have been initialized
   this->InvokeEvent( mitk::RenderingManagerViewsInitializedEvent() );
 
 
   return boundingBoxInitialized;
 }
 
 
 bool
 RenderingManager
 ::InitializeViews( RequestType type )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     mitk::BaseRenderer *baseRenderer =
       mitk::BaseRenderer::GetInstance( it->first );
     int id = baseRenderer->GetMapperID();
     if ( (type == REQUEST_UPDATE_ALL)
       || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
       || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
     {
 
       mitk::SliceNavigationController *nc =
 
       baseRenderer->GetSliceNavigationController();
 
       // Re-initialize view direction
       nc->SetViewDirectionToDefault();
 
       // Update the SNC
       nc->Update();
     }
   }
 
   this->RequestUpdateAll( type );
 
   return true;
 }
 
 //bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow, const DataStorage* ds, const DataNode node = NULL,  bool initializeGlobalTimeSNC )
 //{
 //  mitk::Geometry3D::Pointer geometry;
 //  if ( ds != NULL )
 //  {
 //    geometry = ds->ComputeVisibleBoundingGeometry3D(node, NULL, "includeInBoundingBox" );
 //
 //    if ( geometry.IsNotNull() )
 //    {
 //      // let's see if we have data with a limited live-span ...
 //      mitk::TimeBounds timebounds = geometry->GetTimeBounds();
 //      if ( timebounds[1] < mitk::ScalarTypeNumericTraits::max() )
 //      {
 //        mitk::ScalarType duration = timebounds[1]-timebounds[0];
 //
 //        mitk::TimeSlicedGeometry::Pointer timegeometry =
 //          mitk::TimeSlicedGeometry::New();
 //        timegeometry->InitializeEvenlyTimed(
 //          geometry, (unsigned int) duration );
 //        timegeometry->SetTimeBounds( timebounds );
 //
 //        timebounds[1] = timebounds[0] + 1.0;
 //        geometry->SetTimeBounds( timebounds );
 //
 //        geometry = timegeometry;
 //      }
 //    }
 //  }
 //
 //  // Use geometry for initialization
 //  return this->InitializeView( renderWindow,
 //    geometry.GetPointer(), initializeGlobalTimeSNC );
 //}
 
 bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow, const Geometry3D * geometry, bool initializeGlobalTimeSNC )
 {
   bool boundingBoxInitialized = false;
 
   int warningLevel = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   if ( (geometry != NULL ) && (const_cast< mitk::BoundingBox * >(
    geometry->GetBoundingBox())->GetDiagonalLength2() > mitk::eps) )
   {
    boundingBoxInitialized = true;
   }
 
   mitk::BaseRenderer *baseRenderer =
    mitk::BaseRenderer::GetInstance( renderWindow );
 
   int id = baseRenderer->GetMapperID();
 
   this->InternalViewInitialization( baseRenderer, geometry,
    boundingBoxInitialized, id );
 
   if ( boundingBoxInitialized && initializeGlobalTimeSNC )
   {
     m_TimeNavigationController->SetInputWorldGeometry( geometry );
   }
   m_TimeNavigationController->Update();
 
   this->RequestUpdate( renderWindow );
 
   vtkObject::SetGlobalWarningDisplay( warningLevel );
 
   return boundingBoxInitialized;
 }
 
 
 bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow )
 {
   mitk::BaseRenderer *baseRenderer =
       mitk::BaseRenderer::GetInstance( renderWindow );
 
   mitk::SliceNavigationController *nc =
     baseRenderer->GetSliceNavigationController();
 
   // Re-initialize view direction
   nc->SetViewDirectionToDefault();
 
   // Update the SNC
   nc->Update();
 
   this->RequestUpdate( renderWindow );
 
   return true;
 }
 
 
 void RenderingManager::InternalViewInitialization(mitk::BaseRenderer *baseRenderer, const mitk::Geometry3D *geometry, bool boundingBoxInitialized, int mapperID )
 {
   mitk::SliceNavigationController *nc = baseRenderer->GetSliceNavigationController();
 
   // Re-initialize view direction
   nc->SetViewDirectionToDefault();
 
   if ( boundingBoxInitialized )
   {
     // Set geometry for NC
     nc->SetInputWorldGeometry( geometry );
     nc->Update();
 
     if ( mapperID == 1 )
     {
       // For 2D SNCs, steppers are set so that the cross is centered
       // in the image
       nc->GetSlice()->SetPos( nc->GetSlice()->GetSteps() / 2 );
     }
 
     // Fit the render window DisplayGeometry
     baseRenderer->GetDisplayGeometry()->Fit();
     baseRenderer->GetCameraController()->SetViewToAnterior();
   }
   else
   {
     nc->Update();
   }
 }
 
 
 const SliceNavigationController* RenderingManager::GetTimeNavigationController() const
 {
   return m_TimeNavigationController.GetPointer();
 }
 
 
 SliceNavigationController* RenderingManager::GetTimeNavigationController()
 {
   return m_TimeNavigationController.GetPointer();
 }
 
 
 void RenderingManager::ExecutePendingRequests()
 {
   m_UpdatePending = false;
 
   // Satisfy all pending update requests
   RenderWindowList::iterator it;
   int i = 0;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it, ++i )
   {
     if ( it->second == RENDERING_REQUESTED )
     {
       this->ForceImmediateUpdate( it->first );
     }
   }
 }
 
 
 void RenderingManager::RenderingStartCallback( vtkObject *caller, unsigned long , void *, void * )
 {
   vtkRenderWindow *renderWindow  = dynamic_cast< vtkRenderWindow * >( caller );
   mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
   RenderWindowList &renderWindowList = renman->m_RenderWindowList;
 
   if ( renderWindow )
   {
     renderWindowList[renderWindow] = RENDERING_INPROGRESS;
   }
 
   renman->m_UpdatePending = false;
 }
 
 
 void
 RenderingManager
 ::RenderingProgressCallback( vtkObject *caller, unsigned long , void *, void * )
 {
   vtkRenderWindow *renderWindow  = dynamic_cast< vtkRenderWindow * >( caller );
   mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
 
   if ( renman->m_LODAbortMechanismEnabled )
   {
     vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
     if ( renderWindow )
     {
       BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
       if ( renderer && (renderer->GetNumberOfVisibleLODEnabledMappers() > 0) )
       {
         renman->DoMonitorRendering();
       }
     }
   }
 }
 
 void
 RenderingManager
 ::RenderingEndCallback( vtkObject *caller, unsigned long , void *, void * )
 {
   vtkRenderWindow *renderWindow  = dynamic_cast< vtkRenderWindow * >( caller );
 
   mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
 
   RenderWindowList &renderWindowList = renman->m_RenderWindowList;
 
   RendererIntMap &nextLODMap = renman->m_NextLODMap;
 
   if ( renderWindow )
   {
     BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
     if ( renderer )
     {
       renderWindowList[renderer->GetRenderWindow()] = RENDERING_INACTIVE;
 
       // Level-of-Detail handling
       if ( renderer->GetNumberOfVisibleLODEnabledMappers() > 0 )
       {
         if(nextLODMap[renderer]==0)
           renman->StartOrResetTimer();
         else
           nextLODMap[renderer] = 0;
       }
     }
   }
 }
 
 
 bool
 RenderingManager
 ::IsRendering() const
 {
   RenderWindowList::const_iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     if ( it->second == RENDERING_INPROGRESS )
     {
       return true;
     }
   }
   return false;
 }
 
 
 void
 RenderingManager
 ::AbortRendering()
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     if ( it->second == RENDERING_INPROGRESS )
     {
       it->first->SetAbortRender( true );
       m_RenderingAbortedMap[BaseRenderer::GetInstance(it->first)] = true;
     }
   }
 }
 
 
 int
 RenderingManager
 ::GetNextLOD( BaseRenderer *renderer )
 {
   if ( renderer != NULL )
   {
     return m_NextLODMap[renderer];
   }
   else
   {
     return 0;
   }
 }
 
 
 void
 RenderingManager
 ::ExecutePendingHighResRenderingRequest()
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     BaseRenderer *renderer = BaseRenderer::GetInstance( it->first );
 
     if(renderer->GetNumberOfVisibleLODEnabledMappers()>0)
     {
       if(m_NextLODMap[renderer]==0)
       {
         m_NextLODMap[renderer]=1;
         RequestUpdate( it->first );
       }
     }
   }
 }
 
 void
 RenderingManager
 ::SetMaximumLOD( unsigned int max )
 {
   m_MaxLOD = max;
 }
 
 
 //enable/disable shading
 void
 RenderingManager
 ::SetShading(bool state, unsigned int lod)
 {
   if(lod>m_MaxLOD)
   {
     itkWarningMacro(<<"LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD);
     return;
   }
   m_ShadingEnabled[lod] = state;
 
 }
 
 bool
 RenderingManager
 ::GetShading(unsigned int lod)
 {
   if(lod>m_MaxLOD)
   {
     itkWarningMacro(<<"LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD);
     return false;
   }
   return m_ShadingEnabled[lod];
 }
 
 
 //enable/disable the clipping plane
 void
 RenderingManager
 ::SetClippingPlaneStatus(bool status)
 {
   m_ClippingPlaneEnabled = status;
 }
 
 
 bool
 RenderingManager
 ::GetClippingPlaneStatus()
 {
   return m_ClippingPlaneEnabled;
 }
 
 
 void
 RenderingManager
 ::SetShadingValues(float ambient, float diffuse, float specular, float specpower)
 {
   m_ShadingValues[0] = ambient;
   m_ShadingValues[1] = diffuse;
   m_ShadingValues[2] = specular;
   m_ShadingValues[3] = specpower;
 }
 
 
 RenderingManager::FloatVector &
 RenderingManager
 ::GetShadingValues()
 {
   return m_ShadingValues;
 }
 
 void RenderingManager::SetDepthPeelingEnabled( bool enabled )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance( it->first );
     baseRenderer->SetDepthPeelingEnabled(enabled);
   }
 }
 
 void RenderingManager::SetMaxNumberOfPeels( int maxNumber )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance( it->first );
     baseRenderer->SetMaxNumberOfPeels(maxNumber);
   }
 }
 
 void RenderingManager::InitializePropertyList()
 {
   if (m_PropertyList.IsNull())
   {
     m_PropertyList = PropertyList::New();
   }
 
   this->SetProperty("coupled-zoom", BoolProperty::New(false));
   this->SetProperty("coupled-plane-rotation", BoolProperty::New(false));
   this->SetProperty("MIP-slice-rendering", BoolProperty::New(false));
 }
 
 PropertyList::Pointer RenderingManager::GetPropertyList() const
 {
   return m_PropertyList;
 }
 
 BaseProperty* RenderingManager::GetProperty(const char *propertyKey) const
 {
   return m_PropertyList->GetProperty(propertyKey);
 }
 
 void RenderingManager::SetProperty(const char *propertyKey, BaseProperty* propertyValue)
 {
   m_PropertyList->SetProperty(propertyKey, propertyValue);
 }
 
 
 void RenderingManager::SetDataStorage( DataStorage* storage )
 {
   if ( storage != NULL )
   {
     m_DataStorage = storage;
 
     RenderingManager::RenderWindowVector::iterator iter;
     for ( iter = m_AllRenderWindows.begin(); iter<m_AllRenderWindows.end(); iter++ )
     {
       mitk::BaseRenderer::GetInstance( (*iter) )->SetDataStorage( m_DataStorage.GetPointer() );
     }
   }
 }
 
 mitk::DataStorage* RenderingManager::GetDataStorage()
 {
   return m_DataStorage;
 }
 
 
 void RenderingManager::SetGlobalInteraction( mitk::GlobalInteraction* globalInteraction )
 {
   if ( globalInteraction != NULL )
   {
     m_GlobalInteraction = globalInteraction;
   }
 }
 
 mitk::GlobalInteraction* RenderingManager::GetGlobalInteraction()
 {
   return m_GlobalInteraction;
 }
 
 // Create and register generic RenderingManagerFactory.
 TestingRenderingManagerFactory renderingManagerFactory;
 
 
 } // namespace
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractRenderEditor.h b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractRenderEditor.h
index 0651fe2f76..c9d78c2398 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractRenderEditor.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractRenderEditor.h
@@ -1,159 +1,157 @@
 /*===================================================================
 
 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 QMITKABSTRACTRENDEREDITOR_H
 #define QMITKABSTRACTRENDEREDITOR_H
 
 #include <berryQtEditorPart.h>
 #include <berryIBerryPreferences.h>
 
 #include "mitkIRenderWindowPart.h"
 
 #include <mitkIDataStorageReference.h>
 #include <mitkDataStorage.h>
 
 #include <org_mitk_gui_qt_common_Export.h>
 
 class QmitkAbstractRenderEditorPrivate;
 
 /**
  * \ingroup org_mitk_gui_qt_common
  *
  * \brief A convenient base class for MITK render window BlueBerry Editors.
  *
  * QmitkAbstractRenderEditor provides several convenience methods that ease the introduction of
  * a new editor for rendering a MITK DataStorage:
  *
  * <ol>
  *   <li> Access to the DataStorage (~ the shared data repository)
  *   <li> Access to and update notification for the editor's preferences
  *   <li> Default implementation of some mitk::IRenderWindowPart methods
  * </ol>
  *
  * When inheriting from QmitkAbstractRenderEditor, you must implement the following methods:
  * <ul>
  * <li>void CreateQtPartControl(QWidget* parent)
  * <li>void SetFocus()
  * </ul>
  *
  * You may reimplement the following private virtual methods to be notified about certain changes:
  * <ul>
  * <li>void OnPreferencesChanged(const berry::IBerryPreferences*)
  * </ul>
  *
  * \see IRenderWindowPart
  * \see ILinkedRenderWindowPart
  */
 class MITK_QT_COMMON QmitkAbstractRenderEditor : public berry::QtEditorPart,
     public virtual mitk::IRenderWindowPart
 {
   Q_OBJECT
   Q_INTERFACES(mitk::IRenderWindowPart)
 
 public:
 
   QmitkAbstractRenderEditor();
   ~QmitkAbstractRenderEditor();
 
 protected:
 
   /**
    * Initializes this editor by checking for a valid mitk::DataStorageEditorInput as <code>input</code>.
    *
    * \see berry::IEditorPart::Init
    */
   void Init(berry::IEditorSite::Pointer site, berry::IEditorInput::Pointer input);
 
   /**
    * Get a reference to the DataStorage set by the editor input.
    */
   virtual mitk::IDataStorageReference::Pointer GetDataStorageReference() const;
 
   /**
    * Get the DataStorage set by the editor input.
    */
   virtual mitk::DataStorage::Pointer GetDataStorage() const;
 
   /**
    * Get the preferences for this editor.
    */
   virtual berry::IPreferences::Pointer GetPreferences() const;
 
   /**
    * Get the RenderingManager used by this editor. This default implementation uses the
    * global MITK RenderingManager provided by mitk::RenderingManager::GetInstance().
    *
    * \see mitk::IRenderWindowPart::GetRenderingManager
    */
   mitk::IRenderingManager* GetRenderingManager() const;
 
   /**
    * Request an update of this editor's render windows.
    * This implementation calls mitk::IRenderingManager::RequestUpdate on the rendering
    * manager interface returned by GetRenderingManager();
    *
    * \param requestType The type of render windows for which an update is requested.
    *
    * \see mitk::IRenderWindowPart::RequestUpdate
    */
   void RequestUpdate(mitk::RenderingManager::RequestType requestType = mitk::RenderingManager::REQUEST_UPDATE_ALL);
 
   /**
    * Force an immediate update of this editor's render windows.
    * This implementation calls mitk::IRenderingManager::ForceImmediateUpdate() on the rendering
    * manager interface returned by GetRenderingManager();
    *
    * \param requestType The type of render windows for which an immedate update is forced.
    *
    * \see mitk::IRenderWindowPart::ForceImmediateUpdate
    */
   void ForceImmediateUpdate(mitk::RenderingManager::RequestType requestType = mitk::RenderingManager::REQUEST_UPDATE_ALL);
 
   /**
    * Get the time navigation controller for this editor.
    * This implementation returns the SliceNavigationController returned by the mitk::IRenderingManager::GetTimeNavigationController()
    * method of the interface implementation returned by GetRenderingManager().
    *
    * \see mitk::IRenderingManager::GetTimeNavigationController
    */
   mitk::SliceNavigationController* GetTimeNavigationController() const;
 
   /** \see berry::IEditorPart::DoSave */
   void DoSave();
 
   /** \see berry::IEditorPart::DoSaveAs */
   void DoSaveAs();
 
   /** \see berry::IEditorPart::IsDirty */
   bool IsDirty() const;
 
   /** \see berry::IEditorPart::IsSaveAsAllowed */
   bool IsSaveAsAllowed() const;
 
-public Q_SLOTS:
-
 private:
 
   virtual void OnPreferencesChanged(const berry::IBerryPreferences*);
 
 private:
 
   QScopedPointer<QmitkAbstractRenderEditorPrivate> d;
 
 };
 
 #endif // QMITKABSTRACTRENDEREDITOR_H
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
index f54ca0404e..17332a58d4 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
@@ -1,469 +1,472 @@
 /*===================================================================
 
 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 "QmitkStdMultiWidgetEditor.h"
 
 #include <berryUIException.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryIPartListener.h>
 
 #include <QWidget>
 
 #include <mitkColorProperty.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 #include <mitkDataStorageEditorInput.h>
 #include <mitkIDataStorageService.h>
 
 #include <QmitkMouseModeSwitcher.h>
 #include <QmitkStdMultiWidget.h>
 
 #include <mbilogo.h>
 
 class QmitkStdMultiWidgetEditorPrivate
 {
 public:
 
   QmitkStdMultiWidgetEditorPrivate();
   ~QmitkStdMultiWidgetEditorPrivate();
 
   QmitkStdMultiWidget* m_StdMultiWidget;
   QmitkMouseModeSwitcher* m_MouseModeToolbar;
   std::string m_FirstBackgroundColor;
   std::string m_SecondBackgroundColor;
   bool m_MenuWidgetsEnabled;
   berry::IPartListener::Pointer m_PartListener;
 
   QHash<QString, QmitkRenderWindow*> m_RenderWindows;
+
 };
 
 struct QmitkStdMultiWidgetPartListener : public berry::IPartListener
 {
   berryObjectMacro(QmitkStdMultiWidgetPartListener)
 
   QmitkStdMultiWidgetPartListener(QmitkStdMultiWidgetEditorPrivate* dd)
     : d(dd)
   {}
 
   Events::Types GetPartEventTypes() const
   {
     return Events::CLOSED | Events::HIDDEN | Events::VISIBLE;
   }
 
   void PartClosed (berry::IWorkbenchPartReference::Pointer partRef)
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         d->m_StdMultiWidget->RemovePlanesFromDataStorage();
         stdMultiWidgetEditor->RequestActivateMenuWidget(false);
       }
     }
   }
 
   void PartHidden (berry::IWorkbenchPartReference::Pointer partRef)
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         d->m_StdMultiWidget->RemovePlanesFromDataStorage();
         stdMultiWidgetEditor->RequestActivateMenuWidget(false);
       }
     }
   }
 
   void PartVisible (berry::IWorkbenchPartReference::Pointer partRef)
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         d->m_StdMultiWidget->AddPlanesToDataStorage();
         stdMultiWidgetEditor->RequestActivateMenuWidget(true);
       }
     }
   }
 
 private:
 
   QmitkStdMultiWidgetEditorPrivate* const d;
 
 };
 
 QmitkStdMultiWidgetEditorPrivate::QmitkStdMultiWidgetEditorPrivate()
   : m_StdMultiWidget(0), m_MouseModeToolbar(0)
   , m_MenuWidgetsEnabled(false)
   , m_PartListener(new QmitkStdMultiWidgetPartListener(this))
 {}
 
 QmitkStdMultiWidgetEditorPrivate::~QmitkStdMultiWidgetEditorPrivate()
 {
 }
 
 const std::string QmitkStdMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.stdmultiwidget";
 
 QmitkStdMultiWidgetEditor::QmitkStdMultiWidgetEditor()
   : d(new QmitkStdMultiWidgetEditorPrivate)
 {
 }
 
 QmitkStdMultiWidgetEditor::~QmitkStdMultiWidgetEditor()
 {
   this->GetSite()->GetPage()->RemovePartListener(d->m_PartListener);
 }
 
 QmitkStdMultiWidget* QmitkStdMultiWidgetEditor::GetStdMultiWidget()
 {
   return d->m_StdMultiWidget;
 }
 
 QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetActiveQmitkRenderWindow() const
 {
   if (d->m_StdMultiWidget) return d->m_StdMultiWidget->GetRenderWindow1();
   return 0;
 }
 
 QHash<QString, QmitkRenderWindow *> QmitkStdMultiWidgetEditor::GetQmitkRenderWindows() const
 {
   return d->m_RenderWindows;
 }
 
 QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetQmitkRenderWindow(const QString &id) const
 {
   static bool alreadyWarned = false;
 
   if(!alreadyWarned)
   {
     MITK_WARN(id == "transversal") << "QmitkStdMultiWidgetEditor::GetRenderWindow(\"transversal\") is deprecated. Use \"axial\" instead.";
     alreadyWarned = true;
   }
 
   if (d->m_RenderWindows.contains(id))
     return d->m_RenderWindows[id];
 
   return 0;
 }
 
 mitk::Point3D QmitkStdMultiWidgetEditor::GetSelectedPosition(const QString & /*id*/) const
 {
   return d->m_StdMultiWidget->GetCrossPosition();
 }
 
 void QmitkStdMultiWidgetEditor::SetSelectedPosition(const mitk::Point3D &pos, const QString &/*id*/)
 {
   d->m_StdMultiWidget->MoveCrossToPosition(pos);
 }
 
 void QmitkStdMultiWidgetEditor::EnableDecorations(bool enable, const QStringList &decorations)
 {
   if (decorations.isEmpty() || decorations.contains(DECORATION_BORDER))
   {
     enable ? d->m_StdMultiWidget->EnableColoredRectangles()
            : d->m_StdMultiWidget->DisableColoredRectangles();
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_LOGO))
   {
     enable ? d->m_StdMultiWidget->EnableDepartmentLogo()
            : d->m_StdMultiWidget->DisableDepartmentLogo();
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_MENU))
   {
     d->m_StdMultiWidget->ActivateMenuWidget(enable);
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_BACKGROUND))
   {
     enable ? d->m_StdMultiWidget->EnableGradientBackground()
            : d->m_StdMultiWidget->DisableGradientBackground();
   }
 }
 
 bool QmitkStdMultiWidgetEditor::IsDecorationEnabled(const QString &decoration) const
 {
   if (decoration == DECORATION_BORDER)
   {
     return d->m_StdMultiWidget->IsColoredRectanglesEnabled();
   }
   else if (decoration == DECORATION_LOGO)
   {
     return d->m_StdMultiWidget->IsColoredRectanglesEnabled();
   }
   else if (decoration == DECORATION_MENU)
   {
     return d->m_StdMultiWidget->IsMenuWidgetEnabled();
   }
   else if (decoration == DECORATION_BACKGROUND)
   {
     return d->m_StdMultiWidget->GetGradientBackgroundFlag();
   }
   return false;
 }
 
 QStringList QmitkStdMultiWidgetEditor::GetDecorations() const
 {
   QStringList decorations;
   decorations << DECORATION_BORDER << DECORATION_LOGO << DECORATION_MENU << DECORATION_BACKGROUND;
   return decorations;
 }
 
 mitk::SlicesRotator* QmitkStdMultiWidgetEditor::GetSlicesRotator() const
 {
   return d->m_StdMultiWidget->GetSlicesRotator();
 }
 
 mitk::SlicesSwiveller* QmitkStdMultiWidgetEditor::GetSlicesSwiveller() const
 {
   return d->m_StdMultiWidget->GetSlicesSwiveller();
 }
 
 void QmitkStdMultiWidgetEditor::EnableSlicingPlanes(bool enable)
 {
   d->m_StdMultiWidget->SetWidgetPlanesVisibility(enable);
 }
 
 bool QmitkStdMultiWidgetEditor::IsSlicingPlanesEnabled() const
 {
   mitk::DataNode::Pointer node = this->d->m_StdMultiWidget->GetWidgetPlane1();
   if (node.IsNotNull())
   {
     bool visible = false;
     node->GetVisibility(visible, 0);
     return visible;
   }
   else
   {
     return false;
   }
 }
 
 void QmitkStdMultiWidgetEditor::EnableLinkedNavigation(bool enable)
 {
   enable ? d->m_StdMultiWidget->EnableNavigationControllerEventListening()
          : d->m_StdMultiWidget->DisableNavigationControllerEventListening();
 }
 
 bool QmitkStdMultiWidgetEditor::IsLinkedNavigationEnabled() const
 {
   return d->m_StdMultiWidget->IsCrosshairNavigationEnabled();
 }
 
 void QmitkStdMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
 {
   if (d->m_StdMultiWidget == 0)
   {
     QHBoxLayout* layout = new QHBoxLayout(parent);
     layout->setContentsMargins(0,0,0,0);
 
     if (d->m_MouseModeToolbar == NULL)
     {
       d->m_MouseModeToolbar = new QmitkMouseModeSwitcher(parent); // delete by Qt via parent
       layout->addWidget(d->m_MouseModeToolbar);
     }
 
     d->m_StdMultiWidget = new QmitkStdMultiWidget(parent);
 
+    d->m_RenderWindows.insert("transversal", d->m_StdMultiWidget->GetRenderWindow1());
     d->m_RenderWindows.insert("axial", d->m_StdMultiWidget->GetRenderWindow1());
     d->m_RenderWindows.insert("sagittal", d->m_StdMultiWidget->GetRenderWindow2());
     d->m_RenderWindows.insert("coronal", d->m_StdMultiWidget->GetRenderWindow3());
     d->m_RenderWindows.insert("3d", d->m_StdMultiWidget->GetRenderWindow4());
 
     d->m_MouseModeToolbar->setMouseModeSwitcher( d->m_StdMultiWidget->GetMouseModeSwitcher() );
     connect( d->m_MouseModeToolbar, SIGNAL( MouseModeSelected(mitk::MouseModeSwitcher::MouseMode) ),
       d->m_StdMultiWidget, SLOT( MouseModeSelected(mitk::MouseModeSwitcher::MouseMode) ) );
 
     layout->addWidget(d->m_StdMultiWidget);
 
     mitk::DataStorage::Pointer ds = this->GetDataStorage();
 
     // Tell the multiWidget which (part of) the tree to render
     d->m_StdMultiWidget->SetDataStorage(ds);
 
     // Initialize views as axial, sagittal, coronar to all data objects in DataStorage
     // (from top-left to bottom)
     mitk::TimeSlicedGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
     mitk::RenderingManager::GetInstance()->InitializeViews(geo);
 
     // Initialize bottom-right view as 3D view
     d->m_StdMultiWidget->GetRenderWindow4()->GetRenderer()->SetMapperID(
       mitk::BaseRenderer::Standard3D );
 
     // Enable standard handler for levelwindow-slider
     d->m_StdMultiWidget->EnableStandardLevelWindow();
 
     // Add the displayed views to the tree to see their positions
     // in 2D and 3D
     d->m_StdMultiWidget->AddDisplayPlaneSubTree();
 
     d->m_StdMultiWidget->EnableNavigationControllerEventListening();
 
     // Store the initial visibility status of the menu widget.
     d->m_MenuWidgetsEnabled = d->m_StdMultiWidget->IsMenuWidgetEnabled();
 
     this->GetSite()->GetPage()->AddPartListener(d->m_PartListener);
 
     berry::IPreferences::Pointer prefs = this->GetPreferences();
     this->OnPreferencesChanged(dynamic_cast<berry::IBerryPreferences*>(prefs.GetPointer()));
 
     this->RequestUpdate();
   }
 }
 
 void QmitkStdMultiWidgetEditor::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   // Enable change of logo. If no DepartmentLogo was set explicitly, MBILogo is used.
   // Set new department logo by prefs->Set("DepartmentLogo", "PathToImage");
 
   // If no logo was set for this plug-in specifically, walk the parent preference nodes
   // and lookup a logo value there.
 
   const berry::IPreferences* currentNode = prefs;
 
   while(currentNode)
   {
     std::vector<std::string> keys = currentNode->Keys();
 
     bool logoFound = false;
     for( std::size_t i = 0; i < keys.size(); ++i )
     {
       if( keys[i] == "DepartmentLogo")
       {
         std::string departmentLogoLocation = currentNode->Get("DepartmentLogo", "");
 
         if (departmentLogoLocation.empty())
         {
           d->m_StdMultiWidget->DisableDepartmentLogo();
         }
         else
         {
           // we need to disable the logo first, otherwise setting a new logo will have
           // no effect due to how mitkManufacturerLogo works...
           d->m_StdMultiWidget->DisableDepartmentLogo();
           d->m_StdMultiWidget->SetDepartmentLogoPath(departmentLogoLocation.c_str());
           d->m_StdMultiWidget->EnableDepartmentLogo();
         }
         logoFound = true;
         break;
       }
     }
 
     if (logoFound) break;
     currentNode = currentNode->Parent().GetPointer();
   }
 
   // preferences for gradient background
   float color = 255.0;
   QString firstColorName = QString::fromStdString (prefs->GetByteArray("first background color", ""));
   QColor firstColor(firstColorName);
   mitk::Color upper;
   if (firstColorName=="") // default values
   {
     upper[0] = 0.1;
     upper[1] = 0.1;
     upper[2] = 0.1;
   }
   else
   {
     upper[0] = firstColor.red() / color;
     upper[1] = firstColor.green() / color;
     upper[2] = firstColor.blue() / color;
   }
 
   QString secondColorName = QString::fromStdString (prefs->GetByteArray("second background color", ""));
   QColor secondColor(secondColorName);
   mitk::Color lower;
   if (secondColorName=="") // default values
   {
     lower[0] = 0.5;
     lower[1] = 0.5;
     lower[2] = 0.5;
   }
   else
   {
     lower[0] = secondColor.red() / color;
     lower[1] = secondColor.green() / color;
     lower[2] = secondColor.blue() / color;
   }
   d->m_StdMultiWidget->SetGradientBackgroundColors(upper, lower);
   d->m_StdMultiWidget->EnableGradientBackground();
 
   // Set preferences respecting zooming and padding
   bool constrainedZooming = prefs->GetBool("Use constrained zooming and padding", false);
 
   mitk::RenderingManager::GetInstance()->SetConstrainedPaddingZooming(constrainedZooming);
 
   mitk::NodePredicateNot::Pointer pred
     = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
     , mitk::BoolProperty::New(false)));
 
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
   // calculate bounding geometry of these nodes
 
   mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
 
   // initialize the views to the bounding geometry
   mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   // level window setting
   bool showLevelWindowWidget = prefs->GetBool("Show level/window widget", true);
   if (showLevelWindowWidget)
   {
     d->m_StdMultiWidget->EnableStandardLevelWindow();
   }
   else
   {
     d->m_StdMultiWidget->DisableStandardLevelWindow();
   }
 
   // mouse modes toolbar
   bool newMode = prefs->GetBool("PACS like mouse interaction", false);
   d->m_MouseModeToolbar->setVisible( newMode );
   d->m_StdMultiWidget->GetMouseModeSwitcher()->SetInteractionScheme( newMode ? mitk::MouseModeSwitcher::PACS : mitk::MouseModeSwitcher::MITK );
 }
 
 void QmitkStdMultiWidgetEditor::SetFocus()
 {
   if (d->m_StdMultiWidget != 0)
     d->m_StdMultiWidget->setFocus();
 }
 
 void QmitkStdMultiWidgetEditor::RequestActivateMenuWidget(bool on)
 {
   if (d->m_StdMultiWidget)
   {
     if (on)
     {
       d->m_StdMultiWidget->ActivateMenuWidget(d->m_MenuWidgetsEnabled);
     }
     else
     {
       d->m_MenuWidgetsEnabled = d->m_StdMultiWidget->IsMenuWidgetEnabled();
       d->m_StdMultiWidget->ActivateMenuWidget(false);
     }
   }
 }
+
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.h b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.h
index 1d55a339cf..f242c612a6 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.h
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.h
@@ -1,126 +1,120 @@
 /*===================================================================
 
 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 QMITKSTDMULTIWIDGETEDITOR_H_
 #define QMITKSTDMULTIWIDGETEDITOR_H_
 
 #include <QmitkAbstractRenderEditor.h>
 
 #include <mitkILinkedRenderWindowPart.h>
 
 #include <org_mitk_gui_qt_stdmultiwidgeteditor_Export.h>
 
 class QmitkStdMultiWidget;
 class QmitkMouseModeSwitcher;
 class QmitkStdMultiWidgetEditorPrivate;
 
 /**
  * \ingroup org_mitk_gui_qt_stdmultiwidgeteditor
  */
 class ORG_MITK_GUI_QT_STDMULTIWIDGETEDITOR QmitkStdMultiWidgetEditor
     : public QmitkAbstractRenderEditor, public mitk::ILinkedRenderWindowPart
 {
   Q_OBJECT
 
 public:
 
   berryObjectMacro(QmitkStdMultiWidgetEditor)
 
   static const std::string EDITOR_ID;
 
   QmitkStdMultiWidgetEditor();
   ~QmitkStdMultiWidgetEditor();
 
   QmitkStdMultiWidget* GetStdMultiWidget();
 
-  /**
-   * Request the QmitkRenderWindowMenus to be either off, or whatever was the last known state, which is
-   * useful when responding to the PartOpened, PartClosed, PartHidden methods.
-   *
-   * \param on If <code>true</code> will request the QmitkStdMultiWidget to set the QmitkRenderWindowMenu to
-   *           whatever was the last known state, and if <code>false</code> will turn the QmitkRenderWindowMenu off.
-   *
-   */
+  /// \brief If on=true will request the QmitkStdMultiWidget set the Menu widget to
+  /// whatever was the last known enabled state, and if on=false will turn the Menu widget off.
   void RequestActivateMenuWidget(bool on);
 
   // -------------------  mitk::IRenderWindowPart  ----------------------
 
   /**
    * \see mitk::IRenderWindowPart::GetActiveQmitkRenderWindow()
    */
   QmitkRenderWindow* GetActiveQmitkRenderWindow() const;
 
   /**
    * \see mitk::IRenderWindowPart::GetQmitkRenderWindows()
    */
   QHash<QString,QmitkRenderWindow*> GetQmitkRenderWindows() const;
 
   /**
    * \see mitk::IRenderWindowPart::GetQmitkRenderWindow(QString)
    */
   QmitkRenderWindow* GetQmitkRenderWindow(const QString& id) const;
 
   /**
    * \see mitk::IRenderWindowPart::GetSelectionPosition()
    */
   mitk::Point3D GetSelectedPosition(const QString& id = QString()) const;
 
   /**
    * \see mitk::IRenderWindowPart::SetSelectedPosition()
    */
   void SetSelectedPosition(const mitk::Point3D& pos, const QString& id = QString());
 
   /**
    * \see mitk::IRenderWindowPart::EnableDecorations()
    */
   void EnableDecorations(bool enable, const QStringList& decorations = QStringList());
 
   /**
    * \see mitk::IRenderWindowPart::IsDecorationEnabled()
    */
   bool IsDecorationEnabled(const QString& decoration) const;
 
   /**
    * \see mitk::IRenderWindowPart::GetDecorations()
    */
   QStringList GetDecorations() const;
 
   // -------------------  mitk::ILinkedRenderWindowPart  ----------------------
 
   mitk::SlicesRotator* GetSlicesRotator() const;
   mitk::SlicesSwiveller* GetSlicesSwiveller() const;
 
   void EnableSlicingPlanes(bool enable);
   bool IsSlicingPlanesEnabled() const;
 
   void EnableLinkedNavigation(bool enable);
   bool IsLinkedNavigationEnabled() const;
 
 protected:
 
   void SetFocus();
 
   void OnPreferencesChanged(const berry::IBerryPreferences*);
 
   void CreateQtPartControl(QWidget* parent);
 
 private:
 
   const QScopedPointer<QmitkStdMultiWidgetEditorPrivate> d;
 
 };
 
 #endif /*QMITKSTDMULTIWIDGETEDITOR_H_*/