diff --git a/Modules/Core/include/mitkSliceNavigationController.h b/Modules/Core/include/mitkSliceNavigationController.h
index abf67f6dba..aedc5b0814 100644
--- a/Modules/Core/include/mitkSliceNavigationController.h
+++ b/Modules/Core/include/mitkSliceNavigationController.h
@@ -1,439 +1,438 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKSLICENAVIGATIONCONTROLLER_H
 #define MITKSLICENAVIGATIONCONTROLLER_H
 
 #include <MitkCoreExports.h>
 
 #include <mitkBaseController.h>
 #include <mitkMessage.h>
 #include <mitkRenderingManager.h>
 #include <mitkRestorePlanePositionOperation.h>
 #include <mitkTimeGeometry.h>
 
 #pragma GCC visibility push(default)
 #include <itkEventObject.h>
 #pragma GCC visibility pop
 
 #include <itkCommand.h>
 
 namespace mitk
 {
 #define mitkTimeGeometryEventMacro(classname, super)                                                                   \
   class MITKCORE_EXPORT classname : public super                                                                       \
   {                                                                                                                    \
   public:                                                                                                              \
     typedef classname Self;                                                                                            \
     typedef super Superclass;                                                                                          \
     classname(TimeGeometry *aTimeGeometry, unsigned int aPos) : Superclass(aTimeGeometry, aPos) {}                     \
     virtual ~classname() {}                                                                                            \
     virtual const char *GetEventName() const { return #classname; }                                                    \
     virtual bool CheckEvent(const ::itk::EventObject *e) const { return dynamic_cast<const Self *>(e); }               \
     virtual ::itk::EventObject *MakeObject() const { return new Self(GetTimeGeometry(), GetPos()); }                   \
   private:                                                                                                             \
     void operator=(const Self &);                                                                                      \
   }
 
   class PlaneGeometry;
   class BaseGeometry;
   class BaseRenderer;
 
   /**
    * \brief Controls the selection of the slice the associated BaseRenderer
    * will display
    *
    * A SliceNavigationController takes a BaseGeometry or a TimeGeometry as input world geometry
    * (TODO what are the exact requirements?) and generates a TimeGeometry
    * as output. The TimeGeometry holds a number of SlicedGeometry3Ds and
    * these in turn hold a series of PlaneGeometries. One of these PlaneGeometries is
    * selected as world geometry for the BaseRenderers associated to 2D views.
    *
    * The SliceNavigationController holds has Steppers (one for the slice, a
    * second for the time step), which control the selection of a single
    * PlaneGeometry from the TimeGeometry. SliceNavigationController generates
    * ITK events to tell observers, like a BaseRenderer, when the selected slice
    * or timestep changes.
    *
    * Example:
    * \code
    * // Initialization
    * sliceCtrl = mitk::SliceNavigationController::New();
    *
-   * // Tell the navigator the geometry to be sliced (with geometry a
-   * // BaseGeometry::ConstPointer)
+   * // Tell the navigation controller the geometry to be sliced
+   * // (with geometry a BaseGeometry::ConstPointer)
    * sliceCtrl->SetInputWorldTimeGeometry(geometry.GetPointer());
    *
-   * // Tell the navigator in which direction it shall slice the data
+   * // Tell the navigation controller in which direction it shall slice the data
    * sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Axial);
    *
-   * // Connect one or more BaseRenderer to this navigator, i.e.: events sent
-   * // by the navigator when stepping through the slices (e.g. by
-   * // sliceCtrl->GetSlice()->Next()) will be received by the BaseRenderer
+   * // Connect one or more BaseRenderer to this navigation controller, i.e.:
+   * // events sent by the navigation controller when stepping through the slices
+   * // (e.g. by sliceCtrl->GetSlice()->Next()) will be received by the BaseRenderer
    * // (in this example only slice-changes, see also ConnectGeometryTimeEvent
    * // and ConnectGeometryEvents.)
    * sliceCtrl->ConnectGeometrySliceEvent(renderer.GetPointer());
    *
    * //create a world geometry and send the information to the connected renderer(s)
    * sliceCtrl->Update();
    * \endcode
    *
    *
-   * You can connect visible navigators to a SliceNavigationController, e.g., a
-   * QmitkSliderNavigator (for Qt):
+   * You can connect visible navigation widgets to a SliceNavigationController, e.g., a
+   * QmitkSliceNavigationWidget (for Qt):
    *
    * \code
-   * // Create the visible navigator (a slider with a spin-box)
-   * QmitkSliderNavigator* navigator =
-   *   new QmitkSliderNavigator(parent, "slidernavigator");
+   * // Create the visible navigation widget (a slider with a spin-box)
+   * QmitkSliceNavigationWidget* navigationWidget =
+   *   new QmitkSliceNavigationWidget(parent);
    *
-   * // Connect the navigator to the slice-stepper of the
-   * // SliceNavigationController. For initialization (position, minimal and
+   * // Connect the navigation widget to the slice-stepper of the
+   * // SliceNavigationController. For initialization (position, mininal and
    * // maximal values) the values of the SliceNavigationController are used.
-   * // Thus, accessing methods of a navigator is normally not necessary, since
-   * // everything can be set via the (Qt-independent) SliceNavigationController.
+   * // Thus, accessing methods of a navigation widget is normally not necessary,
+   * // since everything can be set via the (Qt-independent) SliceNavigationController.
    * // The QmitkStepperAdapter converts the Qt-signals to Qt-independent
    * // itk-events.
-   * new QmitkStepperAdapter(navigator, sliceCtrl->GetSlice(), "navigatoradaptor");
+   * new QmitkStepperAdapter(navigationWidget, sliceCtrl->GetSlice(), "navigatoradaptor");
    * \endcode
    *
    * If you do not want that all renderwindows are updated when a new slice is
    * selected, you can use a specific RenderingManager, which updates only those
    * renderwindows that should be updated. This is sometimes useful when a 3D view
    * does not need to be updated when the slices in some 2D views are changed.
-   * QmitkSliderNavigator (for Qt):
    *
    * \code
    * // create a specific RenderingManager
    * mitk::RenderingManager::Pointer myManager = mitk::RenderingManager::New();
    *
    * // tell the RenderingManager to update only renderwindow1 and renderwindow2
    * myManager->AddRenderWindow(renderwindow1);
    * myManager->AddRenderWindow(renderwindow2);
    *
    * // tell the SliceNavigationController of renderwindow1 and renderwindow2
    * // to use the specific RenderingManager instead of the global one
    * renderwindow1->GetSliceNavigationController()->SetRenderingManager(myManager);
    * renderwindow2->GetSliceNavigationController()->SetRenderingManager(myManager);
    * \endcode
    *
    * \todo implement for non-evenly-timed geometry!
    * \ingroup NavigationControl
    */
   class MITKCORE_EXPORT SliceNavigationController : public BaseController
   {
   public:
 
     mitkClassMacro(SliceNavigationController, BaseController);
     itkNewMacro(Self);
 
     /**
      * \brief Possible view directions, \a Original will use
      * the PlaneGeometry instances in a SlicedGeometry3D provided
      * as input world geometry (by SetInputWorldTimeGeometry).
      */
     enum ViewDirection
     {
       Axial,
       Sagittal,
       Coronal,
       Original
     };
 
     /**
      * \brief Set the input world time geometry out of which the
      * geometries for slicing will be created.
      *
      * Any previous previous set input geometry (3D or Time) will
      * be ignored in future.
      */
     void SetInputWorldTimeGeometry(const TimeGeometry* geometry);
     itkGetConstObjectMacro(InputWorldTimeGeometry, TimeGeometry);
 
     /**
      * \brief Access the created geometry
      */
     itkGetConstObjectMacro(CreatedWorldGeometry, TimeGeometry);
     itkGetObjectMacro(CreatedWorldGeometry, TimeGeometry);
 
     /**
      * \brief Set the desired view directions
      *
      * \sa ViewDirection
      * \sa Update(ViewDirection viewDirection, bool top = true,
      *     bool frontside = true, bool rotated = false)
      */
     itkSetEnumMacro(ViewDirection, ViewDirection);
     itkGetEnumMacro(ViewDirection, ViewDirection);
 
     /**
      * \brief Set the default view direction
      *
      * This is used to re-initialize the view direction of the SNC to the
      * default value with SetViewDirectionToDefault()
      *
      * \sa ViewDirection
      * \sa Update(ViewDirection viewDirection, bool top = true,
      *     bool frontside = true, bool rotated = false)
      */
     itkSetEnumMacro(DefaultViewDirection, ViewDirection);
     itkGetEnumMacro(DefaultViewDirection, ViewDirection);
 
     const char *GetViewDirectionAsString() const;
 
     virtual void SetViewDirectionToDefault();
 
     /**
      * \brief Do the actual creation and send it to the connected
      * observers (renderers)
      *
      */
     virtual void Update();
 
     /**
      * \brief Extended version of Update, additionally allowing to
      * specify the direction/orientation of the created geometry.
      *
      */
     virtual void Update(ViewDirection viewDirection, bool top = true, bool frontside = true, bool rotated = false);
 
     /**
      * \brief Send the created geometry to the connected
      * observers (renderers)
      *
      * Called by Update().
      */
     virtual void SendCreatedWorldGeometry();
 
     /**
      * \brief Tell observers to re-read the currently selected 2D geometry
      *
      */
     virtual void SendCreatedWorldGeometryUpdate();
 
     /**
      * \brief Send the currently selected slice to the connected
      * observers (renderers)
      *
      * Called by Update().
      */
     virtual void SendSlice();
 
     /**
      * \brief Send the currently selected time to the connected
      * observers (renderers)
      *
      * Called by Update().
      */
     virtual void SendTime();
 
     class MITKCORE_EXPORT TimeGeometryEvent : public itk::AnyEvent
     {
     public:
       typedef TimeGeometryEvent Self;
       typedef itk::AnyEvent Superclass;
 
       TimeGeometryEvent(TimeGeometry* aTimeGeometry, unsigned int aPos) : m_TimeGeometry(aTimeGeometry), m_Pos(aPos) {}
       ~TimeGeometryEvent() override {}
       const char* GetEventName() const override { return "TimeGeometryEvent"; }
       bool CheckEvent(const ::itk::EventObject* e) const override { return dynamic_cast<const Self*>(e); }
       ::itk::EventObject* MakeObject() const override { return new Self(m_TimeGeometry, m_Pos); }
       TimeGeometry* GetTimeGeometry() const { return m_TimeGeometry; }
       unsigned int GetPos() const { return m_Pos; }
 
     private:
       TimeGeometry::Pointer m_TimeGeometry;
       unsigned int m_Pos;
       // TimeGeometryEvent(const Self&);
       void operator=(const Self&); // just hide
     };
 
 
     mitkTimeGeometryEventMacro(GeometrySendEvent, TimeGeometryEvent);
     mitkTimeGeometryEventMacro(GeometryUpdateEvent, TimeGeometryEvent);
     mitkTimeGeometryEventMacro(GeometryTimeEvent, TimeGeometryEvent);
     mitkTimeGeometryEventMacro(GeometrySliceEvent, TimeGeometryEvent);
 
     template <typename T>
     void ConnectGeometrySendEvent(T* receiver)
     {
       auto eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
       eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometry);
       unsigned long tag = AddObserver(GeometrySendEvent(nullptr, 0), eventReceptorCommand);
       m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
     }
 
     template <typename T>
     void ConnectGeometryUpdateEvent(T* receiver)
     {
       auto eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
       eventReceptorCommand->SetCallbackFunction(receiver, &T::UpdateGeometry);
       unsigned long tag = AddObserver(GeometryUpdateEvent(nullptr, 0), eventReceptorCommand);
       m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
     }
 
     template <typename T>
     void ConnectGeometrySliceEvent(T* receiver)
     {
       auto eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
       eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometrySlice);
       unsigned long tag = AddObserver(GeometrySliceEvent(nullptr, 0), eventReceptorCommand);
       m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
     }
 
     template <typename T>
     void ConnectGeometryTimeEvent(T* receiver)
     {
       auto eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
       eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometryTime);
       unsigned long tag = AddObserver(GeometryTimeEvent(nullptr, 0), eventReceptorCommand);
       m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
     }
 
     template <typename T>
     void ConnectGeometryEvents(T* receiver)
     {
       // connect sendEvent only once
       ConnectGeometrySliceEvent(receiver, false);
       ConnectGeometryTimeEvent(receiver);
     }
 
     // use a templated method to get the right offset when casting to void*
     template <typename T>
     void Disconnect(T* receiver)
     {
       auto i = m_ReceiverToObserverTagsMap.find(static_cast<void*>(receiver));
       if (i == m_ReceiverToObserverTagsMap.end())
         return;
       const std::list<unsigned long>& tags = i->second;
       for (auto tagIter = tags.begin(); tagIter != tags.end(); ++tagIter)
       {
         RemoveObserver(*tagIter);
       }
       m_ReceiverToObserverTagsMap.erase(i);
     }
 
     Message1<const Point3D&> SetCrosshairEvent;
 
     /**
      * \brief To connect multiple SliceNavigationController, we can
      * act as an observer ourselves: implemented interface
      * \warning not implemented
      */
     virtual void SetGeometry(const itk::EventObject& geometrySliceEvent);
 
     /**
      * \brief To connect multiple SliceNavigationController, we can
      * act as an observer ourselves: implemented interface
      */
     virtual void SetGeometrySlice(const itk::EventObject& geometrySliceEvent);
 
     /**
      * \brief To connect multiple SliceNavigationController, we can
      * act as an observer ourselves: implemented interface
      */
     virtual void SetGeometryTime(const itk::EventObject& geometryTimeEvent);
 
     /** \brief Positions the SNC according to the specified point */
     void SelectSliceByPoint(const Point3D& point);
 
     /** \brief Returns the BaseGeometry of the currently selected time step. */
     const BaseGeometry* GetCurrentGeometry3D();
 
     /** \brief Returns the currently selected Plane in the current
      * BaseGeometry (if existent).
      */
     const PlaneGeometry* GetCurrentPlaneGeometry();
 
     /** \brief Sets / gets the BaseRenderer associated with this SNC (if any).
      * While the BaseRenderer is not directly used by SNC, this is a convenience
      * method to enable BaseRenderer access via the SNC.
      */
     itkSetObjectMacro(Renderer, BaseRenderer);
     itkGetMacro(Renderer, BaseRenderer*);
 
     /** \brief Re-orients the slice stack. All slices will be oriented to the given normal vector.
          The given point (world coordinates) defines the selected slice.
          Careful: The resulting axis vectors are not clearly defined this way. If you want to define them clearly, use
          ReorientSlices (const Point3D &point, const Vector3D &axisVec0, const Vector3D &axisVec1).
      */
     void ReorientSlices(const Point3D& point, const Vector3D& normal);
 
     /** \brief Re-orients the slice stack so that all planes are oriented according to the
      * given axis vectors. The given Point eventually defines selected slice.
      */
     void ReorientSlices(const Point3D& point, const Vector3D& axisVec0, const Vector3D& axisVec1);
 
     void ExecuteOperation(Operation* operation) override;
 
     /**
      * \brief Feature option to lock planes during mouse interaction.
      * This option flag disables the mouse event which causes the center
      * cross to move near by.
      */
     itkSetMacro(SliceLocked, bool);
     itkGetMacro(SliceLocked, bool);
     itkBooleanMacro(SliceLocked);
 
     /**
      * \brief Feature option to lock slice rotation.
      *
      * This option flag disables separately the rotation of a slice which is
      * implemented in mitkSliceRotator.
      */
     itkSetMacro(SliceRotationLocked, bool);
     itkGetMacro(SliceRotationLocked, bool);
     itkBooleanMacro(SliceRotationLocked);
 
     /**
      * \brief Adjusts the numerical range of the slice stepper according to
      * the current geometry orientation of this SNC's SlicedGeometry.
      */
     void AdjustSliceStepperRange();
 
     /** \brief Convenience method that returns the time step currently selected by the controller.*/
     TimeStepType GetSelectedTimeStep() const;
 
     /** \brief Convenience method that returns the time point that corresponds to the selected
      * time step. The conversion is done using the time geometry of the SliceNavigationController.
      * If the time geometry is not yet set, this function will always return 0.0.*/
     TimePointType GetSelectedTimePoint() const;
 
   protected:
 
     SliceNavigationController();
     ~SliceNavigationController() override;
 
     void CreateWorldGeometry(bool top, bool frontside, bool rotated);
 
     TimeGeometry::ConstPointer m_InputWorldTimeGeometry;
     TimeGeometry::Pointer m_CreatedWorldGeometry;
 
     ViewDirection m_ViewDirection;
     ViewDirection m_DefaultViewDirection;
 
     RenderingManager::Pointer m_RenderingManager;
 
     BaseRenderer* m_Renderer;
 
     bool m_BlockUpdate;
 
     bool m_SliceLocked;
     bool m_SliceRotationLocked;
 
     typedef std::map<void*, std::list<unsigned long>> ObserverTagsMapType;
     ObserverTagsMapType m_ReceiverToObserverTagsMap;
   };
 
 } // namespace mitk
 
 #endif // MITKSLICENAVIGATIONCONTROLLER_H
diff --git a/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h b/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h
index 56502e704d..e78d4acaeb 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h
@@ -1,70 +1,70 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKRENDERWINDOWUTILITYWIDGET_H
 #define QMITKRENDERWINDOWUTILITYWIDGET_H
 
 // qt widgets module
 #include "MitkQtWidgetsExports.h"
-#include "QmitkSliderNavigatorWidget.h"
+#include "QmitkSliceNavigationWidget.h"
 #include "QmitkStepperAdapter.h"
 #include "QmitkRenderWindow.h"
 #include "QmitkRenderWindowContextDataStorageInspector.h"
 #include "mitkRenderWindowViewDirectionController.h"
 
 // mitk core
 #include "mitkDataStorage.h"
 
 // qt
 #include <QWidget>
 #include <QHBoxLayout>
 #include <QMenuBar>
 #include <QComboBox>
 
 class MITKQTWIDGETS_EXPORT QmitkRenderWindowUtilityWidget : public QWidget
 {
 	Q_OBJECT
 
 public:
   QmitkRenderWindowUtilityWidget(
     QWidget* parent = nullptr,
     QmitkRenderWindow* renderWindow = nullptr,
     mitk::DataStorage* dataStorage = nullptr
   );
 
   ~QmitkRenderWindowUtilityWidget() override;
 
   void SetInvertedSliceNavigation(bool inverted);
 
 Q_SIGNALS:
 
   void ReinitAction(QList<mitk::DataNode::Pointer> selectedNodes);
   void ResetAction(QList<mitk::DataNode::Pointer> selectedNodes);
 
 private:
 
   QHBoxLayout* m_Layout;
   QMenuBar* m_MenuBar;
 
   QmitkRenderWindow* m_RenderWindow;
   mitk::DataStorage* m_DataStorage;
 
   QmitkRenderWindowContextDataStorageInspector* m_RenderWindowInspector;
-  QmitkSliderNavigatorWidget* m_SliceNavigator;
+  QmitkSliceNavigationWidget* m_SliceNavigationWidget;
   QmitkStepperAdapter* m_StepperAdapter;
   std::unique_ptr<mitk::RenderWindowViewDirectionController> m_RenderWindowViewDirectionController;
   QComboBox* m_ViewDirectionSelector;
 
   void ChangeViewDirection(const QString& viewDirection);
 };
 
 #endif // QMITKRENDERWINDOWUTILITYWIDGET_H
diff --git a/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp
index 0e035960a8..391e9d2a57 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp
@@ -1,95 +1,95 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkRenderWindowUtilityWidget.h"
 
 #include <QWidgetAction>
 
 QmitkRenderWindowUtilityWidget::QmitkRenderWindowUtilityWidget(
   QWidget* parent/* = nullptr */,
   QmitkRenderWindow* renderWindow/* = nullptr */,
   mitk::DataStorage* dataStorage/* = nullptr */)
   : m_Layout(nullptr)
   , m_MenuBar(nullptr)
   , m_RenderWindow(renderWindow)
   , m_DataStorage(dataStorage)
   , m_RenderWindowInspector(nullptr)
-  , m_SliceNavigator(nullptr)
+  , m_SliceNavigationWidget(nullptr)
   , m_StepperAdapter(nullptr)
   , m_ViewDirectionSelector(nullptr)
 {
   m_Layout = new QHBoxLayout(this);
   m_Layout->setMargin(0);
 
   auto* baseRenderer = mitk::BaseRenderer::GetInstance(m_RenderWindow->GetVtkRenderWindow());
   auto* sliceNavigationController = m_RenderWindow->GetSliceNavigationController();
   m_RenderWindowInspector = new QmitkRenderWindowContextDataStorageInspector(parent, baseRenderer);
   m_RenderWindowInspector->SetDataStorage(m_DataStorage);
   m_RenderWindowInspector->setObjectName(QStringLiteral("m_RenderWindowManipulatorWidget"));
   connect(m_RenderWindowInspector, &QmitkRenderWindowContextDataStorageInspector::ReinitAction,
     this, &QmitkRenderWindowUtilityWidget::ReinitAction);
   connect(m_RenderWindowInspector, &QmitkRenderWindowContextDataStorageInspector::ResetAction,
     this, &QmitkRenderWindowUtilityWidget::ResetAction);
 
   m_MenuBar = new QMenuBar(this);
   m_MenuBar->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
   auto menu = m_MenuBar->addMenu("Data");
   QWidgetAction* newAct = new QWidgetAction(menu);
   newAct->setDefaultWidget(m_RenderWindowInspector);
   menu->addAction(newAct);
   m_Layout->addWidget(m_MenuBar);
 
-  m_SliceNavigator = new QmitkSliderNavigatorWidget(this);
+  m_SliceNavigationWidget = new QmitkSliceNavigationWidget(this);
   m_StepperAdapter =
-    new QmitkStepperAdapter(m_SliceNavigator, sliceNavigationController->GetSlice(), "sliceNavigator");
-  m_Layout->addWidget(m_SliceNavigator);
+    new QmitkStepperAdapter(m_SliceNavigationWidget, sliceNavigationController->GetSlice(), "sliceNavigator");
+  m_Layout->addWidget(m_SliceNavigationWidget);
 
   mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer{ baseRenderer };
   m_RenderWindowViewDirectionController = std::make_unique<mitk::RenderWindowViewDirectionController>();
   m_RenderWindowViewDirectionController->SetControlledRenderer(controlledRenderer);
   m_RenderWindowViewDirectionController->SetDataStorage(dataStorage);
 
   m_ViewDirectionSelector = new QComboBox(this);
   QStringList viewDirections{ "axial", "coronal", "sagittal"};
   m_ViewDirectionSelector->insertItems(0, viewDirections);
   connect(m_ViewDirectionSelector, &QComboBox::currentTextChanged, this, &QmitkRenderWindowUtilityWidget::ChangeViewDirection);
   auto viewDirection = sliceNavigationController->GetDefaultViewDirection();
   switch (viewDirection)
   {
   case mitk::SliceNavigationController::Axial:
     m_ViewDirectionSelector->setCurrentIndex(0);
     break;
   case mitk::SliceNavigationController::Coronal:
     m_ViewDirectionSelector->setCurrentIndex(1);
     break;
   case mitk::SliceNavigationController::Sagittal:
     m_ViewDirectionSelector->setCurrentIndex(2);
     break;
   default:
     break;
   }
   m_Layout->addWidget(m_ViewDirectionSelector);
 }
 
 QmitkRenderWindowUtilityWidget::~QmitkRenderWindowUtilityWidget()
 {
 }
 
 void QmitkRenderWindowUtilityWidget::SetInvertedSliceNavigation(bool inverted)
 {
-  m_SliceNavigator->SetInverseDirection(inverted);
+  m_SliceNavigationWidget->SetInverseDirection(inverted);
 }
 
 void QmitkRenderWindowUtilityWidget::ChangeViewDirection(const QString& viewDirection)
 {
   m_RenderWindowViewDirectionController->SetViewDirectionOfRenderer(viewDirection.toStdString());
 }
diff --git a/Modules/QtWidgetsExt/include/QmitkSliceWidget.h b/Modules/QtWidgetsExt/include/QmitkSliceWidget.h
index 9f8f8a7a57..faa776fec6 100644
--- a/Modules/QtWidgetsExt/include/QmitkSliceWidget.h
+++ b/Modules/QtWidgetsExt/include/QmitkSliceWidget.h
@@ -1,91 +1,91 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKSLICEWIDGET_H_
 #define QMITKSLICEWIDGET_H_
 
 #include "MitkQtWidgetsExtExports.h"
 #include "ui_QmitkSliceWidget.h"
 
 #include "QmitkRenderWindow.h"
 #include "mitkDataStorage.h"
 #include "mitkSliceNavigationController.h"
-#include "QmitkSliderNavigatorWidget.h"
+#include "QmitkSliceNavigationWidget.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkStandaloneDataStorage.h"
 #include <QWidget>
 
 class MITKQTWIDGETSEXT_EXPORT QmitkSliceWidget : public QWidget, public Ui::QmitkSliceWidgetUi
 {
   Q_OBJECT
 
 public:
   QmitkSliceWidget(QWidget *parent = nullptr, const char *name = nullptr, Qt::WindowFlags f = nullptr);
 
   mitk::VtkPropRenderer *GetRenderer();
 
   QFrame *GetSelectionFrame();
 
   void UpdateGL();
 
   void mousePressEvent(QMouseEvent *e) override;
 
   void setPopUpEnabled(bool b);
 
   void SetDataStorage(mitk::StandaloneDataStorage::Pointer storage);
 
   mitk::StandaloneDataStorage *GetDataStorage();
 
-  QmitkSliderNavigatorWidget *GetNavigatorWidget();
+  QmitkSliceNavigationWidget* GetSliceNavigationWidget();
 
   bool IsLevelWindowEnabled();
 
   QmitkRenderWindow *GetRenderWindow();
 
   mitk::SliceNavigationController *GetSliceNavigationController() const;
 
   mitk::CameraRotationController *GetCameraRotationController() const;
 
   mitk::BaseController *GetController() const;
 
 public slots:
 
   void SetData(mitk::DataStorage::SetOfObjects::ConstIterator it);
 
   void SetData(mitk::DataStorage::SetOfObjects::ConstIterator it, mitk::SliceNavigationController::ViewDirection view);
 
   void SetData(mitk::DataNode::Pointer node);
 
   void SetData(mitk::DataNode::Pointer node, mitk::SliceNavigationController::ViewDirection view);
 
   void InitWidget(mitk::SliceNavigationController::ViewDirection viewDirection);
 
   void wheelEvent(QWheelEvent *e) override;
 
   void ChangeView(QAction *val);
 
   void SetLevelWindowEnabled(bool enable);
 
 protected:
   QmitkRenderWindow *m_RenderWindow;
   mitk::SliceNavigationController::ViewDirection m_View;
 
 private:
   bool popUpEnabled;
   mitk::VtkPropRenderer::Pointer m_Renderer;
   mitk::SlicedGeometry3D::Pointer m_SlicedGeometry;
   mitk::StandaloneDataStorage::Pointer m_DataStorage;
 
   QMenu *popUp;
 };
 
 #endif
diff --git a/Modules/QtWidgetsExt/src/QmitkSliceWidget.cpp b/Modules/QtWidgetsExt/src/QmitkSliceWidget.cpp
index be85406e02..d3981afadd 100644
--- a/Modules/QtWidgetsExt/src/QmitkSliceWidget.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkSliceWidget.cpp
@@ -1,266 +1,266 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkSliceWidget.h"
 #include "QmitkStepperAdapter.h"
 #include "mitkCameraController.h"
 #include "mitkImage.h"
 #include "mitkNodePredicateDataType.h"
 #include <QMenu>
 #include <QMouseEvent>
 #include <mitkCameraController.h>
 #include <mitkProportionalTimeGeometry.h>
 
 QmitkSliceWidget::QmitkSliceWidget(QWidget *parent, const char *name, Qt::WindowFlags f) : QWidget(parent, f)
 {
   this->setupUi(this);
 
   if (name != nullptr)
     this->setObjectName(name);
 
   popUp = new QMenu(this);
   popUp->addAction("Axial");
   popUp->addAction("Coronal");
   popUp->addAction("Sagittal");
 
   QObject::connect(popUp, SIGNAL(triggered(QAction *)), this, SLOT(ChangeView(QAction *)));
   setPopUpEnabled(false);
 
   m_SlicedGeometry = nullptr;
   m_View = mitk::SliceNavigationController::Axial;
 
   QHBoxLayout *hlayout = new QHBoxLayout(container);
   hlayout->setMargin(0);
 
   // create widget
   QString composedName("QmitkSliceWidget::");
   if (!this->objectName().isEmpty())
     composedName += this->objectName();
   else
     composedName += "QmitkGLWidget";
   m_RenderWindow = new QmitkRenderWindow(container, composedName);
   m_Renderer = m_RenderWindow->GetRenderer();
   hlayout->addWidget(m_RenderWindow);
 
-  new QmitkStepperAdapter(m_NavigatorWidget, m_RenderWindow->GetSliceNavigationController()->GetSlice(), "navigation");
+  new QmitkStepperAdapter(sliceNavigationWidget, m_RenderWindow->GetSliceNavigationController()->GetSlice(), "navigation");
 
   SetLevelWindowEnabled(true);
 }
 
 mitk::VtkPropRenderer *QmitkSliceWidget::GetRenderer()
 {
   return m_Renderer;
 }
 
 QFrame *QmitkSliceWidget::GetSelectionFrame()
 {
   return SelectionFrame;
 }
 
 void QmitkSliceWidget::SetDataStorage(mitk::StandaloneDataStorage::Pointer storage)
 {
   m_DataStorage = storage;
   m_Renderer->SetDataStorage(m_DataStorage);
 }
 
 mitk::StandaloneDataStorage *QmitkSliceWidget::GetDataStorage()
 {
   return m_DataStorage;
 }
 
 void QmitkSliceWidget::SetData(mitk::DataStorage::SetOfObjects::ConstIterator it)
 {
   SetData(it->Value(), m_View);
 }
 
 void QmitkSliceWidget::SetData(mitk::DataStorage::SetOfObjects::ConstIterator it,
                                mitk::SliceNavigationController::ViewDirection view)
 {
   SetData(it->Value(), view);
 }
 
 void QmitkSliceWidget::SetData(mitk::DataNode::Pointer node)
 {
   try
   {
     if (m_DataStorage.IsNotNull())
     {
       m_DataStorage->Add(node);
     }
   }
   catch (...)
   {
   }
   SetData(node, m_View);
 }
 
 void QmitkSliceWidget::SetData(mitk::DataNode::Pointer node, mitk::SliceNavigationController::ViewDirection view)
 {
   mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(node->GetData());
 
   if (image.IsNull())
   {
     MITK_WARN << "QmitkSliceWidget data is not an image!";
     return;
   }
 
   m_SlicedGeometry = image->GetSlicedGeometry();
   this->InitWidget(view);
 }
 
 void QmitkSliceWidget::InitWidget(mitk::SliceNavigationController::ViewDirection viewDirection)
 {
   m_View = viewDirection;
 
   mitk::SliceNavigationController *controller = m_RenderWindow->GetSliceNavigationController();
 
   if (viewDirection == mitk::SliceNavigationController::Axial)
   {
     controller->SetViewDirection(mitk::SliceNavigationController::Axial);
   }
   else if (viewDirection == mitk::SliceNavigationController::Coronal)
   {
     controller->SetViewDirection(mitk::SliceNavigationController::Coronal);
   }
   // init sagittal view
   else
   {
     controller->SetViewDirection(mitk::SliceNavigationController::Sagittal);
   }
 
   if (m_SlicedGeometry.IsNull())
   {
     return;
   }
 
   mitk::BaseGeometry::Pointer geometry = static_cast<mitk::BaseGeometry *>(m_SlicedGeometry->Clone().GetPointer());
 
   const mitk::BoundingBox::Pointer boundingbox = m_DataStorage->ComputeVisibleBoundingBox(GetRenderer(), nullptr);
 
   if (boundingbox->GetPoints()->Size() > 0)
   {
     // let's see if we have data with a limited live-span ...
     mitk::TimeBounds timebounds = m_DataStorage->ComputeTimeBounds(GetRenderer(), nullptr);
 
     mitk::ProportionalTimeGeometry::Pointer timeGeometry = mitk::ProportionalTimeGeometry::New();
     timeGeometry->Initialize(geometry, 1);
 
     {
       timeGeometry->SetFirstTimePoint(timebounds[0]);
       timeGeometry->SetStepDuration(1.0);
     }
 
     if (timeGeometry->GetBoundingBoxInWorld()->GetDiagonalLength2() >= mitk::eps)
     {
       controller->SetInputWorldTimeGeometry(timeGeometry);
       controller->Update();
     }
   }
 
   GetRenderer()->GetCameraController()->Fit();
   mitk::RenderingManager::GetInstance()->RequestUpdate(GetRenderer()->GetRenderWindow());
 }
 
 void QmitkSliceWidget::UpdateGL()
 {
   GetRenderer()->GetCameraController()->Fit();
   mitk::RenderingManager::GetInstance()->RequestUpdate(GetRenderer()->GetRenderWindow());
 }
 
 void QmitkSliceWidget::mousePressEvent(QMouseEvent *e)
 {
   if (e->button() == Qt::RightButton && popUpEnabled)
   {
     popUp->popup(QCursor::pos());
   }
 }
 
 void QmitkSliceWidget::wheelEvent(QWheelEvent *e)
 {
-  int val = m_NavigatorWidget->GetPos();
+  int val = sliceNavigationWidget->GetPos();
 
   if (e->orientation() * e->delta() > 0)
   {
-    m_NavigatorWidget->SetPos(val + 1);
+    sliceNavigationWidget->SetPos(val + 1);
   }
   else
   {
     if (val > 0)
-      m_NavigatorWidget->SetPos(val - 1);
+      sliceNavigationWidget->SetPos(val - 1);
   }
 }
 
 void QmitkSliceWidget::ChangeView(QAction *val)
 {
   if (val->text() == "Axial")
   {
     InitWidget(mitk::SliceNavigationController::Axial);
   }
   else if (val->text() == "Coronal")
   {
     InitWidget(mitk::SliceNavigationController::Coronal);
   }
   else if (val->text() == "Sagittal")
   {
     InitWidget(mitk::SliceNavigationController::Sagittal);
   }
 }
 
 void QmitkSliceWidget::setPopUpEnabled(bool b)
 {
   popUpEnabled = b;
 }
 
-QmitkSliderNavigatorWidget *QmitkSliceWidget::GetNavigatorWidget()
+QmitkSliceNavigationWidget* QmitkSliceWidget::GetSliceNavigationWidget()
 {
-  return m_NavigatorWidget;
+  return sliceNavigationWidget;
 }
 
 void QmitkSliceWidget::SetLevelWindowEnabled(bool enable)
 {
   levelWindow->setEnabled(enable);
   if (!enable)
   {
     levelWindow->setMinimumWidth(0);
     levelWindow->setMaximumWidth(0);
   }
   else
   {
     levelWindow->setMinimumWidth(28);
     levelWindow->setMaximumWidth(28);
   }
 }
 
 bool QmitkSliceWidget::IsLevelWindowEnabled()
 {
   return levelWindow->isEnabled();
 }
 
 QmitkRenderWindow *QmitkSliceWidget::GetRenderWindow()
 {
   return m_RenderWindow;
 }
 
 mitk::SliceNavigationController *QmitkSliceWidget::GetSliceNavigationController() const
 {
   return m_RenderWindow->GetSliceNavigationController();
 }
 
 mitk::CameraRotationController *QmitkSliceWidget::GetCameraRotationController() const
 {
   return m_RenderWindow->GetCameraRotationController();
 }
 
 mitk::BaseController *QmitkSliceWidget::GetController() const
 {
   return m_RenderWindow->GetController();
 }
diff --git a/Modules/QtWidgetsExt/src/QmitkSliceWidget.ui b/Modules/QtWidgetsExt/src/QmitkSliceWidget.ui
index d88e753455..0e4a4916fe 100644
--- a/Modules/QtWidgetsExt/src/QmitkSliceWidget.ui
+++ b/Modules/QtWidgetsExt/src/QmitkSliceWidget.ui
@@ -1,171 +1,171 @@
 <ui version="4.0" >
  <class>QmitkSliceWidgetUi</class>
  <widget class="QWidget" name="QmitkSliceWidgetUi" >
   <property name="geometry" >
    <rect>
     <x>0</x>
     <y>0</y>
     <width>534</width>
     <height>519</height>
    </rect>
   </property>
   <property name="windowTitle" >
    <string>QmitkSliceWidget</string>
   </property>
   <layout class="QVBoxLayout" >
    <property name="spacing" >
     <number>0</number>
    </property>
    <property name="leftMargin" >
     <number>0</number>
    </property>
    <property name="topMargin" >
     <number>0</number>
    </property>
    <property name="rightMargin" >
     <number>0</number>
    </property>
    <property name="bottomMargin" >
     <number>0</number>
    </property>
    <item>
     <widget class="QFrame" name="SelectionFrame" >
      <property name="frameShape" >
       <enum>QFrame::NoFrame</enum>
      </property>
      <property name="frameShadow" >
       <enum>QFrame::Plain</enum>
      </property>
      <property name="margin" stdset="0" >
       <number>0</number>
      </property>
      <layout class="QHBoxLayout" >
       <property name="spacing" >
        <number>0</number>
       </property>
       <property name="leftMargin" >
        <number>0</number>
       </property>
       <property name="topMargin" >
        <number>0</number>
       </property>
       <property name="rightMargin" >
        <number>0</number>
       </property>
       <property name="bottomMargin" >
        <number>0</number>
       </property>
       <item>
        <widget class="QFrame" name="container" >
         <property name="sizePolicy" >
          <sizepolicy vsizetype="Preferred" hsizetype="Preferred" >
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="frameShape" >
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow" >
          <enum>QFrame::Plain</enum>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QFrame" name="frame" >
         <property name="sizePolicy" >
          <sizepolicy vsizetype="Preferred" hsizetype="Fixed" >
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="frameShape" >
          <enum>QFrame::Box</enum>
         </property>
         <property name="frameShadow" >
          <enum>QFrame::Sunken</enum>
         </property>
         <layout class="QVBoxLayout" >
          <property name="spacing" >
           <number>0</number>
          </property>
          <property name="leftMargin" >
           <number>0</number>
          </property>
          <property name="topMargin" >
           <number>0</number>
          </property>
          <property name="rightMargin" >
           <number>0</number>
          </property>
          <property name="bottomMargin" >
           <number>0</number>
          </property>
          <item>
           <widget class="QmitkLevelWindowWidget" native="1" name="levelWindow" >
            <property name="sizePolicy" >
             <sizepolicy vsizetype="MinimumExpanding" hsizetype="Minimum" >
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize" >
             <size>
              <width>25</width>
              <height>50</height>
             </size>
            </property>
            <property name="maximumSize" >
             <size>
              <width>25</width>
              <height>2000</height>
             </size>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
-    <widget class="QmitkSliderNavigatorWidget" native="1" name="m_NavigatorWidget" >
+    <widget class="QmitkSliceNavigationWidget" native="1" name="sliceNavigationWidget" >
      <property name="sizePolicy" >
       <sizepolicy vsizetype="Fixed" hsizetype="Preferred" >
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize" >
       <size>
        <width>0</width>
        <height>25</height>
       </size>
      </property>
      <property name="maximumSize" >
       <size>
        <width>32767</width>
        <height>25</height>
       </size>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11" />
  <customwidgets>
   <customwidget>
    <class>QmitkLevelWindowWidget</class>
    <extends>QWidget</extends>
    <header location="global" >QmitkLevelWindowWidget.h</header>
   </customwidget>
   <customwidget>
-   <class>QmitkSliderNavigatorWidget</class>
+   <class>QmitkSliceNavigationWidget</class>
    <extends>QWidget</extends>
-   <header location="global" >QmitkSliderNavigatorWidget.h</header>
+   <header location="global" >QmitkSliceNavigationWidget.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>