diff --git a/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.cpp
index ac30eb6820..622d866814 100644
--- a/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.cpp
@@ -1,307 +1,289 @@
 /*===================================================================
 
 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::SetToolToEdit(const mitk::NavigationTool::Pointer _tool)
 {
   //If there is already a tool, remove it's node first.
   if (m_ToolToEdit)
     mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetDataStorage()
     ->Remove(m_ToolToEdit->GetDataNode());
 
   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::SetDefaultRotation(const mitk::Quaternion _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(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::SetSynchronizedVauesToSliderAndSpinbox(QDoubleSpinBox* _spinbox, QSlider* _slider, double _value)
+{
+//block signals to avoid loop between slider and spinbox. Unblock at the end of the function!
+  _spinbox->blockSignals(true);
+  _slider->blockSignals(true);
+  _spinbox->setValue(_value);
+  _slider->setValue(_value);
+//unblock signals. See above, don't remove this line. Unblock at the end of the function!
+  _spinbox->blockSignals(false);//
+  _slider->blockSignals(false);//
+}
 
 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);
+  SetSynchronizedVauesToSliderAndSpinbox(m_Controls->m_XTransSpinBox, m_Controls->m_XTransSlider, 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);
+  SetSynchronizedVauesToSliderAndSpinbox(m_Controls->m_YTransSpinBox, m_Controls->m_YTransSlider, 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);
+  SetSynchronizedVauesToSliderAndSpinbox(m_Controls->m_ZTransSpinBox, m_Controls->m_ZTransSlider, 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();
+  rotationParams[1] = m_Controls->m_YRotSpinBox->value();
+  rotationParams[2] = m_Controls->m_ZRotSpinBox->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);
+  SetSynchronizedVauesToSliderAndSpinbox(m_Controls->m_XRotSpinBox, m_Controls->m_XRotSlider, 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[0] = m_Controls->m_XRotSpinBox->value();
   rotationParams[1] = v;
-  rotationParams[2] = m_Controls->m_ZRotSlider->value();
+  rotationParams[2] = m_Controls->m_ZRotSpinBox->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);
+  SetSynchronizedVauesToSliderAndSpinbox(m_Controls->m_YRotSpinBox, m_Controls->m_YRotSlider, 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[0] = m_Controls->m_XRotSpinBox->value();
+  rotationParams[1] = m_Controls->m_YRotSpinBox->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);
+  SetSynchronizedVauesToSliderAndSpinbox(m_Controls->m_ZRotSpinBox, m_Controls->m_ZRotSlider, 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 26877b9d63..869f3bacec 100644
--- a/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h
@@ -1,99 +1,100 @@
 /*===================================================================
 
 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();
 
     /** 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 SetToolToEdit(const mitk::NavigationTool::Pointer _tool);
 
     /** 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);
+  void SetSynchronizedVauesToSliderAndSpinbox(QDoubleSpinBox* _spinbox, QSlider* _slider, double _value);
 
 };
 #endif // QmitkInteractiveTransformationWidget_H
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
index b2b8c56450..ddf002e3d3 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
@@ -1,392 +1,406 @@
 /*===================================================================
 
 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 "QmitkNavigationToolCreationWidget.h"
 
 //mitk headers
 #include <mitkTrackingTypes.h>
 #include <mitkSurface.h>
 #include <mitkNavigationData.h>
 #include <mitkRenderingManager.h>
 #include "mitkTrackingDeviceTypeCollection.h"
 
 //qt headers
 #include <qfiledialog.h>
 #include <qmessagebox.h>
 #include <mitkIOUtil.h>
 #include <QmitkIGTCommonHelper.h>
 #include <QDialogButtonBox>
 
 //poco headers
 #include <Poco/Path.h>
 
 // vtk
 #include <vtkSphereSource.h>
 #include <vtkConeSource.h>
 
 const std::string QmitkNavigationToolCreationWidget::VIEW_ID = "org.mitk.views.navigationtoolcreationwizardwidget";
 
 QmitkNavigationToolCreationWidget::QmitkNavigationToolCreationWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f)
 {
   m_ToolToBeEdited = mitk::NavigationTool::New();
   m_FinalTool = mitk::NavigationTool::New();
   m_ToolTransformationWidget = new QmitkInteractiveTransformationWidget();
 
   m_Controls = NULL;
   CreateQtPartControl(this);
   CreateConnections();
 
   this->InitializeUIToolLandmarkLists();
   Initialize(nullptr, "");
 
   //Default values, which are not stored in tool
   m_Controls->m_CalibrationFileName->setText("none");
   m_Controls->m_Surface_Use_Sphere->setChecked(true);
 
   m_Controls->m_CalibrationLandmarksList->EnableEditButton(false);
   m_Controls->m_RegistrationLandmarksList->EnableEditButton(false);
 
   RefreshTrackingDeviceCollection();
 }
 
 QmitkNavigationToolCreationWidget::~QmitkNavigationToolCreationWidget()
 {
   m_Controls->m_CalibrationLandmarksList->SetPointSetNode(NULL);
   m_Controls->m_RegistrationLandmarksList->SetPointSetNode(NULL);
   delete m_ToolTransformationWidget;
 }
 
 void QmitkNavigationToolCreationWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNavigationToolCreationWidgetControls;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkNavigationToolCreationWidget::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject*)(m_Controls->m_TrackingDeviceTypeChooser), SIGNAL(currentIndexChanged(int)), this, SLOT(GetValuesFromGuiElements()));
     connect((QObject*)(m_Controls->m_ToolNameEdit), SIGNAL(textChanged(const QString)), this, SLOT(GetValuesFromGuiElements()));
     connect((QObject*)(m_Controls->m_ToolTypeChooser), SIGNAL(currentIndexChanged(int)), this, SLOT(GetValuesFromGuiElements()));
     connect((QObject*)(m_Controls->m_IdentifierEdit), SIGNAL(textChanged(const QString)), this, SLOT(GetValuesFromGuiElements()));
     connect((QObject*)(m_Controls->m_SerialNumberEdit), SIGNAL(textChanged(const QString)), this, SLOT(GetValuesFromGuiElements()));
     connect((QObject*)(m_Controls->m_ToolAxisX), SIGNAL(valueChanged(int)), this, SLOT(GetValuesFromGuiElements()));
     connect((QObject*)(m_Controls->m_ToolAxisY), SIGNAL(valueChanged(int)), this, SLOT(GetValuesFromGuiElements()));
     connect((QObject*)(m_Controls->m_ToolAxisZ), SIGNAL(valueChanged(int)), this, SLOT(GetValuesFromGuiElements()));
 
     //Buttons
     connect((QObject*)(m_Controls->m_LoadCalibrationFile), SIGNAL(clicked()), this, SLOT(OnLoadCalibrationFile()));
     connect(m_Controls->m_Surface_Use_Other, SIGNAL(toggled(bool)), this, SLOT(OnSurfaceUseOtherToggled()));
     connect((QObject*)(m_Controls->m_LoadSurface), SIGNAL(clicked()), this, SLOT(OnLoadSurface()));
     connect((QObject*)(m_Controls->m_EditToolTip), SIGNAL(clicked()), this, SLOT(OnEditToolTip()));
 
     connect((QObject*)(m_ToolTransformationWidget), SIGNAL(EditToolTipFinished(mitk::AffineTransform3D::Pointer)), this,
       SLOT(OnEditToolTipFinished(mitk::AffineTransform3D::Pointer)));
 
     connect((QObject*)(m_Controls->m_cancel), SIGNAL(clicked()), this, SLOT(OnCancel()));
     connect((QObject*)(m_Controls->m_finished), SIGNAL(clicked()), this, SLOT(OnFinished()));
   }
 }
 
 void QmitkNavigationToolCreationWidget::Initialize(mitk::DataStorage* dataStorage, const std::string& supposedIdentifier, const std::string& supposedName)
 {
   m_DataStorage = dataStorage;
   //initialize UI components
   m_Controls->m_SurfaceChooser->SetDataStorage(m_DataStorage);
   m_Controls->m_SurfaceChooser->SetAutoSelectNewItems(true);
   m_Controls->m_SurfaceChooser->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
 
   //Create new tool, which should be edited/created
   m_ToolToBeEdited = nullptr;//Reset
   m_ToolToBeEdited = mitk::NavigationTool::New();//Reinitialize
   m_ToolToBeEdited->SetIdentifier(supposedIdentifier);
 
   //Create the default cone surface. Can be changed later on...
   //create DataNode...
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetName(supposedName);
   m_ToolToBeEdited->SetDataNode(newNode);
 
   SetConeAsToolSurface();
 
   this->SetDefaultData(m_ToolToBeEdited);
 }
 
 void QmitkNavigationToolCreationWidget::SetConeAsToolSurface()
 {
   //create small cone and use it as surface
   mitk::Surface::Pointer mySphere = mitk::Surface::New();
   vtkConeSource *vtkData = vtkConeSource::New();
   vtkData->SetAngle(5.0);
   vtkData->SetResolution(50);
   vtkData->SetHeight(6.0f);
   vtkData->SetRadius(2.0f);
   vtkData->SetCenter(0.0, 0.0, 0.0);
   vtkData->Update();
   mySphere->SetVtkPolyData(vtkData->GetOutput());
   vtkData->Delete();
   m_ToolToBeEdited->GetDataNode()->SetData(mySphere);
 }
 
 void QmitkNavigationToolCreationWidget::SetDefaultData(mitk::NavigationTool::Pointer DefaultTool)
 {
   //Set Members. This can either be the new initialized tool from call of Initialize() or a tool which already exists in the toolStorage
   m_ToolToBeEdited = DefaultTool->Clone();
 
   //Set all gui variables
   SetGuiElements();
 }
 
 void QmitkNavigationToolCreationWidget::SetGuiElements()
 {
-  //Block signals, so that we don't call SetGuiElements again. This is undone at the end o this function!
-  this->blockSignals(true);
+  //Block signals, so that we don't call SetGuiElements again. This is undone at the end of this function!
+  m_Controls->m_TrackingDeviceTypeChooser->blockSignals(true);
+  m_Controls->m_ToolNameEdit->blockSignals(true);
+  m_Controls->m_ToolTypeChooser->blockSignals(true);
+  m_Controls->m_IdentifierEdit->blockSignals(true);
+  m_Controls->m_SerialNumberEdit->blockSignals(true);
+  m_Controls->m_ToolAxisX->blockSignals(true);
+  m_Controls->m_ToolAxisY->blockSignals(true);
+  m_Controls->m_ToolAxisZ->blockSignals(true);
 
   //DeviceType
   int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(m_ToolToBeEdited->GetTrackingDeviceType()));
   if (index >= 0)
   {
     m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
   }
 
   m_Controls->m_ToolNameEdit->setText(QString(m_ToolToBeEdited->GetDataNode()->GetName().c_str()));
   m_Controls->m_CalibrationFileName->setText(QString(m_ToolToBeEdited->GetCalibrationFile().c_str()));
 
   m_Controls->m_SurfaceChooser->SetSelectedNode(m_ToolToBeEdited->GetDataNode());
   FillUIToolLandmarkLists(m_ToolToBeEdited->GetToolCalibrationLandmarks(), m_ToolToBeEdited->GetToolRegistrationLandmarks());
 
   switch (m_ToolToBeEdited->GetType())
   {
   case mitk::NavigationTool::Instrument:
     m_Controls->m_ToolTypeChooser->setCurrentIndex(0); break;
   case mitk::NavigationTool::Fiducial:
     m_Controls->m_ToolTypeChooser->setCurrentIndex(1); break;
   case mitk::NavigationTool::Skinmarker:
     m_Controls->m_ToolTypeChooser->setCurrentIndex(2); break;
   case mitk::NavigationTool::Unknown:
     m_Controls->m_ToolTypeChooser->setCurrentIndex(3); break;
   }
 
   m_Controls->m_IdentifierEdit->setText(QString(m_ToolToBeEdited->GetIdentifier().c_str()));
   m_Controls->m_SerialNumberEdit->setText(QString(m_ToolToBeEdited->GetSerialNumber().c_str()));
 
   m_Controls->m_ToolAxisX->setValue(m_ToolToBeEdited->GetToolAxis()[0]);
   m_Controls->m_ToolAxisY->setValue(m_ToolToBeEdited->GetToolAxis()[1]);
   m_Controls->m_ToolAxisZ->setValue(m_ToolToBeEdited->GetToolAxis()[2]);
   QString _label = "(" +
     QString::number(m_ToolToBeEdited->GetToolTipPosition()[0], 'f', 1) + ", " +
     QString::number(m_ToolToBeEdited->GetToolTipPosition()[1], 'f', 1) + ", " +
     QString::number(m_ToolToBeEdited->GetToolTipPosition()[2], 'f', 1) + "), quat: [" +
     QString::number(m_ToolToBeEdited->GetToolTipOrientation()[0], 'f', 2) + ", " +
     QString::number(m_ToolToBeEdited->GetToolTipOrientation()[1], 'f', 2) + ", " +
     QString::number(m_ToolToBeEdited->GetToolTipOrientation()[2], 'f', 2) + ", " +
     QString::number(m_ToolToBeEdited->GetToolTipOrientation()[3], 'f', 2) + "]";
   m_Controls->m_ToolTipLabel->setText(_label);
 
   //Undo block signals. Don't remove it, if signals are still blocked at the beginning of this function!
-  this->blockSignals(false);
+  m_Controls->m_TrackingDeviceTypeChooser->blockSignals(false);
+  m_Controls->m_ToolNameEdit->blockSignals(false);
+  m_Controls->m_ToolTypeChooser->blockSignals(false);
+  m_Controls->m_IdentifierEdit->blockSignals(false);
+  m_Controls->m_SerialNumberEdit->blockSignals(false);
+  m_Controls->m_ToolAxisX->blockSignals(false);
+  m_Controls->m_ToolAxisY->blockSignals(false);
+  m_Controls->m_ToolAxisZ->blockSignals(false);
 }
 
 void QmitkNavigationToolCreationWidget::OnSurfaceUseOtherToggled()
 {
   m_Controls->m_LoadSurface->setEnabled(m_Controls->m_Surface_Use_Other->isChecked());
   if (m_Controls->m_Surface_Use_Sphere->isChecked())
     SetConeAsToolSurface();
 }
 
 void QmitkNavigationToolCreationWidget::OnLoadSurface()
 {
   std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Surface"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("STL (*.stl)")).toLatin1().data();
   QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
   try
   {
     mitk::IOUtil::Load(filename.c_str(), *m_DataStorage);
   }
   catch (mitk::Exception &e)
   {
     MITK_ERROR << "Exception occured: " << e.what();
   }
 
   m_ToolToBeEdited->GetDataNode()->SetData(m_Controls->m_SurfaceChooser->GetSelectedNode()->GetData());
 }
 
 void QmitkNavigationToolCreationWidget::OnLoadCalibrationFile()
 {
   QString fileName = QFileDialog::getOpenFileName(NULL, tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*");
   QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(fileName);
   m_Controls->m_CalibrationFileName->setText(fileName);
   m_ToolToBeEdited->SetCalibrationFile(fileName.toStdString());
 }
 void QmitkNavigationToolCreationWidget::GetValuesFromGuiElements()
 {
   //Tracking Device
   m_ToolToBeEdited->SetTrackingDeviceType(m_Controls->m_TrackingDeviceTypeChooser->currentText().toStdString());
   m_ToolToBeEdited->GetDataNode()->SetName(m_Controls->m_ToolNameEdit->text().toStdString());
 
   //Tool Landmarks
   mitk::PointSet::Pointer toolCalLandmarks, toolRegLandmarks;
   GetUIToolLandmarksLists(toolCalLandmarks, toolRegLandmarks);
   m_ToolToBeEdited->SetToolCalibrationLandmarks(toolCalLandmarks);
   m_ToolToBeEdited->SetToolRegistrationLandmarks(toolRegLandmarks);
 
   //Advanced
   if (m_Controls->m_ToolTypeChooser->currentText() == "Instrument") m_ToolToBeEdited->SetType(mitk::NavigationTool::Instrument);
   else if (m_Controls->m_ToolTypeChooser->currentText() == "Fiducial") m_ToolToBeEdited->SetType(mitk::NavigationTool::Fiducial);
   else if (m_Controls->m_ToolTypeChooser->currentText() == "Skinmarker") m_ToolToBeEdited->SetType(mitk::NavigationTool::Skinmarker);
   else m_FinalTool->SetType(mitk::NavigationTool::Unknown);
 
   m_ToolToBeEdited->SetIdentifier(m_Controls->m_IdentifierEdit->text().toLatin1().data());
   m_ToolToBeEdited->SetSerialNumber(m_Controls->m_SerialNumberEdit->text().toLatin1().data());
 
   //Tool Axis
   mitk::Point3D toolAxis;
   toolAxis.SetElement(0, (m_Controls->m_ToolAxisX->value()));
   toolAxis.SetElement(1, (m_Controls->m_ToolAxisY->value()));
   toolAxis.SetElement(2, (m_Controls->m_ToolAxisZ->value()));
   m_ToolToBeEdited->SetToolAxis(toolAxis);
 }
 
 mitk::NavigationTool::Pointer QmitkNavigationToolCreationWidget::GetCreatedTool()
 {
   return m_FinalTool;
 }
 
 void QmitkNavigationToolCreationWidget::OnFinished()
 {
   //here we create a new tool
   m_FinalTool = m_ToolToBeEdited->Clone();
 
   emit NavigationToolFinished();
 }
 
 void QmitkNavigationToolCreationWidget::OnCancel()
 {
   Initialize(nullptr, "");//Reset everything to a fresh tool, like it was done in the constructor
   emit Canceled();
 }
 
 void QmitkNavigationToolCreationWidget::SetTrackingDeviceType(mitk::TrackingDeviceType type, bool changeable /*= true*/)
 {
   //Adapt Gui
   int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(type));
 
   if (index >= 0)
   {
     m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
   }
 
   m_Controls->m_TrackingDeviceTypeChooser->setEditable(changeable);
 
   //Set data to member
   m_ToolToBeEdited->SetTrackingDeviceType(type);
 }
 
 //##################################################################################
 //############################## internal help methods #############################
 //##################################################################################
 void QmitkNavigationToolCreationWidget::MessageBox(std::string s)
 {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
 }
 
 void QmitkNavigationToolCreationWidget::OnEditToolTip()
 {
   m_ToolTransformationWidget->SetToolToEdit(m_ToolToBeEdited);
   m_ToolTransformationWidget->SetDefaultRotation(m_ToolToBeEdited->GetToolTipOrientation());
   m_ToolTransformationWidget->SetDefaultOffset(m_ToolToBeEdited->GetToolTipPosition());
 
   QVBoxLayout *mainLayout = new QVBoxLayout;
   mainLayout->addWidget(m_ToolTransformationWidget);
   m_ToolEditDialog.setLayout(mainLayout);
   m_ToolEditDialog.setWindowTitle("Edit Tool Tip and Tool Orientation");
   m_ToolEditDialog.setProperty("minimumSizeHint", m_ToolTransformationWidget->size());
   m_ToolEditDialog.open();
 }
 
 void QmitkNavigationToolCreationWidget::OnEditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip)
 {
   //This function is called, when the toolTipEdit view is closed.
   m_ToolEditDialog.close();
 
   //if user pressed cancle, nullptr is returned. Do nothing. Else, set values.
   if (toolTip)
   {
     m_ToolToBeEdited->SetToolTipPosition(toolTip->GetOffset());
     mitk::NavigationData::Pointer tempND = mitk::NavigationData::New(toolTip);//Convert to Navigation data for simple transversion to quaternion
     m_ToolToBeEdited->SetToolTipOrientation(tempND->GetOrientation());
 
     //Update Label
     QString _label = "(" +
       QString::number(m_ToolToBeEdited->GetToolTipPosition()[0], 'f', 1) + ", " +
       QString::number(m_ToolToBeEdited->GetToolTipPosition()[1], 'f', 1) + ", " +
       QString::number(m_ToolToBeEdited->GetToolTipPosition()[2], 'f', 1) + "), quat: [" +
       QString::number(m_ToolToBeEdited->GetToolTipOrientation()[0], 'f', 2) + ", " +
       QString::number(m_ToolToBeEdited->GetToolTipOrientation()[1], 'f', 2) + ", " +
       QString::number(m_ToolToBeEdited->GetToolTipOrientation()[2], 'f', 2) + ", " +
       QString::number(m_ToolToBeEdited->GetToolTipOrientation()[3], 'f', 2) + "]";
     m_Controls->m_ToolTipLabel->setText(_label);
   }
 }
 
 void QmitkNavigationToolCreationWidget::FillUIToolLandmarkLists(mitk::PointSet::Pointer calLandmarks, mitk::PointSet::Pointer regLandmarks)
 {
   m_calLandmarkNode->SetData(calLandmarks);
   m_regLandmarkNode->SetData(regLandmarks);
   m_Controls->m_CalibrationLandmarksList->SetPointSetNode(m_calLandmarkNode);
   m_Controls->m_RegistrationLandmarksList->SetPointSetNode(m_regLandmarkNode);
 }
 
 void QmitkNavigationToolCreationWidget::GetUIToolLandmarksLists(mitk::PointSet::Pointer& calLandmarks, mitk::PointSet::Pointer& regLandmarks)
 {
   calLandmarks = dynamic_cast<mitk::PointSet*>(m_calLandmarkNode->GetData());
   regLandmarks = dynamic_cast<mitk::PointSet*>(m_regLandmarkNode->GetData());
 }
 
 void QmitkNavigationToolCreationWidget::InitializeUIToolLandmarkLists()
 {
   m_calLandmarkNode = mitk::DataNode::New();
   m_regLandmarkNode = mitk::DataNode::New();
   FillUIToolLandmarkLists(mitk::PointSet::New(), mitk::PointSet::New());
 }
 
 void QmitkNavigationToolCreationWidget::RefreshTrackingDeviceCollection()
 {
   us::ModuleContext* context = us::GetModuleContext();
   std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > refs = context->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();
   if (refs.empty())
   {
     MITK_WARN << "No tracking device service found!";
     return;
   }
   mitk::TrackingDeviceTypeCollection* _DeviceTypeCollection = context->GetService<mitk::TrackingDeviceTypeCollection>(refs.front());
 
   for (auto name : _DeviceTypeCollection->GetTrackingDeviceTypeNames())
   {
     //if the device is not included yet, add name to comboBox and widget to stackedWidget
     if (m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(name)) == -1)
     {
       m_Controls->m_TrackingDeviceTypeChooser->addItem(QString::fromStdString(name));
     }
   }
 }
\ No newline at end of file