diff --git a/Modules/IGT/DataManagement/mitkNavigationTool.cpp b/Modules/IGT/DataManagement/mitkNavigationTool.cpp
index 24b7dc669a..915e9cb4d3 100644
--- a/Modules/IGT/DataManagement/mitkNavigationTool.cpp
+++ b/Modules/IGT/DataManagement/mitkNavigationTool.cpp
@@ -1,180 +1,180 @@
 /*===================================================================
 
 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 "mitkNavigationTool.h"
 #include "mitkIGTException.h"
 #include "mitkNavigationData.h"
 #include "Poco/File.h"
 #include "mitkUnspecifiedTrackingTypeInformation.h"
 #include "mitkInternalTrackingTool.h"
 
 mitk::NavigationTool::NavigationTool() : m_Identifier("None"),
 m_Type(mitk::NavigationTool::Unknown),
 m_CalibrationFile("none"),
 m_SerialNumber(""),
 m_TrackingDeviceType(mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName()),
 m_ToolRegistrationLandmarks(mitk::PointSet::New()),
 m_ToolCalibrationLandmarks(mitk::PointSet::New()),
 m_ToolTipOrientation(mitk::Quaternion(0, 0, 0, 1))
 {
   m_ToolTipPosition[0] = 0;
   m_ToolTipPosition[1] = 0;
   m_ToolTipPosition[2] = 0;
 
   m_ToolAxis[0] = 1;
   m_ToolAxis[1] = 0;
   m_ToolAxis[2] = 0;
 }
 
 itk::LightObject::Pointer mitk::NavigationTool::InternalClone() const
 {
   Self::Pointer tool = new Self(*this);
   tool->UnRegister();
   return tool.GetPointer();
 }
 
 mitk::NavigationTool::NavigationTool(const NavigationTool &other)
   : Superclass()
 {
   this->m_Identifier = other.m_Identifier;
   this->m_Type = other.m_Type;
   if (other.m_DataNode.IsNotNull())
   {
     this->m_DataNode = other.m_DataNode->Clone();
     if (other.m_DataNode->GetData())
-      this->m_DataNode->SetData(other.m_DataNode->GetData());
+      this->m_DataNode->SetData(dynamic_cast<mitk::BaseData*>(other.m_DataNode->GetData()->Clone().GetPointer()));
   }
 
   if (other.m_SpatialObject.IsNotNull())
     this->m_SpatialObject = other.m_SpatialObject->Clone();
   this->m_CalibrationFile = other.m_CalibrationFile;
   this->m_SerialNumber = other.m_SerialNumber;
   this->m_TrackingDeviceType = other.m_TrackingDeviceType;
   if (other.m_ToolRegistrationLandmarks.IsNotNull())
     this->m_ToolRegistrationLandmarks = other.m_ToolRegistrationLandmarks->Clone();
   if (other.m_ToolCalibrationLandmarks.IsNotNull())
     this->m_ToolCalibrationLandmarks = other.m_ToolCalibrationLandmarks->Clone();
   this->m_ToolTipPosition = other.m_ToolTipPosition;
   this->m_ToolTipOrientation = other.m_ToolTipOrientation;
   this->m_ToolAxis = other.m_ToolAxis;
 }
 
 mitk::NavigationTool::~NavigationTool()
 {
 }
 
 mitk::AffineTransform3D::Pointer mitk::NavigationTool::GetToolTipTransform()
 {
   mitk::NavigationData::Pointer returnValue = mitk::NavigationData::New();
   returnValue->SetPosition(this->m_ToolTipPosition);
   returnValue->SetOrientation(this->m_ToolTipOrientation);
   return returnValue->GetAffineTransform3D();
 }
 
 void mitk::NavigationTool::Graft(const DataObject *data)
 {
   // Attempt to cast data to an NavigationData
   const Self* nd;
   try
   {
     nd = dynamic_cast<const Self *>(data);
   }
   catch (...)
   {
     mitkThrowException(mitk::IGTException) << "mitk::NavigationData::Graft cannot cast "
       << typeid(data).name() << " to "
       << typeid(const Self *).name();
   }
   if (!nd)
   {
     // pointer could not be cast back down
     mitkThrowException(mitk::IGTException) << "mitk::NavigationData::Graft cannot cast "
       << typeid(data).name() << " to "
       << typeid(const Self *).name();
   }
   // Now copy anything that is needed
   m_Identifier = nd->GetIdentifier();
   m_Type = nd->GetType();
   m_DataNode->SetName(nd->GetDataNode()->GetName());
   m_DataNode->SetData(nd->GetDataNode()->GetData());
   m_SpatialObject = nd->GetSpatialObject();
   m_CalibrationFile = nd->GetCalibrationFile();
   m_SerialNumber = nd->GetSerialNumber();
   m_TrackingDeviceType = nd->GetTrackingDeviceType();
   m_ToolRegistrationLandmarks = nd->GetToolRegistrationLandmarks();
   m_ToolCalibrationLandmarks = nd->GetToolCalibrationLandmarks();
   m_ToolTipPosition = nd->GetToolTipPosition();
   m_ToolTipOrientation = nd->GetToolTipOrientation();
   m_ToolAxis = nd->GetToolAxis();
 }
 
 bool mitk::NavigationTool::IsToolTipSet()
 {
   if ((m_ToolTipPosition[0] == 0) &&
     (m_ToolTipPosition[1] == 0) &&
     (m_ToolTipPosition[2] == 0) &&
     (m_ToolTipOrientation.x() == 0) &&
     (m_ToolTipOrientation.y() == 0) &&
     (m_ToolTipOrientation.z() == 0) &&
     (m_ToolTipOrientation.r() == 1))
     return false;
   else return true;
 }
 
 void mitk::NavigationTool::SetCalibrationFile(const std::string filename)
 {
   //check if file does exist:
   if (filename == "")
   {
     m_CalibrationFile = "none";
   }
   else
   {
     Poco::File myFile(filename);
     if (myFile.exists())
       m_CalibrationFile = filename;
     else
       m_CalibrationFile = "none";
   }
 }
 
 std::string mitk::NavigationTool::GetToolName()
 {
   if (this->m_DataNode.IsNull()) { return ""; }
   else { return m_DataNode->GetName(); }
 }
 
 mitk::Surface::Pointer mitk::NavigationTool::GetToolSurface()
 {
   if (this->m_DataNode.IsNull()) { return nullptr; }
   else if (this->m_DataNode->GetData() == nullptr) { return nullptr; }
   else { return dynamic_cast<mitk::Surface*>(m_DataNode->GetData()); }
 }
 
 std::string mitk::NavigationTool::GetStringWithAllToolInformation() const
 {
   std::stringstream _info;
   _info << "  Identifier: " << this->m_Identifier << "\n"
     << "  NavigationToolType: " << m_Type << "\n"
     << "  Calibration file: " << m_CalibrationFile << "\n"
     << "  Serial number: " << m_SerialNumber << "\n"
     << "  TrackingDeviceType: " << m_TrackingDeviceType << "\n"
     << "  ToolTip Position: " << m_ToolTipPosition << "\n"
     << "  ToolTip Orientation: " << m_ToolTipOrientation << "\n"
     << "  ToolTip Axis: " << m_ToolAxis;
 
   return _info.str();
 }
\ No newline at end of file
diff --git a/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.cpp
index 4985f541f4..1326a400bd 100644
--- a/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.cpp
@@ -1,276 +1,302 @@
 /*===================================================================
 
 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 "QmitkInteractiveTransformationWidget.h"
 
 // mitk includes
 #include "mitkRenderingManager.h"
+#include "mitkBaseRenderer.h"
 #include "mitkNavigationData.h"
 
 // vtk includes
 #include "vtkMatrix4x4.h"
 #include "vtkLinearTransform.h"
 
 const std::string QmitkInteractiveTransformationWidget::VIEW_ID = "org.mitk.views.interactivetransformationwidget";
 
 QmitkInteractiveTransformationWidget::QmitkInteractiveTransformationWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f), m_Controls(nullptr), m_Geometry(nullptr)
 {
   CreateQtPartControl(this);
   CreateConnections();
 
   m_ResetGeometry = mitk::Geometry3D::New();
 }
 
 QmitkInteractiveTransformationWidget::~QmitkInteractiveTransformationWidget()
 {
 }
 
 void QmitkInteractiveTransformationWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkInteractiveTransformationWidgetControls;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkInteractiveTransformationWidget::CreateConnections()
 {
   if (m_Controls)
   {
     // translations
     connect(m_Controls->m_XTransSpinBox, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this, &QmitkInteractiveTransformationWidget::OnXTranslationValueChanged);
     connect(m_Controls->m_XTransSlider, &QSlider::valueChanged, this, &QmitkInteractiveTransformationWidget::OnXTranslationValueChanged);
 
     connect(m_Controls->m_YTransSpinBox, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this, &QmitkInteractiveTransformationWidget::OnYTranslationValueChanged);
     connect(m_Controls->m_YTransSlider, &QSlider::valueChanged, this, &QmitkInteractiveTransformationWidget::OnYTranslationValueChanged);
 
     connect(m_Controls->m_ZTransSpinBox, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this, &QmitkInteractiveTransformationWidget::OnZTranslationValueChanged);
     connect(m_Controls->m_ZTransSlider, &QSlider::valueChanged, this, &QmitkInteractiveTransformationWidget::OnZTranslationValueChanged);
 
     // rotations
     connect(m_Controls->m_XRotSpinBox, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this, &QmitkInteractiveTransformationWidget::OnXRotationValueChanged);
     connect(m_Controls->m_XRotSlider, &QSlider::valueChanged, this, &QmitkInteractiveTransformationWidget::OnXRotationValueChanged);
 
     connect(m_Controls->m_YRotSpinBox, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this, &QmitkInteractiveTransformationWidget::OnYRotationValueChanged);
     connect(m_Controls->m_YRotSlider, &QSlider::valueChanged, this, &QmitkInteractiveTransformationWidget::OnYRotationValueChanged);
 
     connect(m_Controls->m_ZRotSpinBox, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this, &QmitkInteractiveTransformationWidget::OnZRotationValueChanged);
     connect(m_Controls->m_ZRotSlider, &QSlider::valueChanged, this, &QmitkInteractiveTransformationWidget::OnZRotationValueChanged);
 
     connect((QObject*)(m_Controls->m_ResetPB), SIGNAL(clicked()), this, SLOT(OnResetGeometryToIdentity()));
     connect((QObject*)(m_Controls->m_RevertChanges), SIGNAL(clicked()), this, SLOT(OnRevertChanges()));
     connect((QObject*)(m_Controls->m_UseManipulatedToolTipPB), SIGNAL(clicked()), this, SLOT(OnApplyManipulatedToolTip()));
     connect((QObject*)(m_Controls->m_Cancel), SIGNAL(clicked()), this, SLOT(OnCancel()));
   }
 }
 
-void QmitkInteractiveTransformationWidget::SetGeometryPointer(mitk::BaseGeometry::Pointer geometry)
+void QmitkInteractiveTransformationWidget::SetToolToEdit(const mitk::NavigationTool::Pointer _tool)
 {
-  m_Geometry = geometry;
-  //For ResetGeometry, use the set-fuction via vtk matrix, 'cause this garantees a deep copy and not just sharing a pointer.
-  m_ResetGeometry->SetIndexToWorldTransformByVtkMatrix(geometry->GetVtkMatrix()); //Remember the original values to be able to reset and abort everything
+  m_ToolToEdit = _tool->Clone();
+  mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetDataStorage()
+    ->Add(m_ToolToEdit->GetDataNode());
+  m_ToolToEdit->GetDataNode()->SetName("Tool Tip to be edited");
+
+  //change color to red
+  m_ToolToEdit->GetDataNode()->SetProperty("color", mitk::ColorProperty::New(1, 0, 0));
+
+  //use the set-fuction via vtk matrix, 'cause this garantees a deep copy and not just sharing a pointer.
+  m_Geometry = m_ToolToEdit->GetDataNode()->GetData()->GetGeometry();
+  m_ResetGeometry->SetIndexToWorldTransformByVtkMatrix(m_Geometry->GetVtkMatrix()); //Remember the original values to be able to reset and abort everything
+}
+
+void QmitkInteractiveTransformationWidget::SetDefaultOffset(const mitk::Point3D _defaultValues)
+{
+  m_Geometry->SetOrigin(_defaultValues);
+  m_ResetGeometry->SetOrigin(_defaultValues); //Remember the original values to be able to reset and abort everything
+  SetValuesToGUI(m_Geometry->GetIndexToWorldTransform());
 }
 
-void QmitkInteractiveTransformationWidget::SetGeometryDefaultValues(const mitk::AffineTransform3D::Pointer _defaultValues)
+void QmitkInteractiveTransformationWidget::SetDefaultRotation(const mitk::Quaternion _defaultValues)
 {
-  m_Geometry->SetIndexToWorldTransform(_defaultValues);
+  // Conversion to navigation data / transform
+  mitk::NavigationData::Pointer rotationTransform = mitk::NavigationData::New(m_Geometry->GetIndexToWorldTransform());
+  rotationTransform->SetOrientation(_defaultValues);
+  m_Geometry->SetIndexToWorldTransform(rotationTransform->GetAffineTransform3D());
+
   //For ResetGeometry, use the set-fuction via vtk matrix, 'cause this garantees a deep copy and not just sharing a pointer.
   m_ResetGeometry->SetIndexToWorldTransformByVtkMatrix(m_Geometry->GetVtkMatrix()); //Remember the original values to be able to reset and abort everything
-  SetValuesToGUI(_defaultValues);
+  SetValuesToGUI(m_Geometry->GetIndexToWorldTransform());
 }
 
 void QmitkInteractiveTransformationWidget::SetValuesToGUI(const mitk::AffineTransform3D::Pointer _defaultValues)
 {
 
   //Set toolTip values in gui
   m_Controls->m_XTransSlider->setValue(_defaultValues->GetOffset()[0]);
   m_Controls->m_YTransSlider->setValue(_defaultValues->GetOffset()[1]);
   m_Controls->m_ZTransSlider->setValue(_defaultValues->GetOffset()[2]);
 
   //first: some conversion
   mitk::NavigationData::Pointer transformConversionHelper = mitk::NavigationData::New(_defaultValues);
   double eulerAlphaDegrees = transformConversionHelper->GetOrientation().rotation_euler_angles()[0] / vnl_math::pi * 180;
   double eulerBetaDegrees = transformConversionHelper->GetOrientation().rotation_euler_angles()[1] / vnl_math::pi * 180;
   double eulerGammaDegrees = transformConversionHelper->GetOrientation().rotation_euler_angles()[2] / vnl_math::pi * 180;
 
   m_Controls->m_XRotSpinBox->setValue(eulerAlphaDegrees);
   m_Controls->m_YRotSpinBox->setValue(eulerBetaDegrees);
   m_Controls->m_ZRotSpinBox->setValue(eulerGammaDegrees);
 
   //Update view
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 // Section to allow interactive positioning of the moving surface
 /////////////////////////////////////////////////////////////////////////////////////////////
 
 void QmitkInteractiveTransformationWidget::OnXTranslationValueChanged(double v)
 {
   this->blockSignals(true);//block signals to avoid loop between slider and spinbox. Unblock at the end of the function!
 
   //Set values to member variable
   mitk::Point3D translationParams = m_Geometry->GetOrigin();
   translationParams[0] = v;
   m_Geometry->SetOrigin(translationParams);
 
   //Update Gui (change may come either from spin box or from slider)
   m_Controls->m_XTransSlider->setValue(v);
   m_Controls->m_XTransSpinBox->setValue(v);
 
   //Update view
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->blockSignals(false);//unblock signals. See above, don't remove this line. Unblock at the end of the function!
 }
 
 void QmitkInteractiveTransformationWidget::OnYTranslationValueChanged(double v)
 {
   this->blockSignals(true);//block signals to avoid loop between slider and spinbox. Unblock at the end of the function!
 
   //Set values to member variable
   mitk::Point3D translationParams = m_Geometry->GetOrigin();
   translationParams[1] = v;
   m_Geometry->SetOrigin(translationParams);
 
   //Update Gui (change may come either from spin box or from slider)
   m_Controls->m_YTransSlider->setValue(v);
   m_Controls->m_YTransSpinBox->setValue(v);
 
   //Update view
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->blockSignals(false);//unblock signals. See above, don't remove this line. Unblock at the end of the function!
 }
 
 void QmitkInteractiveTransformationWidget::OnZTranslationValueChanged(double v)
 {
   this->blockSignals(true);//block signals to avoid loop between slider and spinbox. Unblock at the end of the function!
 
   //Set values to member variable
   mitk::Point3D translationParams = m_Geometry->GetOrigin();
   translationParams[2] = v;
   m_Geometry->SetOrigin(translationParams);
 
   //Update Gui (change may come either from spin box or from slider)
   m_Controls->m_ZTransSlider->setValue(v);
   m_Controls->m_ZTransSpinBox->setValue(v);
 
   //Update view
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->blockSignals(false);//unblock signals. See above, don't remove this line. Unblock at the end of the function!
 }
 
 void QmitkInteractiveTransformationWidget::OnXRotationValueChanged(double v)
 {
   this->blockSignals(true);//block signals to avoid loop between slider and spinbox. Unblock at the end of the function!
   mitk::Vector3D rotationParams;
   rotationParams[0] = v;
   rotationParams[1] = m_Controls->m_YRotSlider->value();
   rotationParams[2] = m_Controls->m_ZRotSlider->value();
 
   //Update Gui (change may come either from spin box or from slider)
   m_Controls->m_XRotSlider->setValue(v);
   m_Controls->m_XRotSpinBox->setValue(v);
 
   this->Rotate(rotationParams);
   this->blockSignals(false);//unblock signals. See above, don't remove this line. Unblock at the end of the function!
 }
 
 void QmitkInteractiveTransformationWidget::OnYRotationValueChanged(double v)
 {
   this->blockSignals(true);//block signals to avoid loop between slider and spinbox. Unblock at the end of the function!
   mitk::Vector3D rotationParams;
   rotationParams[0] = m_Controls->m_XRotSlider->value();
   rotationParams[1] = v;
   rotationParams[2] = m_Controls->m_ZRotSlider->value();
 
   //Update Gui (change may come either from spin box or from slider)
   m_Controls->m_YRotSlider->setValue(v);
   m_Controls->m_YRotSpinBox->setValue(v);
 
   this->Rotate(rotationParams);
   this->blockSignals(false);//unblock signals. See above, don't remove this line. Unblock at the end of the function!
 }
 
 void QmitkInteractiveTransformationWidget::OnZRotationValueChanged(double v)
 {
   this->blockSignals(true);//block signals to avoid loop between slider and spinbox. Unblock at the end of the function!
   mitk::Vector3D rotationParams;
   rotationParams[0] = m_Controls->m_XRotSlider->value();
   rotationParams[1] = m_Controls->m_YRotSlider->value();
   rotationParams[2] = v;
 
   //Update Gui (change may come either from spin box or from slider)
   m_Controls->m_ZRotSlider->setValue(v);
   m_Controls->m_ZRotSpinBox->setValue(v);
 
   this->Rotate(rotationParams);
   this->blockSignals(false);//unblock signals. See above, don't remove this line. Unblock at the end of the function!
 }
 
 void QmitkInteractiveTransformationWidget::Rotate(mitk::Vector3D rotateVector)
 {
   //0: from degrees to radians
   double radianX = rotateVector[0] * vnl_math::pi / 180;
   double radianY = rotateVector[1] * vnl_math::pi / 180;
   double radianZ = rotateVector[2] * vnl_math::pi / 180;
 
   //1: from euler angles to quaternion
   mitk::Quaternion rotation(radianX, radianY, radianZ);
 
   //2: Conversion to navigation data / transform
   mitk::NavigationData::Pointer rotationTransform = mitk::NavigationData::New(m_Geometry->GetIndexToWorldTransform());
   rotationTransform->SetOrientation(rotation);
 
   m_Geometry->SetIndexToWorldTransform(rotationTransform->GetAffineTransform3D());
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkInteractiveTransformationWidget::OnResetGeometryToIdentity()
 {
   // reset the input to its initial state.
   m_Geometry->SetIdentity();
 
   //Update Sliders
   this->SetValuesToGUI(m_Geometry->GetIndexToWorldTransform());
   //Refresh view
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkInteractiveTransformationWidget::OnRevertChanges()
 {
   // reset the input to its initial state.
   m_Geometry->SetIndexToWorldTransformByVtkMatrix(m_ResetGeometry->GetVtkMatrix());
 
   //Update Sliders
   this->SetValuesToGUI(m_Geometry->GetIndexToWorldTransform());
   //Refresh view
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkInteractiveTransformationWidget::OnApplyManipulatedToolTip()
 {
+  mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetDataStorage()
+    ->Remove(m_ToolToEdit->GetDataNode());
+
   mitk::AffineTransform3D::Pointer toolTip = m_Geometry->GetIndexToWorldTransform();
   emit EditToolTipFinished(toolTip);
 }
 
 void QmitkInteractiveTransformationWidget::OnCancel()
 {
+  mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetDataStorage()
+    ->Remove(m_ToolToEdit->GetDataNode());
+
   emit EditToolTipFinished(nullptr);
 }
\ No newline at end of file
diff --git a/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h b/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h
index 25101a6646..26877b9d63 100644
--- a/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h
@@ -1,90 +1,99 @@
 /*===================================================================
 
 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 QmitkInteractiveTransformationWidget_H
 #define QmitkInteractiveTransformationWidget_H
 
 //QT headers
 #include <QWidget>
 
 //Mitk headers
 #include "MitkIGTUIExports.h"
 #include "mitkVector.h"
 #include "mitkGeometry3D.h"
+#include "mitkNavigationTool.h"
 
 //ui header
 #include "ui_QmitkInteractiveTransformationWidgetControls.h"
 
  /** Documentation:
   *   \brief An object of this class offers an UI to create a widget to access the advance tool creation options.
   *
   *
   *   \ingroup IGTUI
   */
 class MITKIGTUI_EXPORT QmitkInteractiveTransformationWidget : public QWidget
 {
   Q_OBJECT
 
   public:
     static const std::string VIEW_ID;
 
     QmitkInteractiveTransformationWidget(QWidget* parent = nullptr, Qt::WindowFlags f = nullptr);
     ~QmitkInteractiveTransformationWidget();
 
-    /** Sets the geometry which will be modified by this widget. Default values may be
-     *  provided by the second variable. These values will be applied to the geometry
-     *  in the beginning and the UI will also hold these values.
+    /** This tool will be copied to m_ToolToEdit. It will not be changed.
+        To apply any changes made by this widget, you will need to connect to the signal
+        EditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip) and set this transfrom
+        as calibrated tool tip.
+        We do not directly modify the tool to allow to cancel/exit this widget without doing
+        any harm.
      */
-    void SetGeometryPointer(mitk::BaseGeometry::Pointer geometry);
+    void SetToolToEdit(const mitk::NavigationTool::Pointer _tool);
 
-    void SetGeometryDefaultValues(const mitk::AffineTransform3D::Pointer _defaultValues);
+    /** The sliders and spinboxes will be set to these values.
+        When clicking "Revert Changes", sliders will be reseted to these values.
+    */
+    void SetDefaultOffset(const mitk::Point3D _defaultValues);
+    void SetDefaultRotation(const mitk::Quaternion _defaultValues);
 
   protected slots:
     void OnZTranslationValueChanged( double v );
     void OnYTranslationValueChanged(double v);
     void OnXTranslationValueChanged(double v);
     void OnZRotationValueChanged(double v);
     void OnYRotationValueChanged(double v);
     void OnXRotationValueChanged(double v);
     void OnResetGeometryToIdentity();
     void OnRevertChanges();
     void OnApplyManipulatedToolTip();
     void OnCancel();
 
 signals:
     void EditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip);
 
   protected:
 
     virtual void CreateConnections();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     /*! \brief Method performs the rotation.
     \params rotateVector New rotation to be combined with geometry. */
     void Rotate(mitk::Vector3D rotateVector);
 
     // Member variables
     Ui::QmitkInteractiveTransformationWidgetControls* m_Controls;
 
+    mitk::NavigationTool::Pointer m_ToolToEdit;     ///< \brief this mamber holds a copy of the tool that should be edited for visualization
     mitk::BaseGeometry::Pointer m_Geometry;         ///< \brief The geometry that is manipulated
     mitk::BaseGeometry::Pointer m_ResetGeometry;    ///< \brief Lifeline to reset to the original geometry
 
 private:
   void SetValuesToGUI(const mitk::AffineTransform3D::Pointer _defaultValues);
 
 };
 #endif // QmitkInteractiveTransformationWidget_H