diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkHistogramVisualizationWidget.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkHistogramVisualizationWidget.cpp
index e893386303..25ad5e8ad8 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkHistogramVisualizationWidget.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkHistogramVisualizationWidget.cpp
@@ -1,228 +1,229 @@
 /*============================================================================
 
 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 "QmitkHistogramVisualizationWidget.h"
 
 #include <QClipboard>
 
 QmitkHistogramVisualizationWidget::QmitkHistogramVisualizationWidget(QWidget* parent) : QWidget(parent)
 {
   m_Controls.setupUi(this);
   m_Controls.checkBoxShowSubchart->setChecked(false);
   m_Controls.spinBoxNBins->setValue(m_DefaultNBins);
   m_Controls.spinBoxNBins->setMinimum(m_MinNBins);
   m_Controls.spinBoxNBins->setMaximum(m_MaxNBins);
   m_Controls.chartWidget->SetXAxisLabel("Gray value");
   m_Controls.chartWidget->SetYAxisLabel("Frequency");
+  m_Controls.chartWidget->SetShowLegend(false);
 
   SetGUIElementsEnabled(false);
   CreateConnections();
 }
 
 void QmitkHistogramVisualizationWidget::SetHistogram(itk::Statistics::Histogram<double>::ConstPointer histogram, const std::string& dataLabel)
 {
   if (histogram == nullptr)
     return;
 
   bool histogramWasEmpty = m_Histograms.empty();
 
   if (m_Histograms.find(dataLabel) == m_Histograms.end())
   {
     m_Histograms.insert(std::make_pair(dataLabel, histogram));
     m_Controls.chartWidget->AddData2D(ConvertHistogramToPairList(histogram), dataLabel);
     m_Controls.chartWidget->SetChartType(dataLabel, QmitkChartWidget::ChartType::bar);
   }
   else
   {
     m_Histograms[dataLabel] = histogram;
     m_Controls.chartWidget->UpdateData2D(ConvertHistogramToPairList(histogram), dataLabel);
   }
 
   if (m_Histograms.empty() != histogramWasEmpty)
   {
     m_Controls.chartWidget->Show(m_Controls.checkBoxShowSubchart->isChecked());
     SetGUIElementsEnabled(!m_Histograms.empty());
   }
 }
 
 void QmitkHistogramVisualizationWidget::Reset()
 {
   m_Controls.chartWidget->Clear();
   SetGUIElementsEnabled(false);
 }
 
 int QmitkHistogramVisualizationWidget::GetBins() {
   return m_Controls.spinBoxNBins->value();
 }
 
 void QmitkHistogramVisualizationWidget::ResetDefault()
 {
   m_Controls.checkBoxUseDefaultNBins->setChecked(true);
   m_Controls.spinBoxNBins->setEnabled(false);
   m_Controls.spinBoxNBins->setValue(100);
   m_Controls.checkBoxShowSubchart->setChecked(false);
 }
 
 void QmitkHistogramVisualizationWidget::SetTheme(QmitkChartWidget::ColorTheme style)
 {
   m_Controls.chartWidget->SetTheme(style);
 }
 
 void QmitkHistogramVisualizationWidget::CreateConnections()
 {
   connect(m_Controls.buttonCopyHistogramToClipboard, &QPushButton::clicked, this, &QmitkHistogramVisualizationWidget::OnClipboardButtonClicked);
   connect(m_Controls.checkBoxUseDefaultNBins, &QCheckBox::clicked, this, &QmitkHistogramVisualizationWidget::OnDefaultNBinsCheckBoxChanged);
   connect(m_Controls.spinBoxNBins, &QSpinBox::editingFinished, this, &QmitkHistogramVisualizationWidget::OnNBinsSpinBoxValueChanged);
   connect(m_Controls.checkBoxShowSubchart, &QCheckBox::clicked, this, &QmitkHistogramVisualizationWidget::OnShowSubchartCheckBoxChanged);
   connect(m_Controls.checkBoxViewMinMax, &QCheckBox::clicked, this, &QmitkHistogramVisualizationWidget::OnViewMinMaxCheckBoxChanged);
   connect(m_Controls.doubleSpinBoxMaxValue, &QSpinBox::editingFinished, this, &QmitkHistogramVisualizationWidget::OnMaxValueSpinBoxValueChanged);
   connect(m_Controls.doubleSpinBoxMinValue, &QSpinBox::editingFinished, this, &QmitkHistogramVisualizationWidget::OnMinValueSpinBoxValueChanged);
 }
 
 void QmitkHistogramVisualizationWidget::SetGUIElementsEnabled(bool enabled)
 {
   this->setEnabled(enabled);
   m_Controls.tabWidgetPlot->setEnabled(enabled);
   m_Controls.checkBoxShowSubchart->setEnabled(enabled);
   m_Controls.checkBoxUseDefaultNBins->setEnabled(enabled);
   m_Controls.spinBoxNBins->setEnabled(!m_Controls.checkBoxUseDefaultNBins->isChecked());
   m_Controls.buttonCopyHistogramToClipboard->setEnabled(enabled);
   m_Controls.checkBoxViewMinMax->setEnabled(enabled);
   m_Controls.doubleSpinBoxMaxValue->setEnabled(m_Controls.checkBoxViewMinMax->isChecked());
   m_Controls.doubleSpinBoxMinValue->setEnabled(m_Controls.checkBoxViewMinMax->isChecked());
 }
 
 std::vector< std::pair<double, double> > QmitkHistogramVisualizationWidget::ConvertHistogramToPairList(itk::Statistics::Histogram<double>::ConstPointer histogram) const
 {
   std::map<double, double> histogramMap;
   if (histogram)
   {
     auto endIt = histogram->End();
     auto it = histogram->Begin();
 
     // generating Lists of measurement and frequencies
     for (; it != endIt; ++it)
     {
       double frequency = it.GetFrequency();
       double measurement = it.GetMeasurementVector()[0];
       histogramMap.emplace(measurement, frequency);
     }
 
   }
   std::vector< std::pair<double, double> > histogram_list;
   for(auto iter = histogramMap.begin(); iter != histogramMap.end(); ++iter)
     histogram_list.emplace_back( iter->first, iter->second );
 
   return histogram_list;
 }
 
 void QmitkHistogramVisualizationWidget::OnClipboardButtonClicked()
 {
   if (!m_Histograms.empty())
   {
     QString clipboard;
     for (const auto& histogram : m_Histograms)
     {
       clipboard.append(QString::fromStdString(histogram.first));
       clipboard.append("Measurement \t Frequency\n");
       auto iter = histogram.second->Begin();
       auto iterEnd = histogram.second->End();
       for (; iter != iterEnd; ++iter)
       {
         clipboard = clipboard.append("%L1 \t %L2\n")
             .arg(iter.GetMeasurementVector()[0], 0, 'f', 2)
             .arg(iter.GetFrequency());
       }
       clipboard.append("\n\n");
     }
 
     QApplication::clipboard()->clear();
     QApplication::clipboard()->setText(clipboard, QClipboard::Clipboard);
   }
 }
 
 void QmitkHistogramVisualizationWidget::OnDefaultNBinsCheckBoxChanged()
 {
   if (m_Controls.checkBoxUseDefaultNBins->isChecked())
   {
     m_Controls.spinBoxNBins->setEnabled(false);
     if (m_Controls.spinBoxNBins->value() != static_cast<int>(m_DefaultNBins) ) {
       m_Controls.spinBoxNBins->setValue(m_DefaultNBins);
       OnNBinsSpinBoxValueChanged();
     }
   }
   else
   {
     m_Controls.spinBoxNBins->setEnabled(true);
   }
 }
 
 void QmitkHistogramVisualizationWidget::OnNBinsSpinBoxValueChanged()
 {
   emit RequestHistogramUpdate(m_Controls.spinBoxNBins->value());
 }
 
 void QmitkHistogramVisualizationWidget::OnShowSubchartCheckBoxChanged()
 {
   m_Controls.chartWidget->Show(m_Controls.checkBoxShowSubchart->isChecked());
 }
 
 void QmitkHistogramVisualizationWidget::OnViewMinMaxCheckBoxChanged()
 {
   double min = std::numeric_limits<double>::max();
   double max = std::numeric_limits<double>::lowest();
   for (const auto& histogram : m_Histograms)
   {
     auto aMin = histogram.second->GetBinMin(0, 0);
     if (min > aMin) min = aMin;
 
     auto maxVector = histogram.second->GetDimensionMaxs(0);
     if (m_Controls.checkBoxUseDefaultNBins->isChecked())
     {
       max = std::max(max, maxVector[m_DefaultNBins - 1]);
     }
     else
     {
       max = std::max(max, maxVector[m_Controls.spinBoxNBins->value() - 1]);
     }
   }
 
   if (!m_Controls.checkBoxViewMinMax->isChecked())
   {
     m_Controls.doubleSpinBoxMaxValue->setEnabled(false);
     m_Controls.doubleSpinBoxMinValue->setEnabled(false);
     m_Controls.chartWidget->Reload();
   }
   else
   {
     m_Controls.doubleSpinBoxMinValue->setMinimum(min);
     m_Controls.doubleSpinBoxMinValue->setValue(min);
     m_Controls.doubleSpinBoxMaxValue->setMaximum(max);
     m_Controls.doubleSpinBoxMaxValue->setValue(max);
     m_Controls.doubleSpinBoxMaxValue->setEnabled(true);
     m_Controls.doubleSpinBoxMinValue->setEnabled(true);
   }
 }
 
 void QmitkHistogramVisualizationWidget::OnMinValueSpinBoxValueChanged()
 {
   m_Controls.doubleSpinBoxMaxValue->setMinimum(m_Controls.doubleSpinBoxMinValue->value()+1);
   m_Controls.chartWidget->SetMinMaxValueXView(m_Controls.doubleSpinBoxMinValue->value(),m_Controls.doubleSpinBoxMaxValue->value());
   m_Controls.chartWidget->Show();
 }
 
 void QmitkHistogramVisualizationWidget::OnMaxValueSpinBoxValueChanged()
 {
   m_Controls.doubleSpinBoxMinValue->setMaximum(m_Controls.doubleSpinBoxMaxValue->value()-1);
   m_Controls.chartWidget->SetMinMaxValueXView(m_Controls.doubleSpinBoxMinValue->value(),m_Controls.doubleSpinBoxMaxValue->value());
   m_Controls.chartWidget->Show();
 }
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkSliceNavigationListener.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkSliceNavigationListener.cpp
index 4e8df798a0..9c8bf772ba 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkSliceNavigationListener.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkSliceNavigationListener.cpp
@@ -1,172 +1,205 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 // Qmitk
 #include "QmitkRenderWindow.h"
 #include "QmitkSliceNavigationListener.h"
 
 #include "mitkIRenderWindowPart.h"
 
 // Qt
 #include <QTimer>
 #include <QMessageBox>
 
 
 ///**********************************************
-QmitkSliceNavigationListener::QmitkSliceNavigationListener(): m_renderWindowPart(nullptr),
+QmitkSliceNavigationListener::QmitkSliceNavigationListener() : m_renderWindowPart(nullptr),
 m_PendingSliceChangedEvent(false),
-m_internalUpdateFlag(false)
+m_CurrentSelectedPosition(std::numeric_limits<mitk::Point3D::ValueType>::lowest()),
+m_CurrentSelectedTimePoint(std::numeric_limits<mitk::TimePointType>::lowest())
 {
 }
 
 QmitkSliceNavigationListener::~QmitkSliceNavigationListener()
 {
   this->RemoveAllObservers();
 };
 
+mitk::TimePointType QmitkSliceNavigationListener::GetCurrentSelectedTimePoint() const
+{
+  return m_CurrentSelectedTimePoint;
+}
+
+mitk::Point3D QmitkSliceNavigationListener::GetCurrentSelectedPosition() const
+{
+  return m_CurrentSelectedPosition;
+}
+
 void QmitkSliceNavigationListener::OnSliceChangedDelayed()
 {
   m_PendingSliceChangedEvent = false;
+
   emit SliceChanged();
+
+  if (nullptr != m_renderWindowPart)
+  {
+    const auto newSelectedPosition = m_renderWindowPart->GetSelectedPosition();
+    const auto newSelectedTimePoint = m_renderWindowPart->GetSelectedTimePoint();
+
+    if (newSelectedPosition != m_CurrentSelectedPosition)
+    {
+      m_CurrentSelectedPosition = newSelectedPosition;
+      emit SelectedPositionChanged(newSelectedPosition);
+    }
+
+    if (newSelectedTimePoint != m_CurrentSelectedTimePoint)
+    {
+      m_CurrentSelectedTimePoint = newSelectedTimePoint;
+      emit SelectedTimePointChanged(newSelectedTimePoint);
+    }
+  }
 };
 
 void
 QmitkSliceNavigationListener::OnSliceChangedInternal(const itk::EventObject&)
 {
   // Taken from QmitkStdMultiWidget::HandleCrosshairPositionEvent().
   // Since there are always 3 events arriving (one for each render window) every time the slice
   // or time changes, the slot OnSliceChangedDelayed is triggered - and only if it hasn't been
   // triggered yet - so it is only executed once for every slice/time change.
   if (!m_PendingSliceChangedEvent)
   {
     m_PendingSliceChangedEvent = true;
 
     QTimer::singleShot(0, this, SLOT(OnSliceChangedDelayed()));
   }
 };
 
 void QmitkSliceNavigationListener::OnSliceNavigationControllerDeleted(const itk::Object* sender, const itk::EventObject& /*e*/)
 {
   const mitk::SliceNavigationController* sendingSlicer =
     dynamic_cast<const mitk::SliceNavigationController*>(sender);
 
   this->RemoveObservers(sendingSlicer);
 };
 
 void QmitkSliceNavigationListener::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_renderWindowPart != renderWindowPart)
   {
     m_renderWindowPart = renderWindowPart;
 
     if (!InitObservers())
     {
       QMessageBox::information(nullptr, "Error", "Unable to set up the event observers. The " \
         "plot will not be triggered on changing the crosshair, " \
         "position or time step.");
     }
+
+    m_CurrentSelectedPosition = m_renderWindowPart->GetSelectedPosition();
+    m_CurrentSelectedTimePoint = m_renderWindowPart->GetSelectedTimePoint();
   }
 };
 
 void QmitkSliceNavigationListener::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   m_renderWindowPart = nullptr;
   this->RemoveAllObservers(renderWindowPart);
 };
 
 bool QmitkSliceNavigationListener::InitObservers()
 {
   bool result = true;
 
   typedef QHash<QString, QmitkRenderWindow*> WindowMapType;
   WindowMapType windowMap = m_renderWindowPart->GetQmitkRenderWindows();
 
   auto i = windowMap.begin();
 
   while (i != windowMap.end())
   {
     mitk::SliceNavigationController* sliceNavController =
       i.value()->GetSliceNavigationController();
 
     if (sliceNavController)
     {
       itk::ReceptorMemberCommand<QmitkSliceNavigationListener>::Pointer cmdSliceEvent =
         itk::ReceptorMemberCommand<QmitkSliceNavigationListener>::New();
       cmdSliceEvent->SetCallbackFunction(this, &QmitkSliceNavigationListener::OnSliceChangedInternal);
       int tag = sliceNavController->AddObserver(
         mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0),
         cmdSliceEvent);
 
       m_ObserverMap.insert(std::make_pair(sliceNavController, ObserverInfo(sliceNavController, tag,
         i.key().toStdString(), m_renderWindowPart)));
 
       itk::ReceptorMemberCommand<QmitkSliceNavigationListener>::Pointer cmdTimeEvent =
         itk::ReceptorMemberCommand<QmitkSliceNavigationListener>::New();
       cmdTimeEvent->SetCallbackFunction(this, &QmitkSliceNavigationListener::OnSliceChangedInternal);
       tag = sliceNavController->AddObserver(
         mitk::SliceNavigationController::GeometryTimeEvent(nullptr, 0),
         cmdTimeEvent);
 
       m_ObserverMap.insert(std::make_pair(sliceNavController, ObserverInfo(sliceNavController, tag,
         i.key().toStdString(), m_renderWindowPart)));
 
       itk::MemberCommand<QmitkSliceNavigationListener>::Pointer cmdDelEvent =
         itk::MemberCommand<QmitkSliceNavigationListener>::New();
       cmdDelEvent->SetCallbackFunction(this,
         &QmitkSliceNavigationListener::OnSliceNavigationControllerDeleted);
       tag = sliceNavController->AddObserver(
         itk::DeleteEvent(), cmdDelEvent);
 
       m_ObserverMap.insert(std::make_pair(sliceNavController, ObserverInfo(sliceNavController, tag,
         i.key().toStdString(), m_renderWindowPart)));
     }
 
     ++i;
 
     result = result && sliceNavController;
   }
 
   return result;
 };
 
 void QmitkSliceNavigationListener::RemoveObservers(const mitk::SliceNavigationController* deletedSlicer)
 {
   std::pair < ObserverMapType::const_iterator, ObserverMapType::const_iterator> obsRange =
     m_ObserverMap.equal_range(deletedSlicer);
 
   for (ObserverMapType::const_iterator pos = obsRange.first; pos != obsRange.second; ++pos)
   {
     pos->second.controller->RemoveObserver(pos->second.observerTag);
   }
 
   m_ObserverMap.erase(deletedSlicer);
 };
 
 void QmitkSliceNavigationListener::RemoveAllObservers(mitk::IRenderWindowPart* deletedPart)
 {
   for (ObserverMapType::const_iterator pos = m_ObserverMap.begin(); pos != m_ObserverMap.end();)
   {
     ObserverMapType::const_iterator delPos = pos++;
 
     if (deletedPart == nullptr || deletedPart == delPos->second.renderWindowPart)
     {
       delPos->second.controller->RemoveObserver(delPos->second.observerTag);
       m_ObserverMap.erase(delPos);
     }
   }
 };
 
 QmitkSliceNavigationListener::ObserverInfo::ObserverInfo(mitk::SliceNavigationController* controller, int observerTag,
   const std::string& renderWindowName, mitk::IRenderWindowPart* part) : controller(controller), observerTag(observerTag),
   renderWindowName(renderWindowName), renderWindowPart(part)
 {
 };
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkSliceNavigationListener.h b/Plugins/org.mitk.gui.qt.common/src/QmitkSliceNavigationListener.h
index 10ffebfe75..bf258cde86 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkSliceNavigationListener.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkSliceNavigationListener.h
@@ -1,118 +1,133 @@
 /*============================================================================
 
 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 __Q_MITK_SLICE_NAVIGATION_LISTENER_H
 #define __Q_MITK_SLICE_NAVIGATION_LISTENER_H
 
+#include <mitkTimeGeometry.h>
+#include <mitkPoint.h>
+
 #include <itkEventObject.h>
 
 #include <QObject>
 
 #include <org_mitk_gui_qt_common_Export.h>
 
 namespace itk
 {
   class Object;
 }
 
 namespace mitk
 {
   class SliceNavigationController;
   struct IRenderWindowPart;
 }
 
 
 /** @brief Helper class to allow QmitkAbstractView and derived classes to react on changes of the slice/time navigation.
  Purpose of the class to be used in view and to give the respective view class (by composition) the posibility to react
  on changes of the currently selected timepoint or position in the world geometry.\n
+ It also offers the convinient signals that are only trigger if the selected timepoint or the selected possition of the 
+ active render window have realy changed.\n
  In order to setup this class properly the following things must be regarded:
  - View class must also derive public from mitk::IRenderWindowPartListener
  - View class must implement void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) and pass the renderWindowPart to the listener.
 
     void QmitkMyView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
     {
       this->m_SliceNavigationListener.RenderWindowPartActivated(renderWindowPart);
     }
 
  - View class must implement void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) and pass the renderWindowPart to the listener.
 
     void QmitkMyView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)
     {
     this->m_SliceNavigationListener.RenderWindowPartDeactivated(renderWindowPart);
     }
 
  - View class must pass its on render window part in its CreateQtPartControl(QWidget* parent)
 
     this->m_SliceNavigationListener.RenderWindowPartActivated(this->GetRenderWindowPart());
 
  - View class must connect the SliceChanged signal of the listener as see fit.
 */
 class MITK_QT_COMMON QmitkSliceNavigationListener : public QObject
   {
     Q_OBJECT
 
   public:
     QmitkSliceNavigationListener();
     ~QmitkSliceNavigationListener() override;
 
+    mitk::TimePointType GetCurrentSelectedTimePoint() const;
+    mitk::Point3D GetCurrentSelectedPosition() const;
+
   signals:
+    /** Signal triggered as soon as there is any change. It may be a change in the position/slice or of the selected timepoint.*/
     void SliceChanged();
+    /** Convinience signal that can be used if you are only interested in changes of the current selected time point.
+     Changes in spatial position will be ignored.*/
+    void SelectedTimePointChanged(mitk::TimePointType newTimePoint);
+    /** Convinience signal that can be used if you are only interested in changes of the current selected position.
+     Changes in time will be ignored.*/
+    void SelectedPositionChanged(mitk::Point3D newPoint);
 
   public slots:
     void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart);
     void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart);
 
   protected slots:
       /** Overwrite function to implement the behavior on slice/time changes. */
       void OnSliceChangedDelayed();
 
   protected:
 
     /**	@brief Calls OnSliceChangedDelayed so the event isn't triggered multiple times. */
     void OnSliceChangedInternal(const itk::EventObject& e);
 
     void OnSliceNavigationControllerDeleted(const itk::Object* sender, const itk::EventObject& /*e*/);
 
     /** Initializes and sets the observers that are used to monitor changes in the selected position
     or time point in order to actualize the view.h*/
     bool InitObservers();
     void RemoveObservers(const mitk::SliceNavigationController* deletedSlicer);
     /** Removes all observers of the deletedPart. If null pointer is passed all observers will be removed.*/
     void RemoveAllObservers(mitk::IRenderWindowPart* deletedPart = nullptr);
 
     mitk::IRenderWindowPart* m_renderWindowPart;
 
     // Needed for observing the events for when a slice or time step is changed.
     bool m_PendingSliceChangedEvent;
 
     /**Helper structure to manage the registered observer events.*/
     struct ObserverInfo
     {
       mitk::SliceNavigationController* controller;
       int observerTag;
       std::string renderWindowName;
       mitk::IRenderWindowPart* renderWindowPart;
 
       ObserverInfo(mitk::SliceNavigationController* controller, int observerTag,
         const std::string& renderWindowName, mitk::IRenderWindowPart* part);
     };
 
     typedef std::multimap<const mitk::SliceNavigationController*, ObserverInfo> ObserverMapType;
     ObserverMapType m_ObserverMap;
 
-    /**	@brief	Is a visualization currently running? */
-    bool m_internalUpdateFlag;
+    mitk::Point3D m_CurrentSelectedPosition;
+    mitk::TimePointType m_CurrentSelectedTimePoint;
   };
 
 #endif
 
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
index 5a2bfebebd..a1d98885a3 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
@@ -1,444 +1,473 @@
 /*============================================================================
 
 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 "QmitkImageStatisticsView.h"
 
 #include <utility>
 
 // berry includes
 #include <berryIQtStyleManager.h>
 #include <berryWorkbenchPlugin.h>
 
 #include <QmitkChartWidget.h>
 #include <mitkImageStatisticsContainerNodeHelper.h>
 #include <mitkImageStatisticsPredicateHelper.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkIntensityProfile.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateGeometry.h>
 #include <mitkNodePredicateSubGeometry.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateFunction.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkStatusBar.h>
 #include <mitkPlanarFigure.h>
 #include "mitkPlanarFigureMaskGenerator.h"
 
 #include "QmitkImageStatisticsDataGenerator.h"
 
 #include "mitkImageStatisticsContainerManager.h"
 #include <mitkPlanarFigureInteractor.h>
 
 const std::string QmitkImageStatisticsView::VIEW_ID = "org.mitk.views.imagestatistics";
 
 QmitkImageStatisticsView::~QmitkImageStatisticsView()
 {
 }
 
 void QmitkImageStatisticsView::CreateQtPartControl(QWidget *parent)
 {
   m_Controls.setupUi(parent);
-  m_Controls.widget_histogram->SetTheme(GetColorTheme());
   m_Controls.widget_intensityProfile->SetTheme(GetColorTheme());
   m_Controls.groupBox_histogram->setVisible(true);
   m_Controls.groupBox_intensityProfile->setVisible(false);
   m_Controls.label_currentlyComputingStatistics->setVisible(false);
   m_Controls.sliderWidget_histogram->setPrefix("Time: ");
   m_Controls.sliderWidget_histogram->setDecimals(0);
   m_Controls.sliderWidget_histogram->setVisible(false);
   m_Controls.sliderWidget_intensityProfile->setPrefix("Time: ");
   m_Controls.sliderWidget_intensityProfile->setDecimals(0);
   m_Controls.sliderWidget_intensityProfile->setVisible(false);
   ResetGUI();
 
   m_DataGenerator = new QmitkImageStatisticsDataGenerator(parent);
   m_DataGenerator->SetDataStorage(this->GetDataStorage());
   m_DataGenerator->SetAutoUpdate(true);
   m_Controls.widget_statistics->SetDataStorage(this->GetDataStorage());
-  m_Controls.widget_histogram->SetTheme(GetColorTheme());
 
   m_Controls.imageNodesSelector->SetDataStorage(this->GetDataStorage());
   m_Controls.imageNodesSelector->SetNodePredicate(mitk::GetImageStatisticsImagePredicate());
   m_Controls.imageNodesSelector->SetSelectionCheckFunction(this->CheckForSameGeometry());
   m_Controls.imageNodesSelector->SetSelectionIsOptional(false);
   m_Controls.imageNodesSelector->SetInvalidInfo(QStringLiteral("Please select images for statistics"));
   m_Controls.imageNodesSelector->SetPopUpTitel(QStringLiteral("Select input images"));
   m_Controls.roiNodesSelector->SetPopUpHint(QStringLiteral("You may select multiple images for the statistics computation. But all selected images must have the same geometry."));
 
   m_Controls.roiNodesSelector->SetDataStorage(this->GetDataStorage());
   m_Controls.roiNodesSelector->SetNodePredicate(this->GenerateROIPredicate());
   m_Controls.roiNodesSelector->SetSelectionIsOptional(true);
   m_Controls.roiNodesSelector->SetEmptyInfo(QStringLiteral("Please select ROIs"));
   m_Controls.roiNodesSelector->SetPopUpTitel(QStringLiteral("Select ROIs for statistics computation"));
   m_Controls.roiNodesSelector->SetPopUpHint(QStringLiteral("You may select ROIs (e.g. planar figures, segmentations) that should be used for the statistics computation. The statistics will only computed for the image parts defined by the ROIs."));
 
-
   CreateConnections();
+
+  this->m_TimePointChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
+  connect(&m_TimePointChangeListener, &QmitkSliceNavigationListener::SelectedTimePointChanged, this, & QmitkImageStatisticsView::OnSelectedTimePointChanged);
+}
+
+void QmitkImageStatisticsView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
+{
+  this->m_TimePointChangeListener.RenderWindowPartActivated(renderWindowPart);
+}
+
+void QmitkImageStatisticsView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)
+{
+  this->m_TimePointChangeListener.RenderWindowPartDeactivated(renderWindowPart);
 }
 
 void QmitkImageStatisticsView::CreateConnections()
 {
   connect(m_Controls.checkBox_ignoreZero, &QCheckBox::stateChanged,
     this, &QmitkImageStatisticsView::OnCheckBoxIgnoreZeroStateChanged);
   connect(m_Controls.buttonSelection, &QAbstractButton::clicked,
     this, &QmitkImageStatisticsView::OnButtonSelectionPressed);
 
   connect(m_Controls.widget_histogram, &QmitkHistogramVisualizationWidget::RequestHistogramUpdate,
     this, &QmitkImageStatisticsView::OnRequestHistogramUpdate);
 
   connect(m_DataGenerator, &QmitkImageStatisticsDataGenerator::DataGenerationStarted,
     this, &QmitkImageStatisticsView::OnGenerationStarted);
   connect(m_DataGenerator, &QmitkImageStatisticsDataGenerator::GenerationFinished,
     this, &QmitkImageStatisticsView::OnGenerationFinished);
   connect(m_DataGenerator, &QmitkImageStatisticsDataGenerator::JobError,
     this, &QmitkImageStatisticsView::OnJobError);
 
   connect(m_Controls.imageNodesSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkImageStatisticsView::OnImageSelectionChanged);
   connect(m_Controls.roiNodesSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkImageStatisticsView::OnROISelectionChanged);
 
   connect(m_Controls.sliderWidget_intensityProfile, &ctkSliderWidget::valueChanged, this, &QmitkImageStatisticsView::UpdateIntensityProfile);
 }
 
 void QmitkImageStatisticsView::UpdateIntensityProfile()
 {
   m_Controls.groupBox_intensityProfile->setVisible(false);
 
   const auto selectedImageNodes = m_Controls.imageNodesSelector->GetSelectedNodes();
   const auto selectedROINodes = m_Controls.roiNodesSelector->GetSelectedNodes();
 
   if (selectedImageNodes.size()==1 && selectedROINodes.size()==1)
   { //only supported for one image and roi currently
     auto image = dynamic_cast<mitk::Image*>(selectedImageNodes.front()->GetData());
 
     auto maskPlanarFigure = dynamic_cast<mitk::PlanarFigure*>(selectedROINodes.front()->GetData());
 
     if (maskPlanarFigure != nullptr)
     {
       if (!maskPlanarFigure->IsClosed())
       {
         mitk::Image::Pointer inputImage;
         if (image->GetDimension() == 4)
         {
           m_Controls.sliderWidget_intensityProfile->setVisible(true);
           unsigned int maxTimestep = image->GetTimeSteps();
           m_Controls.sliderWidget_intensityProfile->setMaximum(maxTimestep - 1);
           // Intensity profile can only be calculated on 3D, so extract if 4D
           mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
           int currentTimestep = static_cast<int>(m_Controls.sliderWidget_intensityProfile->value());
           timeSelector->SetInput(image);
           timeSelector->SetTimeNr(currentTimestep);
           timeSelector->Update();
 
           inputImage = timeSelector->GetOutput();
         }
         else
         {
           m_Controls.sliderWidget_intensityProfile->setVisible(false);
           inputImage = image;
         }
 
         auto intensityProfile = mitk::ComputeIntensityProfile(inputImage, maskPlanarFigure);
         m_Controls.groupBox_intensityProfile->setVisible(true);
         m_Controls.widget_intensityProfile->Reset();
         m_Controls.widget_intensityProfile->SetIntensityProfile(intensityProfile.GetPointer(),
           "Intensity Profile of " + selectedImageNodes.front()->GetName());
       }
     }
   }
 }
 
 void QmitkImageStatisticsView::UpdateHistogramWidget()
 {
-  m_Controls.groupBox_histogram->setVisible(false);
+  bool visibility = false;
 
   const auto selectedImageNodes = m_Controls.imageNodesSelector->GetSelectedNodes();
   const auto selectedMaskNodes = m_Controls.roiNodesSelector->GetSelectedNodes();
 
   if (selectedImageNodes.size() == 1 && selectedMaskNodes.size()<=1)
   { //currently only supported for one image and roi due to histogram widget limitations.
     auto imageNode = selectedImageNodes.front();
     const mitk::DataNode* roiNode = nullptr;
     const mitk::PlanarFigure* planarFigure = nullptr;
     if (!selectedMaskNodes.empty())
     {
       roiNode = selectedMaskNodes.front();
       planarFigure = dynamic_cast<const mitk::PlanarFigure*>(roiNode->GetData());
     }
 
-    if (planarFigure == nullptr || planarFigure->IsClosed())
+    if ((planarFigure == nullptr || planarFigure->IsClosed())
+        && imageNode->GetData()->GetTimeGeometry()->IsValidTimePoint(m_TimePointChangeListener.GetCurrentSelectedTimePoint()))
     { //if a planar figure is not closed, we show the intensity profile instead of the histogram.
       auto statisticsNode = m_DataGenerator->GetLatestResult(imageNode, roiNode, true);
 
       if (statisticsNode.IsNotNull())
       {
         auto statistics = dynamic_cast<const mitk::ImageStatisticsContainer*>(statisticsNode->GetData());
 
         if (statistics)
         {
+          const auto timeStep = imageNode->GetData()->GetTimeGeometry()->TimePointToTimeStep(m_TimePointChangeListener.GetCurrentSelectedTimePoint());
+
           std::stringstream label;
-          label << "Histogram " << imageNode->GetName();
+          label << imageNode->GetName();
           if (imageNode->GetData()->GetTimeSteps() > 1)
           {
-            label << "[0]";
+            label << "["<< timeStep <<"]";
           }
 
           if (roiNode)
           {
             label << " with " << roiNode->GetName();
           }
 
-          m_Controls.widget_histogram->SetHistogram(statistics->GetHistogramForTimeStep(0), label.str());
+          //Hardcoded labels are currently needed because the current histogram widget (and ChartWidget)
+          //do not allow correct removal or sound update/insertion of serveral charts.
+          //only thing that works for now is always to update/overwrite the same data label
+          //This is a quick fix for T28223 and T28221
+          m_Controls.widget_histogram->SetHistogram(statistics->GetHistogramForTimeStep(timeStep), "histogram");
+
+          visibility = true;
         }
-        m_Controls.groupBox_histogram->setVisible(statisticsNode.IsNotNull());
       }
     }
   }
+
+  if (visibility != m_Controls.groupBox_histogram->isVisible())
+  {
+    m_Controls.groupBox_histogram->setVisible(visibility);
+  }
+
 }
 
 QmitkChartWidget::ColorTheme QmitkImageStatisticsView::GetColorTheme() const
 {
   ctkPluginContext *context = berry::WorkbenchPlugin::GetDefault()->GetPluginContext();
   ctkServiceReference styleManagerRef = context->getServiceReference<berry::IQtStyleManager>();
   if (styleManagerRef)
   {
     auto styleManager = context->getService<berry::IQtStyleManager>(styleManagerRef);
     if (styleManager->GetStyle().name == "Dark")
     {
       return QmitkChartWidget::ColorTheme::darkstyle;
     }
     else
     {
       return QmitkChartWidget::ColorTheme::lightstyle;
     }
   }
   return QmitkChartWidget::ColorTheme::darkstyle;
 }
 
 void QmitkImageStatisticsView::ResetGUI()
 {
   m_Controls.widget_statistics->Reset();
   m_Controls.widget_statistics->setEnabled(false);
   m_Controls.widget_histogram->Reset();
   m_Controls.widget_histogram->setEnabled(false);
   m_Controls.widget_histogram->SetTheme(GetColorTheme());
 }
 
 void QmitkImageStatisticsView::OnGenerationStarted(const mitk::DataNode* /*imageNode*/, const mitk::DataNode* /*roiNode*/, const QmitkDataGenerationJobBase* /*job*/)
 {
   m_Controls.label_currentlyComputingStatistics->setVisible(true);
 }
 
 void QmitkImageStatisticsView::OnGenerationFinished()
 {
   m_Controls.label_currentlyComputingStatistics->setVisible(false);
 
   mitk::StatusBar::GetInstance()->Clear();
 
   this->UpdateIntensityProfile();
   this->UpdateHistogramWidget();
 }
 
+void QmitkImageStatisticsView::OnSelectedTimePointChanged(mitk::TimePointType /*newTimePoint*/)
+{
+  this->UpdateHistogramWidget();
+}
+
 void QmitkImageStatisticsView::OnJobError(QString error, const QmitkDataGenerationJobBase* /*failedJob*/)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(error.toStdString().c_str());
   MITK_WARN << "Error when calculating statistics: " << error;
 }
 
 void QmitkImageStatisticsView::OnRequestHistogramUpdate(unsigned int nbins)
 {
   m_Controls.widget_statistics->SetHistogramNBins(nbins);
   m_DataGenerator->SetHistogramNBins(nbins);
   this->UpdateIntensityProfile();
   this->UpdateHistogramWidget();
 }
 
 void QmitkImageStatisticsView::OnCheckBoxIgnoreZeroStateChanged(int state)
 {
   auto ignoreZeroValueVoxel = (state == Qt::Unchecked) ? false : true;
   m_Controls.widget_statistics->SetIgnoreZeroValueVoxel(ignoreZeroValueVoxel);
   m_DataGenerator->SetIgnoreZeroValueVoxel(ignoreZeroValueVoxel);
   this->UpdateIntensityProfile();
   this->UpdateHistogramWidget();
 }
 
 void QmitkImageStatisticsView::OnImageSelectionChanged(QmitkAbstractNodeSelectionWidget::NodeList /*nodes*/)
 {
   auto images = m_Controls.imageNodesSelector->GetSelectedNodesStdVector();
   m_Controls.widget_statistics->SetImageNodes(images);
 
   m_Controls.widget_statistics->setEnabled(!images.empty());
 
   m_Controls.roiNodesSelector->SetNodePredicate(this->GenerateROIPredicate());
 
   m_DataGenerator->SetAutoUpdate(false);
   m_DataGenerator->SetImageNodes(images);
   m_DataGenerator->Generate();
   m_DataGenerator->SetAutoUpdate(true);
 
   this->UpdateHistogramWidget();
   this->UpdateIntensityProfile();
 }
 
 void QmitkImageStatisticsView::OnROISelectionChanged(QmitkAbstractNodeSelectionWidget::NodeList /*nodes*/)
 {
   auto rois = m_Controls.roiNodesSelector->GetSelectedNodesStdVector();
 
   m_Controls.widget_statistics->SetMaskNodes(rois);
 
   m_DataGenerator->SetAutoUpdate(false);
   m_DataGenerator->SetROINodes(rois);
   m_DataGenerator->Generate();
   m_DataGenerator->SetAutoUpdate(true);
 
   this->UpdateHistogramWidget();
   this->UpdateIntensityProfile();
 }
 
 
 void QmitkImageStatisticsView::OnButtonSelectionPressed()
 {
   QmitkNodeSelectionDialog* dialog = new QmitkNodeSelectionDialog(nullptr, "Select input for the statistic","You may select images and ROIs to compute their statistic. ROIs may be segmentations or planar figures.");
   dialog->SetDataStorage(GetDataStorage());
   dialog->SetSelectionCheckFunction(CheckForSameGeometry());
 
   // set predicates
   auto isPlanarFigurePredicate = mitk::GetImageStatisticsPlanarFigurePredicate();
   auto isMaskPredicate = mitk::GetImageStatisticsMaskPredicate();
   auto isImagePredicate = mitk::GetImageStatisticsImagePredicate();
   auto isMaskOrPlanarFigurePredicate = mitk::NodePredicateOr::New(isPlanarFigurePredicate, isMaskPredicate);
   auto isImageOrMaskOrPlanarFigurePredicate = mitk::NodePredicateOr::New(isMaskOrPlanarFigurePredicate, isImagePredicate);
   dialog->SetNodePredicate(isImageOrMaskOrPlanarFigurePredicate);
   dialog->SetSelectionMode(QAbstractItemView::MultiSelection);
   dialog->SetCurrentSelection(m_Controls.imageNodesSelector->GetSelectedNodes()+m_Controls.roiNodesSelector->GetSelectedNodes());
 
   if (dialog->exec())
   {
     auto selectedNodeList = dialog->GetSelectedNodes();
 
     m_Controls.imageNodesSelector->SetCurrentSelection(selectedNodeList);
     m_Controls.roiNodesSelector->SetCurrentSelection(selectedNodeList);
   }
 
   delete dialog;
 }
 
 QmitkNodeSelectionDialog::SelectionCheckFunctionType QmitkImageStatisticsView::CheckForSameGeometry() const
 {
   auto isMaskPredicate = mitk::GetImageStatisticsMaskPredicate();
 
   auto lambda = [isMaskPredicate](const QmitkNodeSelectionDialog::NodeList& nodes)
   {
     if (nodes.empty())
     {
       return std::string();
     }
 
     const mitk::Image* imageNodeData = nullptr;
     for (auto& node : nodes)
     {
       auto castedData = dynamic_cast<const mitk::Image*>(node->GetData());
       if (castedData != nullptr && !isMaskPredicate->CheckNode(node))
       {
         imageNodeData = castedData;
         break;
       }
     }
 
     if (imageNodeData == nullptr)
     {
       std::stringstream ss;
       ss << "<font class=\"warning\"><p>Select at least one image.</p></font>";
       return ss.str();
     }
 
     auto imageGeoPredicate = mitk::NodePredicateGeometry::New(imageNodeData->GetGeometry());
     auto maskGeoPredicate = mitk::NodePredicateSubGeometry::New(imageNodeData->GetGeometry());
 
     for (auto& rightNode : nodes)
     {
       if (imageNodeData != rightNode->GetData())
       {
         bool validGeometry = true;
 
         if (isMaskPredicate->CheckNode(rightNode))
         {
           validGeometry = maskGeoPredicate->CheckNode(rightNode);
         }
         else if (dynamic_cast<const mitk::Image*>(rightNode->GetData()))
         {
           validGeometry = imageGeoPredicate->CheckNode(rightNode);
         }
         else
         {
           const mitk::PlanarFigure* planar2 = dynamic_cast<const mitk::PlanarFigure*>(rightNode->GetData());
           if (planar2)
           {
             validGeometry = mitk::PlanarFigureMaskGenerator::CheckPlanarFigureIsNotTilted(planar2->GetPlaneGeometry(), imageNodeData->GetGeometry());
           }
         }
 
         if (!validGeometry)
         {
           std::stringstream ss;
           ss << "<font class=\"warning\"><p>Invalid selection: All selected nodes must have the same geometry.</p><p>Differing node i.a.: \"";
           ss << rightNode->GetName() <<"\"</p></font>";
           return ss.str();
         }
       }
     }
 
     return std::string();
   };
 
   return lambda;
 }
 
 mitk::NodePredicateBase::Pointer QmitkImageStatisticsView::GenerateROIPredicate() const
 {
   auto isPlanarFigurePredicate = mitk::GetImageStatisticsPlanarFigurePredicate();
   auto isMaskPredicate = mitk::GetImageStatisticsMaskPredicate();
   auto isMaskOrPlanarFigurePredicate = mitk::NodePredicateOr::New(isPlanarFigurePredicate, isMaskPredicate);
 
   mitk::NodePredicateBase::Pointer result = isMaskOrPlanarFigurePredicate.GetPointer();
 
   if(!m_Controls.imageNodesSelector->GetSelectedNodes().empty())
   {
     auto image = m_Controls.imageNodesSelector->GetSelectedNodes().front()->GetData();
     auto imageGeoPredicate = mitk::NodePredicateSubGeometry::New(image->GetGeometry());
 
     auto lambda = [image, imageGeoPredicate](const mitk::DataNode* node)
     {
       bool sameGeometry = true;
 
       if (dynamic_cast<const mitk::Image*>(node->GetData()) != nullptr)
       {
         sameGeometry = imageGeoPredicate->CheckNode(node);
       }
       else
       {
         const auto planar2 = dynamic_cast<const mitk::PlanarFigure*>(node->GetData());
         if (planar2)
         {
           sameGeometry = mitk::PlanarFigureMaskGenerator::CheckPlanarFigureIsNotTilted(planar2->GetPlaneGeometry(), image->GetGeometry());
         }
       }
 
       return sameGeometry;
     };
 
     result = mitk::NodePredicateAnd::New(isMaskOrPlanarFigurePredicate, mitk::NodePredicateFunction::New(lambda)).GetPointer();
   }
 
   return result;
 }
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.h b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.h
index c9f8dd618b..906c3d0f24 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.h
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.h
@@ -1,85 +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.
 
 ============================================================================*/
 
 #ifndef QMITKIMAGESTATISTICSVIEW_H
 #define QMITKIMAGESTATISTICSVIEW_H
 
 #include "ui_QmitkImageStatisticsViewControls.h"
 
 #include <QmitkAbstractView.h>
 #include <mitkImageStatisticsContainer.h>
 #include <QmitkNodeSelectionDialog.h>
+#include <QmitkSliceNavigationListener.h>
 
 #include <mitkPropertyRelations.h>
 
+#include <mitkIRenderWindowPartListener.h>
+
 class QmitkImageStatisticsDataGenerator;
 class QmitkDataGenerationJobBase;
 
 /*!
 \brief QmitkImageStatisticsView is a bundle that allows statistics calculation from images. Three modes
 are supported: 1. Statistics of one image, 2. Statistics of an image and a segmentation, 3. Statistics
 of an image and a Planar Figure. The statistics calculation is realized in a separate thread to keep the
 gui accessible during calculation.
 
 \ingroup Plugins/org.mitk.gui.qt.measurementtoolbox
 */
-class QmitkImageStatisticsView : public QmitkAbstractView
+class QmitkImageStatisticsView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   /*!
   \brief default destructor */
   ~QmitkImageStatisticsView() override;
+
+protected:
   /*!
   \brief Creates the widget containing the application controls, like sliders, buttons etc.*/
-  void CreateQtPartControl(QWidget *parent) override;
+  void CreateQtPartControl(QWidget* parent) override;
 
-protected:
+  void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
+  void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
 
   using HistogramType = mitk::ImageStatisticsContainer::HistogramType;
 
   void SetFocus() override { };
 
   virtual void CreateConnections();
 
   void UpdateIntensityProfile();
   void UpdateHistogramWidget();
 
   QmitkChartWidget::ColorTheme GetColorTheme() const;
 
   void ResetGUI();
 
   void OnGenerationStarted(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode, const QmitkDataGenerationJobBase* job);
   void OnGenerationFinished();
   void OnJobError(QString error, const QmitkDataGenerationJobBase* failedJob);
   void OnRequestHistogramUpdate(unsigned int);
   void OnCheckBoxIgnoreZeroStateChanged(int state);
   void OnButtonSelectionPressed();
   void OnImageSelectionChanged(QmitkAbstractNodeSelectionWidget::NodeList nodes);
   void OnROISelectionChanged(QmitkAbstractNodeSelectionWidget::NodeList nodes);
+  void OnSelectedTimePointChanged(mitk::TimePointType newTimePoint);
 
   // member variable
   Ui::QmitkImageStatisticsViewControls m_Controls;
 
 private:
   QmitkNodeSelectionDialog::SelectionCheckFunctionType CheckForSameGeometry() const;
   mitk::NodePredicateBase::Pointer GenerateROIPredicate() const;
 
   std::vector<mitk::ImageStatisticsContainer::ConstPointer> m_StatisticsForSelection;
   QmitkImageStatisticsDataGenerator* m_DataGenerator = nullptr;
+
+  QmitkSliceNavigationListener m_TimePointChangeListener;
+
 };
 
 #endif // QMITKIMAGESTATISTICSVIEW_H