diff --git a/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss b/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss
index 7f12943ca9..21554f33c5 100644
--- a/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss
+++ b/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss
@@ -1,1475 +1,1475 @@
 /*===================================================================
 
 BlueBerry Platform
 
 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.
 
 ===================================================================*/
 /*
  * The MIT License (MIT)
  *
  * Copyright (c) <2013-2014> <Colin Duquesnoy>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
 
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
 
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
 
 /*
   foregroundColor = #adb1b6
   iconColor       = #adb1b6 <- This line is parsed by MITK
   iconAccentColor = #db7039 <- This line is parsed by MITK
   backgroundColor = #323231
   inactiveColor   = #1d1d1c
   highlightColor  = #3399cc
   popupColor      = #027c90
   warningColor    = #ffb400
   borderColor     = #1d1d1c
 */
 
 QToolTip
 {
   border: 1px solid #1d1d1c;
   background-color: #323231;
   color: #adb1b6;
   padding: 3px;
   opacity: 200;
 }
 
 QWidget
 {
   color: #adb1b6;
   background-color: #323231;
   selection-background-color: #3399cc;
   selection-color: #1d1d1c;
   background-clip: border;
   border-image: none;
   border: 0px transparent #1d1d1c;
   outline: 0;
 }
 
 QWidget:item:hover
 {
   background-color: #3399cc;
   color: #adb1b6;
 }
 
 QWidget:item:selected
 {
   background-color: #3399cc;
 }
 
 QCheckBox
 {
   spacing: 5px;
   outline: none;
   color: #adb1b6;
   margin-bottom: 2px;
 }
 
 QCheckBox:disabled
 {
   color: #1d1d1c;
 }
 
 QCheckBox::indicator,
 QGroupBox::indicator
 {
   width: 18px;
   height: 30px;
 }
 QGroupBox::indicator
 {
   margin-left: 0px;
 }
 
 QCheckBox::indicator:unchecked
 {
   image: url(:/org.blueberry.ui.qt/dark/checkbox_unchecked.png);
 }
 
 QCheckBox::indicator:unchecked:hover,
 QCheckBox::indicator:unchecked:focus,
 QCheckBox::indicator:unchecked:pressed,
 QGroupBox::indicator:unchecked:hover,
 QGroupBox::indicator:unchecked:focus,
 QGroupBox::indicator:unchecked:pressed
 {
   border: none;
   image: url(:/org.blueberry.ui.qt/dark/checkbox_unchecked_focus.png);
 }
 
 QCheckBox::indicator:checked
 {
   image: url(:/org.blueberry.ui.qt/dark/checkbox_checked.png);
 }
 
 QCheckBox::indicator:checked:hover,
 QCheckBox::indicator:checked:focus,
 QCheckBox::indicator:checked:pressed,
 QGroupBox::indicator:checked:hover,
 QGroupBox::indicator:checked:focus,
 QGroupBox::indicator:checked:pressed
 {
   border: none;
   image: url(:/org.blueberry.ui.qt/dark/checkbox_checked_focus.png);
 }
 
 
 QCheckBox::indicator:indeterminate
 {
   image: url(:/org.blueberry.ui.qt/dark/checkbox_indeterminate.png);
 }
 
 QCheckBox::indicator:indeterminate:focus,
 QCheckBox::indicator:indeterminate:hover,
 QCheckBox::indicator:indeterminate:pressed
 {
   image: url(:/org.blueberry.ui.qt/dark/checkbox_indeterminate_focus.png);
 }
 
 QCheckBox::indicator:checked:disabled,
 QGroupBox::indicator:checked:disabled
 {
   image: url(:/org.blueberry.ui.qt/dark/checkbox_checked_disabled.png);
 }
 
 QCheckBox::indicator:unchecked:disabled,
 QGroupBox::indicator:unchecked:disabled
 {
   image: url(:/org.blueberry.ui.qt/dark/checkbox_unchecked_disabled.png);
 }
 
 QRadioButton
 {
   spacing: 5px;
   outline: none;
   color: #adb1b6;
   margin-bottom: 2px;
 }
 
 QRadioButton:disabled
 {
   color: #1d1d1c;
 }
 QRadioButton::indicator
 {
   width: 21px;
   height: 21px;
 }
 
 QRadioButton::indicator:unchecked
 {
   image: url(:/org.blueberry.ui.qt/dark/radio_unchecked.png);
 }
 
 QRadioButton::indicator:unchecked:hover,
 QRadioButton::indicator:unchecked:focus,
 QRadioButton::indicator:unchecked:pressed
 {
   border: none;
   outline: none;
   image: url(:/org.blueberry.ui.qt/dark/radio_unchecked_focus.png);
 }
 
 QRadioButton::indicator:checked
 {
   border: none;
   outline: none;
   image: url(:/org.blueberry.ui.qt/dark/radio_checked.png);
 }
 
 QRadioButton::indicator:checked:hover,
 QRadioButton::indicator:checked:focus,
 QRadioButton::indicator:checked:pressed
 {
   border: none;
   outline: none;
   image: url(:/org.blueberry.ui.qt/dark/radio_checked_focus.png);
 }
 
 QRadioButton::indicator:checked:disabled
 {
   outline: none;
   image: url(:/org.blueberry.ui.qt/dark/radio_checked_disabled.png);
 }
 
 QRadioButton::indicator:unchecked:disabled
 {
   image: url(:/org.blueberry.ui.qt/dark/radio_unchecked_disabled.png);
 }
 
 QMenuBar
 {
   background-color: #323231;
   color: #adb1b6;
 }
 
 QMenuBar::item
 {
   background: transparent;
 }
 
 QMenuBar::item:selected
 {
   background: transparent;
   border: 1px solid #1d1d1c;
 }
 
 QMenuBar::item:pressed
 {
   border: 1px solid #1d1d1c;
   background-color: #3399cc;
   color: #adb1b6;
   margin-bottom:-1px;
   padding-bottom:1px;
 }
 
 QMenu
 {
   border: 1px solid #1d1d1c;
   color: #adb1b6;
   margin: 2px;
 }
 
 QMenu::icon
 {
   margin: 5px;
 }
 
 QMenu::item
 {
   padding: 5px 30px 5px 30px;
   margin-left: 5px;
   border: 1px solid transparent; /* leave some space for selection border */
 }
 
 QMenu::item:selected
 {
   color: #adb1b6;
 }
 
 QMenu::separator
 {
   height: 2px;
   background: #3399cc;
   margin-left: 10px;
   margin-right: 5px;
 }
 
 QMenu::indicator
 {
   width: 18px;
   height: 18px;
 }
 
 /* non-exclusive indicator = check box style indicator
    (see QActionGroup::setExclusive) */
 QMenu::indicator:non-exclusive:unchecked
 {
   image: url(:/org.blueberry.ui.qt/dark/checkbox_unchecked.png);
 }
 
 QMenu::indicator:non-exclusive:unchecked:selected
 {
   image: url(:/org.blueberry.ui.qt/dark/checkbox_unchecked_disabled.png);
 }
 
 QMenu::indicator:non-exclusive:checked
 {
   image: url(:/org.blueberry.ui.qt/dark/checkbox_checked.png);
 }
 
 QMenu::indicator:non-exclusive:checked:selected
 {
   image: url(:/org.blueberry.ui.qt/dark/checkbox_checked_disabled.png);
 }
 
 /* exclusive indicator = radio button style indicator (see QActionGroup::setExclusive) */
 QMenu::indicator:exclusive:unchecked {
   image: url(:/org.blueberry.ui.qt/dark/radio_unchecked.png);
 }
 
 QMenu::indicator:exclusive:unchecked:selected {
   image: url(:/org.blueberry.ui.qt/dark/radio_unchecked_disabled.png);
 }
 
 QMenu::indicator:exclusive:checked
 {
   image: url(:/org.blueberry.ui.qt/dark/radio_checked.png);
 }
 
 QMenu::indicator:exclusive:checked:selected
 {
   image: url(:/org.blueberry.ui.qt/dark/radio_checked_disabled.png);
 }
 
 QMenu::right-arrow
 {
   margin: 5px;
   image: url(:/org.blueberry.ui.qt/dark/right_arrow.png)
 }
 
 QWidget:disabled
 {
   color: #1d1d1c;
   background-color: #323231;
 }
 
 QAbstractItemView
 {
   alternate-background-color: #323231;
   color: #adb1b6;
   border: 1px solid 3A3939;
   border-radius: 0px;
 }
 
 QWidget:focus,
 QMenuBar:focus
 {
   border: 1px solid #3399cc;
 }
 
 QTabWidget:focus,
 QCheckBox:focus,
 QRadioButton:focus,
 QSlider:focus
 {
   border: none;
 }
 
 QLineEdit
 {
   background-color: #1d1d1c;
   padding: 2px;
   border-style: solid;
   border: 1px solid #1d1d1c;
   border-radius: 0px;
   color: #adb1b6;
 }
 
 QGroupBox
 {
   border:1px solid #323231;
   border-radius: 0px;
-  padding-top: 1px;
+  padding-top: 24px;
   font-weight: bold;
 }
 
 QGroupBox::title
 {
   border:1px solid #323231;
   border-right:0px;
   border-bottom:0px;
   subcontrol-position: top left;
   subcontrol-origin: margin;
   padding: 1px;
 }
 
 QAbstractScrollArea
 {
   border-radius: 0px;
   border: 1px solid #1d1d1c;
   background-color: #323231;
 }
 
 QScrollBar:horizontal
 {
   height: 15px;
   margin: 3px 15px 3px 15px;
   border: 1px transparent #1d1d1c;
   border-radius: 0px;
   background-color: #1d1d1c;
 }
 
 QScrollBar::handle:horizontal
 {
   background-color: #323231;
   border: 2px solid #1d1d1c;
   min-width: 5px;
   border-radius: 0px;
 }
 
 QScrollBar::add-line:horizontal
 {
   margin: 0px 3px 0px 3px;
   border-image: url(:/org.blueberry.ui.qt/dark/right_arrow_disabled.png);
   width: 10px;
   height: 10px;
   subcontrol-position: right;
   subcontrol-origin: margin;
 }
 
 QScrollBar::sub-line:horizontal
 {
   margin: 0px 3px 0px 3px;
   border-image: url(:/org.blueberry.ui.qt/dark/left_arrow_disabled.png);
   height: 10px;
   width: 10px;
   subcontrol-position: left;
   subcontrol-origin: margin;
 }
 
 QScrollBar::add-line:horizontal:hover,
 QScrollBar::add-line:horizontal:on
 {
   border-image: url(:/org.blueberry.ui.qt/dark/right_arrow.png);
   height: 10px;
   width: 10px;
   subcontrol-position: right;
   subcontrol-origin: margin;
 }
 
 QScrollBar::sub-line:horizontal:hover,
 QScrollBar::sub-line:horizontal:on
 {
   border-image: url(:/org.blueberry.ui.qt/dark/left_arrow.png);
   height: 10px;
   width: 10px;
   subcontrol-position: left;
   subcontrol-origin: margin;
 }
 
 QScrollBar::up-arrow:horizontal,
 QScrollBar::down-arrow:horizontal
 {
   background: none;
 }
 
 
 QScrollBar::add-page:horizontal,
 QScrollBar::sub-page:horizontal
 {
   background: none;
 }
 
 QScrollBar:vertical
 {
   background-color: #1d1d1c;
   width: 15px;
   margin: 15px 2px 15px 2px;
   border: 1px transparent #1d1d1c;
   border-radius: 0px;
 }
 
 QScrollBar::handle:vertical
 {
   background-color: #323231;
   border: 2px solid #1d1d1c;
   min-height: 5px;
   border-radius: 0px;
 }
 
 QScrollBar::sub-line:vertical
 {
   margin: 3px 0px 3px 0px;
   border-image: url(:/org.blueberry.ui.qt/dark/up_arrow_disabled.png);
   height: 10px;
   width: 10px;
   subcontrol-position: top;
   subcontrol-origin: margin;
 }
 
 QScrollBar::add-line:vertical
 {
   margin: 3px 0px 3px 0px;
   border-image: url(:/org.blueberry.ui.qt/dark/down_arrow_disabled.png);
   height: 10px;
   width: 10px;
   subcontrol-position: bottom;
   subcontrol-origin: margin;
 }
 
 QScrollBar::sub-line:vertical:hover,
 QScrollBar::sub-line:vertical:on
 {
   border-image: url(:/org.blueberry.ui.qt/dark/up_arrow.png);
   height: 10px;
   width: 10px;
   subcontrol-position: top;
   subcontrol-origin: margin;
 }
 
 
 QScrollBar::add-line:vertical:hover,
 QScrollBar::add-line:vertical:on
 {
   border-image: url(:/org.blueberry.ui.qt/dark/down_arrow.png);
   height: 10px;
   width: 10px;
   subcontrol-position: bottom;
   subcontrol-origin: margin;
 }
 
 QScrollBar::up-arrow:vertical,
 QScrollBar::down-arrow:vertical
 {
   background: none;
 }
 
 
 QScrollBar::add-page:vertical,
 QScrollBar::sub-page:vertical
 {
   background: none;
 }
 
 QTextEdit
 {
   background-color: #1d1d1c;
   color: #adb1b6;
   border: 1px solid #1d1d1c;
 }
 
 QPlainTextEdit
 {
   background-color: #1d1d1c;;
   color: #adb1b6;
   border-radius: 0px;
   border: 1px solid #1d1d1c;
 }
 
 QHeaderView::section
 {
   background-color: #1d1d1c;
   color: #adb1b6;
   padding: 5px;
   border: 1px solid #1d1d1c;
 }
 
 QSizeGrip
 {
   image: url(:/org.blueberry.ui.qt/dark/sizegrip.png);
   width: 12px;
   height: 12px;
 }
 
 
 QMainWindow::separator
 {
   background-color: #323231;
   color: #adb1b6;
   padding-left: 4px;
   spacing: 2px;
   border: 1px dashed #1d1d1c;
 }
 
 QMainWindow::separator:hover
 {
   background-color: #adb1b6;
   color: #adb1b6;
   padding-left: 4px;
   border: 1px solid #1d1d1c;
   spacing: 2px;
 }
 
 
 QMenu::separator
 {
   height: 1px;
   background-color: #1d1d1c;
   color: #adb1b6;
   padding-left: 4px;
   margin-left: 10px;
   margin-right: 5px;
 }
 
 
 QFrame
 {
   border-radius: 0px;
   border: 1px solid #1d1d1c;
 }
 
 QFrame[frameShape="0"]
 {
   border-radius: 0px;
   border: 1px transparent #1d1d1c;
 }
 
 QStackedWidget
 {
   border: 1px transparent #1d1d1c;
 }
 
 QToolBar
 {
   border: 1px transparent #393838;
   background: 1px solid #323231;
   font-weight: bold;
 }
 
 /* this fixes the size of the plugin icons in the toolbar */
 QToolBar QToolButton
 {
   background-color: #323231;
   border: 1px solid #323231;
   border-radius: 0px;
   min-width: 30px;
   min-height: 30px;
   margin: 0px;
   padding: 0px;
 }
 
 QToolBar::handle:horizontal
 {
   image: url(:/org.blueberry.ui.qt/dark/Hmovetoolbar.png);
 }
 QToolBar::handle:vertical
 {
   image: url(:/org.blueberry.ui.qt/dark/Vmovetoolbar.png);
 }
 QToolBar::separator:horizontal
 {
   image: url(:/org.blueberry.ui.qt/dark/Hsepartoolbar.png);
 }
 QToolBar::separator:vertical
 {
   image: url(:/org.blueberry.ui.qt/dark/Vsepartoolbar.png);
 }
 
 QToolButton
 {
   background-color: #323231;
   border: 1px solid #323231;
   border-radius: 0px;
   min-width: 12px;
   min-height: 12px;
   margin: 0px;
   padding: 0px;
 }
 
 /* only for MenuButtonPopup */
 QToolButton[popupMode="1"]
 {
   border: 0px solid #1d1d1c;
 }
 
 /* only for InstantPopup */
 QToolButton[popupMode="2"]
 {
   border: 0px solid #1d1d1c;
 }
 
 /* this fixes the size of the standard icons in the toolbar */
 QToolButton:hover,
 QToolButton::menu-button:hover
 {
   background-color: #3399cc;
   border: 1px solid #3399cc;
   min-width: 30px;
   min-height: 30px;
   margin: 0px;
   padding: 0px;
 }
 
 QToolButton#qt_toolbar_ext_button,
 QToolBarExtension
 {
   qproperty-icon: url(:/org.blueberry.ui.qt/dark/right_arrows.svg);
   min-width: 10px;
 }
 
 QPushButton
 {
   color: #adb1b6;
   background-color: #323231;
   min-width: 68px;
   border-width: 1px;
   border-color: #1d1d1c;
   border-style: solid;
   padding: 3px;
   border-radius: 0px;
   outline: none;
 }
 
 QPushButton:disabled
 {
   background-color: #1d1d1c;
   color: #323231;
 }
 
 QPushButton:focus
 {
   color: #3399cc;
   border-color: #3399cc;
   border-style: solid;
   border-width: 1px;
 }
 
 QPushButton:pressed
 {
   background-color: #3399cc;
   color: #1d1d1c;
   padding-top: -15px;
   padding-bottom: -17px;
   border-width: 1px;
   border-color: #1d1d1c;
 }
 
 QComboBox
 {
   selection-background-color: #3399cc;
   selection-color: #1d1d1c;
   border: 1px solid #1d1d1c;
   border-radius: 0px;
   padding: 3px;
   min-width: 75px;
 }
 
 QPushButton:checked{
   background-color: #1d1d1c;
   border-color: #adb1b6;
 }
 
 QComboBox:hover,
 QAbstractSpinBox:hover,
 QLineEdit:hover,
 QTextEdit:hover,
 QPlainTextEdit:hover,
 QAbstractView:hover
 {
   border: 1px solid #3399cc;
   color: #adb1b6;
 }
 
 QPushButton:hover,QTreeView:hover
 {
   border: 1px solid #1d1d1c;
   color: #3399cc;
 }
 
 QComboBox QAbstractItemView
 {
   background-color: #323231;
   border-radius: 0px;
   border: 1px solid #1d1d1c;
   selection-background-color: #3399cc;
   selection-color: #adb1b6;
 }
 
 QComboBox:on
 {
   padding-top: 3px;
   padding-left: 3px;
   selection-background-color: #3399cc;
   color: #adb1b6;
   selection-color: #adb1b6;
 }
 
 QComboBox::drop-down
 {
   subcontrol-origin: padding;
   subcontrol-position: top right;
   min-width: 15px;
   border-top-right-radius: 0px;
   border-bottom-right-radius: 0px;
 }
 
 QComboBox::down-arrow
 {
   image: url(:/org.blueberry.ui.qt/dark/down_arrow_disabled.png);
 }
 
 QComboBox::down-arrow:on,
 QComboBox::down-arrow:hover,
 QComboBox::down-arrow:focus
 {
   image: url(:/org.blueberry.ui.qt/dark/down_arrow.png);
 }
 
 QAbstractSpinBox
 {
   border: 1px solid #1d1d1c;
   background-color: #1d1d1c;
   padding-top: 1px;
   padding-bottom: 1px;
   color: #adb1b6;
   border-radius: 0px;
   min-width: 50px;
 }
 
 QAbstractSpinBox:up-button
 {
   border: 2px transparent #1d1d1c;
   background-color: #323231;
   subcontrol-origin: border;
   subcontrol-position: top right;
   padding-top: 1px;
   margin-bottom: 1px;
   margin-top: 2px;
   margin-right: 2px;
   margin-left: 2px;
 }
 
 QAbstractSpinBox:down-button
 {
   border: 2px transparent #1d1d1c;
   background-color: #323231;
   subcontrol-origin: border;
   subcontrol-position: bottom right;
   padding-bottom: 0px;
   margin-bottom: 2px;
   margin-top: 1px;
   margin-right: 2px;
   margin-left: 2px;
 }
 
 QAbstractSpinBox::up-arrow,QAbstractSpinBox::up-arrow:disabled,QAbstractSpinBox::up-arrow:off
 {
   image: url(:/org.blueberry.ui.qt/dark/up_arrow_disabled.png);
   width: 10px;
   height: 10px;
 }
 
 QAbstractSpinBox::up-arrow:hover
 {
   image: url(:/org.blueberry.ui.qt/dark/up_arrow.png);
 }
 
 QAbstractSpinBox::down-arrow,QAbstractSpinBox::down-arrow:disabled,QAbstractSpinBox::down-arrow:off
 {
   image: url(:/org.blueberry.ui.qt/dark/down_arrow_disabled.png);
   width: 10px;
   height: 10px;
 }
 
 QAbstractSpinBox::down-arrow:hover
 {
   image: url(:/org.blueberry.ui.qt/dark/down_arrow.png);
 }
 
 QLabel
 {
   border: 0px solid #1d1d1c;
 }
 
 QTabWidget{
   border: 1px transparent #1d1d1c;
 }
 
 QTabWidget::pane
 {
   border: 1px solid #1d1d1c;
   padding: 2px;
   margin: 0px;
 }
 
 /* TABS IN GENERAL */
 QTabBar
 {
   qproperty-drawBase: 0;
   left: 0px;
   border-radius: 0px;
   border: 1px trasparent #1d1d1c;
 }
 
 QTabBar:focus
 {
   border: 1px solid #1d1d1c;
 }
 
 QTabBar::close-button
 {
   image: url(:/org.blueberry.ui.qt/dark/tab_close_grey.svg);
   background: transparent;
 }
 
 QTabBar::close-button:hover
 {
   image: url(:/org.blueberry.ui.qt/dark/tab_close_grey.svg);
   background: transparent;
 }
 
 QTabBar::close-button:pressed {
   image: url(:/org.blueberry.ui.qt/dark/tab_close_grey.svg);
   background: transparent;
 }
 
 QTabBar::tab:right:!selected:hover
 {
   color: #3399cc;
 }
 
 QTabBar QToolButton::right-arrow:enabled
 {
   image: url(:/org.blueberry.ui.qt/dark/right_arrow.png);
 }
 
 QTabBar QToolButton::left-arrow:enabled
 {
   image: url(:/org.blueberry.ui.qt/dark/left_arrow.png);
 }
 
 QTabBar QToolButton::right-arrow:disabled
 {
   image: url(:/org.blueberry.ui.qt/dark/right_arrow_disabled.png);
 }
 
 QTabBar QToolButton::left-arrow:disabled
 {
   image: url(:/org.blueberry.ui.qt/dark/left_arrow_disabled.png);
 }
 
 QTabBar::scroller
 {
   margin: 0px;
   padding: 0px;
 }
 
 /* TOP TABS */
 QTabBar::tab:top
 {
   font-weight: bold;
   color: #adb1b6;
   border: 0px solid #1d1d1c;
   background-color: #1d1d1c;
   padding: 5px;
   min-width: 50px;
   border-top-left-radius: 0px;
   border-top-right-radius: 0px;
 }
 
 QTabBar::tab:top:!selected
 {
   color: #adb1b6;
   font-weight: normal;
   background-color: #323231;
   border: 0px solid #1d1d1c;
   border-top-left-radius: 0px;
   border-top-right-radius: 0px;
 }
 
 QTabBar::tab:top:!selected:hover
 {
   color: #3399cc;
 }
 
 /* BOTTOM TABS */
 QTabBar::tab:bottom
 {
   font-weight: bold;
   color: #adb1b6;
   border: 0px solid #1d1d1c;
   background-color: #1d1d1c;
   padding: 5px;
   border-bottom-left-radius: 0px;
   border-bottom-right-radius: 0px;
   min-width: 50px;
 }
 
 QTabBar::tab:bottom:!selected
 {
   color: #adb1b6;
   font-weight: normal;
   background-color: #323231;
   border: 0px solid #1d1d1c;
   border-bottom-left-radius: 0px;
   border-bottom-right-radius: 0px;
 }
 
 QTabBar::tab:bottom:!selected:hover
 {
   color: #3399cc;
 }
 
 /* LEFT TABS */
 QTabBar::tab:left
 {
   color: #adb1b6;
   font-weight: bold;
   border: 0px solid #1d1d1c;
   background-color: #1d1d1c;
   padding: 5px;
   border-top-right-radius: 0px;
   border-bottom-right-radius: 0px;
   min-height: 50px;
 }
 
 QTabBar::tab:left:!selected
 {
   color: #adb1b6;
   font-weight: normal;
   background-color: #323231;
   border: 0px solid #1d1d1c;
   border-top-right-radius: 0px;
   border-bottom-right-radius: 0px;
 }
 
 QTabBar::tab:left:!selected:hover
 {
   color: #3399cc;
 }
 
 /* RIGHT TABS */
 QTabBar::tab:right
 {
   color: #adb1b6;
   font-weight: bold;
   border: 0px solid #1d1d1c;
   background-color: #1d1d1c;
   padding: 5px;
   border-top-left-radius: 0px;
   border-bottom-left-radius: 0px;
   min-height: 50px;
 }
 
 QTabBar::tab:right:!selected
 {
   color: #adb1b6;
   font-weight: normal;
   background-color: #323231;
   border: 0px solid #1d1d1c;
   border-top-left-radius: 0px;
   border-bottom-left-radius: 0px;
 }
 
 /* TODO check if #403F3F is nice */
 QDockWidget
 {
   background: #323231;
   border: 1px solid #403F3F;
   titlebar-close-icon: url(:/org.blueberry.ui.qt/dark/tab_close_grey.svg);
   titlebar-normal-icon: url(:/org.blueberry.ui.qt/dark/undock.png);
 }
 
 QDockWidget::close-button, QDockWidget::float-button
 {
   border: 1px solid transparent;
   border-radius: 0px;
   background: transparent;
 }
 
 /* TODO check if rgba(255, 255, 255, 10) is nice */
 QDockWidget::close-button:hover,
 QDockWidget::float-button:hover
 {
   background: rgba(255, 255, 255, 10);
 }
 
 QDockWidget::close-button:pressed,
 QDockWidget::float-button:pressed
 {
   padding: 1px -1px -1px 1px;
   background: rgba(255, 255, 255, 10);
 }
 
 QTreeView, QListView
 {
   border: 1px solid #1d1d1c;
   background-color: #1d1d1c;
 }
 
 QTreeView::indicator:unchecked
 {
   image: url(:/org.blueberry.ui.qt/dark/checkbox_big_unchecked.png);
 }
 
 QTreeView::indicator:checked,
 QTreeView::indicator:indeterminate
 {
   image: url(:/org.blueberry.ui.qt/dark/checkbox_big_checked.png);
 }
 
 QTreeView::indicator:unchecked:selected
 {
     image: url(:/org.blueberry.ui.qt/dark/checkbox_big_unchecked_disabled.png);
 }
 
 QTreeView::indicator:indeterminate:selected,
 QTreeView::indicator:checked:selected
 {
   image: url(:/org.blueberry.ui.qt/dark/checkbox_big_checked_disabled.png);
 }
 
 QTreeView:branch:selected,
 QTreeView:branch:hover
 {
   background: url(:/org.blueberry.ui.qt/dark/transparent.png);
 }
 
 QTreeView::branch:has-siblings:!adjoins-item
 {
   border-image: url(:/org.blueberry.ui.qt/dark/transparent.png);
 }
 
 QTreeView::branch:has-siblings:adjoins-item
 {
   border-image: url(:/org.blueberry.ui.qt/dark/transparent.png);
 }
 
 QTreeView::branch:!has-children:!has-siblings:adjoins-item
 {
   border-image: url(:/org.blueberry.ui.qt/dark/transparent.png);
 }
 
 QTreeView::branch:has-children:!has-siblings:closed,
 QTreeView::branch:closed:has-children:has-siblings
 {
   image: url(:/org.blueberry.ui.qt/dark/branch_closed.png);
 }
 
 QTreeView::branch:open:has-children:!has-siblings,
 QTreeView::branch:open:has-children:has-siblings
 {
   image: url(:/org.blueberry.ui.qt/dark/branch_open.png);
 }
 
 QTreeView::branch:has-children:!has-siblings:closed:hover,
 QTreeView::branch:closed:has-children:has-siblings:hover
 {
   image: url(:/org.blueberry.ui.qt/dark/branch_closed-on.png);
 }
 
 QTreeView::branch:open:has-children:!has-siblings:hover,
 QTreeView::branch:open:has-children:has-siblings:hover
 {
   image: url(:/org.blueberry.ui.qt/dark/branch_open-on.png);
 }
 
 QListView::item:!selected:hover,
 QTreeView::item:!selected:hover
 {
   background: #323231;
   outline: 0;
   color: #adb1b6
 }
 
 QListView::item:selected:hover,
 QTreeView::item:selected:hover
 {
   background: #3399cc;
   color: #adb1b6;
 }
 
 QSlider::groove:horizontal
 {
   border: 1px solid #1d1d1c;
   height: 3px;
   background: #1d1d1c;
   margin: 0px;
   border-radius: 0px;
 }
 
 QSlider::handle:horizontal
 {
   background: #adb1b6;
   border: 1px solid #1d1d1c;
   width: 7px;
   height: 16px;
   margin: -8px 0;
   border-radius: 0px;
 }
 
 QSlider::groove:vertical
 {
   border: 1px solid #1d1d1c;
   width: 3px;
   background: #1d1d1c;
   margin: 0px;
   border-radius: 0px;
 }
 
 QSlider::handle:vertical
 {
   background: #adb1b6;
   border: 1px solid #1d1d1c;
   width: 16px;
   height: 7px;
   margin: 0 -8px;
   border-radius: 0px;
 }
 
 QmitkRenderWindowMenu
 {
   background-color: transparent;
 }
 
 /* this fixes the size of the icons in the stdMultiWidget */
 QmitkRenderWindowMenu QToolButton,
 QmitkRenderWindowMenu QToolButton::menu-button {
   background-color: transparent;
   border: 0px solid #1d1d1c;
   border-radius: 0px;
   width: 15px;
   height: 15px;
   margin: 1px;
   padding: 0px;
 }
 
 QmitkRenderWindowMenu QToolButton:hover,
 QmitkRenderWindowMenu QToolButton::menu-button:hover
 {
   background-color: #adb1b6;
   border: 0px solid #3399cc;
   width: 15px;
   height: 15px;
   margin: 1px;
   padding: 0px;
 }
 
 QToolButton:checked,
 QToolButton:pressed,
 QToolButton::menu-button:pressed
 {
   color: #3399cc;
   border: 1px solid #3399cc;
   padding: 0px;
 }
 
 /* the subcontrol below is used only in the InstantPopup or DelayedPopup mode */
 QToolButton::menu-indicator
 {
   image: url(:/org.blueberry.ui.qt/dark/down_arrow.png);
   top: -7px; left: -2px; /* shift it a bit */
 }
 
 /* the subcontrols below are used only in the MenuButtonPopup mode */
 QToolButton::menu-button
 {
   border: 1px transparent #1d1d1c;
   border-top-right-radius: 0px;
   border-bottom-right-radius: 0px;
   /* 16px width + 4px for border = 20px allocated above */
   width: 16px;
   outline: none;
 }
 
 QToolButton::menu-arrow
 {
   image: url(:/org.blueberry.ui.qt/dark/down_arrow.png);
 }
 
 QToolButton::menu-arrow:open
 {
   border: 1px solid #1d1d1c;
 }
 
 QPushButton::menu-indicator
 {
   subcontrol-origin: padding;
   subcontrol-position: bottom right;
   left: 8px;
 }
 
 QTableView
 {
   border: 1px solid #1d1d1c;
   gridline-color: #323231;
   background-color: #1d1d1c;
 }
 
 
 QTableView, QHeaderView
 {
   border-radius: 0px;
 }
 
 QTableView::item:pressed, QListView::item:pressed, QTreeView::item:pressed
 {
   background: #3399cc;
   color: #1d1d1c;
 }
 
 QTableView::item:selected:active, QTreeView::item:selected:active, QListView::item:selected:active
 {
   background: #3399cc;
   color: #1d1d1c;
 }
 
 
 QHeaderView
 {
   background-color: #323231;
   border: 1px transparent;
   border-radius: 0px;
   margin: 0px;
   padding: 0px;
 }
 
 QHeaderView::section
 {
   background-color: #323231;
   color: #adb1b6;
   padding: 5px;
   border: 1px solid #1d1d1c;
   border-radius: 0px;
   text-align: left;
 }
 
 QHeaderView::section::vertical::first, QHeaderView::section::vertical::only-one
 {
   border-top: 1px solid #1d1d1c;
 }
 
 QHeaderView::section::vertical
 {
   border-top: transparent;
 }
 
 QHeaderView::section::horizontal::first, QHeaderView::section::horizontal::only-one
 {
   border-left: 1px solid #1d1d1c;
 }
 
 QHeaderView::section::horizontal
 {
   border-left: transparent;
 }
 
 QHeaderView::section:checked
 {
   color: #adb1b6;
   background-color: #323231;
 }
 
 /* sort indicator */
 QHeaderView::down-arrow
 {
   image: url(:/org.blueberry.ui.qt/dark/down_arrow.png);
 }
 
 QHeaderView::up-arrow
 {
   image: url(:/org.blueberry.ui.qt/dark/up_arrow.png);
 }
 
 
 QTableCornerButton::section
 {
   background-color: #323231;
   border: 1px transparent #1d1d1c;
   border-radius: 0px;
 }
 
 QToolBox
 {
   color: #adb1b6;
   background-color: #323231;
   padding: 5px;
   border: 1px transparent #1d1d1c;
 }
 
 QToolBox::tab
 {
   color: #adb1b6;
   background-color: #323231;
   border: 1px solid #1d1d1c;
   border-bottom: 1px transparent #323231;
   border-top-left-radius: 0px;
   border-top-right-radius: 0px;
 }
 
 QToolBox::tab:selected
 {
   background-color: #323231;
   border-color: #3399cc;
 }
 
 QStatusBar::item
 {
   border: 0px transparent #1d1d1c;
 }
 
 QSplitter::handle
 {
   border: 1px dashed #1d1d1c;
 }
 
 QSplitter::handle:hover
 {
   background-color: #adb1b6;
   border: 1px solid #1d1d1c;
 }
 
 QSplitter::handle:horizontal
 {
   width: 1px;
 }
 
 QSplitter::handle:vertical
 {
   height: 1px;
 }
 
 QProgressBar
 {
   border: 1px solid #1d1d1c;
   border-radius: 0px;
   text-align: center;
 }
 
 QProgressBar::chunk
 {
   background-color: #3399cc;
 }
 
 QDateEdit
 {
   selection-background-color: #3399cc;
   selection-color: #1d1d1c;
   border: 1px solid #1d1d1c;
   border-radius: 0px;
   padding: 1px;
   min-width: 75px;
 }
 
 QDateEdit:on
 {
   padding-top: 3px;
   padding-left: 4px;
 }
 
 QDateEdit QAbstractItemView
 {
   background-color: #1d1d1c;
   border-radius: 0px;
   border: 1px solid #1d1d1c;
   selection-background-color: #3399cc;
   selection-color: #1d1d1c;
 }
 
 QDateEdit::drop-down
 {
   subcontrol-origin: padding;
   subcontrol-position: top right;
   width: 15px;
   border-left-width: 0px;
   border-left-color: darkgray;
   border-left-style: solid;
   border-top-right-radius: 0px;
   border-bottom-right-radius: 0px;
 }
 
 QDateEdit::down-arrow
 {
   image: url(:/org.blueberry.ui.qt/dark/down_arrow_disabled.png);
 }
 
 QDateEdit::down-arrow:on, QDateEdit::down-arrow:hover,
 QDateEdit::down-arrow:focus
 {
   image: url(:/org.blueberry.ui.qt/dark/down_arrow.png);
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
index ad176e1cf9..78829bff6d 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
@@ -1,1349 +1,1349 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkMITKIGTTrackingToolboxView.h"
 
 // Qt
 #include <QMessageBox>
 #include <QSettings>
 #include <qfiledialog.h>
 
 // MITK
 #include <mitkNavigationToolStorageDeserializer.h>
 #include <mitkTrackingVolumeGenerator.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNavigationToolStorageSerializer.h>
 #include <mitkIOUtil.h>
 #include <mitkLog.h>
 #include <mitkTrackingDeviceTypeCollection.h>
 #include <mitkUnspecifiedTrackingTypeInformation.h>
 #include <mitkNeedleProjectionFilter.h>
 
 //for exceptions
 #include <mitkIGTException.h>
 #include <mitkIGTIOException.h>
 
 #include "mitkPluginActivator.h"
 
 const std::string QmitkMITKIGTTrackingToolboxView::VIEW_ID = "org.mitk.views.mitkigttrackingtoolbox";
 
 QmitkMITKIGTTrackingToolboxView::QmitkMITKIGTTrackingToolboxView()
   : QmitkAbstractView()
   , m_Controls(nullptr)
   , m_DeviceTypeCollection(nullptr)
 {
   m_TrackingLoggingTimer = new QTimer(this);
   m_TrackingRenderTimer = new QTimer(this);
   m_TimeoutTimer = new QTimer(this);
   m_tracking = false;
   m_connected = false;
   m_logging = false;
   m_ShowHideToolProjection = false;
   m_ShowHideToolAxis = false;
   m_loggedFrames = 0;
   m_SimpleModeEnabled = false;
   m_NeedleProjectionFilter = mitk::NeedleProjectionFilter::New();
 
   //create filename for autosaving of tool storage
   QString loggingPathWithoutFilename = QString(mitk::LoggingBackend::GetLogFile().c_str());
   if (!loggingPathWithoutFilename.isEmpty()) //if there already is a path for the MITK logging file use this one
   {
     //extract path from path+filename (if someone knows a better way to do this feel free to change it)
     int lengthOfFilename = QFileInfo(QString::fromStdString(mitk::LoggingBackend::GetLogFile())).fileName().size();
     loggingPathWithoutFilename.resize(loggingPathWithoutFilename.size() - lengthOfFilename);
     m_AutoSaveFilename = loggingPathWithoutFilename + "TrackingToolboxAutoSave.IGTToolStorage";
   }
   else //if not: use a temporary path from IOUtil
   {
     m_AutoSaveFilename = QString(mitk::IOUtil::GetTempPath().c_str()) + "TrackingToolboxAutoSave.IGTToolStorage";
   }
   MITK_INFO("IGT Tracking Toolbox") << "Filename for auto saving of IGT ToolStorages: " << m_AutoSaveFilename.toStdString();
 
   //! [Thread 1]
   //initialize worker thread
   m_WorkerThread = new QThread();
   m_Worker = new QmitkMITKIGTTrackingToolboxViewWorker();
   //! [Thread 1]
 
   ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
   if (pluginContext)
   {
     QString interfaceName = QString::fromStdString(us_service_interface_iid<mitk::TrackingDeviceTypeCollection>());
     QList<ctkServiceReference> serviceReference = pluginContext->getServiceReferences(interfaceName);
 
     if (serviceReference.size() > 0)
     {
       m_DeviceTypeServiceReference = serviceReference.at(0);
       const ctkServiceReference& r = serviceReference.at(0);
       m_DeviceTypeCollection = pluginContext->getService<mitk::TrackingDeviceTypeCollection>(r);
     }
     else
     {
       MITK_INFO << "No Tracking Device Collection!";
     }
   }
 }
 
 QmitkMITKIGTTrackingToolboxView::~QmitkMITKIGTTrackingToolboxView()
 {
   this->StoreUISettings();
   m_TrackingLoggingTimer->stop();
   m_TrackingRenderTimer->stop();
   m_TimeoutTimer->stop();
   delete m_TrackingLoggingTimer;
   delete m_TrackingRenderTimer;
   delete m_TimeoutTimer;
   try
   {
     //! [Thread 2]
     // wait for thread to finish
     m_WorkerThread->terminate();
     m_WorkerThread->wait();
     //clean up worker thread
     if (m_WorkerThread) { delete m_WorkerThread; }
     if (m_Worker) { delete m_Worker; }
     //! [Thread 2]
 
     //remove the tracking volume
     this->GetDataStorage()->Remove(m_TrackingVolumeNode);
     //unregister microservices
     if (m_toolStorage) { m_toolStorage->UnRegisterMicroservice(); }
 
     if (m_IGTLMessageProvider.IsNotNull()){ m_IGTLMessageProvider->UnRegisterMicroservice(); }
   }
   catch (std::exception& e) { MITK_WARN << "Unexpected exception during clean up of tracking toolbox view: " << e.what(); }
   catch (...) { MITK_WARN << "Unexpected unknown error during clean up of tracking toolbox view!"; }
   //store tool storage and UI settings for persistence
   this->AutoSaveToolStorage();
   this->StoreUISettings();
 
   m_DeviceTypeCollection = nullptr;
   mitk::PluginActivator::GetContext()->ungetService(m_DeviceTypeServiceReference);
 }
 
 void QmitkMITKIGTTrackingToolboxView::CreateQtPartControl(QWidget *parent)
 {
   // build up qt view, unless already done
   if (!m_Controls)
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkMITKIGTTrackingToolboxViewControls;
     m_Controls->setupUi(parent);
 
     //create connections
     connect(m_Controls->m_LoadTools, SIGNAL(clicked()), this, SLOT(OnLoadTools()));
     connect(m_Controls->m_ConnectDisconnectButton, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
     connect(m_Controls->m_StartStopTrackingButton, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
     connect(m_Controls->m_ConnectSimpleMode, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
     connect(m_Controls->m_StartTrackingSimpleMode, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
     connect(m_Controls->m_FreezeUnfreezeTrackingButton, SIGNAL(clicked()), this, SLOT(OnFreezeUnfreezeTracking()));
     connect(m_TrackingLoggingTimer, SIGNAL(timeout()), this, SLOT(UpdateLoggingTrackingTimer()));
     connect(m_TrackingRenderTimer, SIGNAL(timeout()), this, SLOT(UpdateRenderTrackingTimer()));
     connect(m_TimeoutTimer, SIGNAL(timeout()), this, SLOT(OnTimeOut()));
     connect(m_Controls->m_ChooseFile, SIGNAL(clicked()), this, SLOT(OnChooseFileClicked()));
     connect(m_Controls->m_StartLogging, SIGNAL(clicked()), this, SLOT(StartLogging()));
     connect(m_Controls->m_StopLogging, SIGNAL(clicked()), this, SLOT(StopLogging()));
     connect(m_Controls->m_VolumeSelectionBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(OnTrackingVolumeChanged(QString)));
     connect(m_Controls->m_ShowTrackingVolume, SIGNAL(clicked()), this, SLOT(OnShowTrackingVolumeChanged()));
     connect(m_Controls->m_AutoDetectTools, SIGNAL(clicked()), this, SLOT(OnAutoDetectTools()));
     connect(m_Controls->m_ResetTools, SIGNAL(clicked()), this, SLOT(OnResetTools()));
     connect(m_Controls->m_AddSingleTool, SIGNAL(clicked()), this, SLOT(OnAddSingleTool()));
     connect(m_Controls->m_NavigationToolCreationWidget, SIGNAL(NavigationToolFinished()), this, SLOT(OnAddSingleToolFinished()));
     connect(m_Controls->m_NavigationToolCreationWidget, SIGNAL(Canceled()), this, SLOT(OnAddSingleToolCanceled()));
     connect(m_Controls->m_CsvFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
     connect(m_Controls->m_XmlFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
     connect(m_Controls->m_UseDifferentUpdateRates, SIGNAL(clicked()), this, SLOT(OnToggleDifferentUpdateRates()));
     connect(m_Controls->m_RenderUpdateRate, SIGNAL(valueChanged(int)), this, SLOT(OnChangeRenderUpdateRate()));
     connect(m_Controls->m_DisableAllTimers, SIGNAL(stateChanged(int)), this, SLOT(EnableDisableTimerButtons(int)));
     connect(m_Controls->m_advancedUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
     connect(m_Controls->m_SimpleUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
     connect(m_Controls->showHideToolProjectionCheckBox, SIGNAL(clicked()), this, SLOT(OnShowHideToolProjectionClicked()));
     connect(m_Controls->showHideToolAxisCheckBox, SIGNAL(clicked()), this, SLOT(OnShowHideToolAxisClicked()));
 
     //connections for the tracking device configuration widget
     connect(m_Controls->m_ConfigurationWidget, SIGNAL(TrackingDeviceSelectionChanged()), this, SLOT(OnTrackingDeviceChanged()));
 
 
     //! [Thread 3]
     //connect worker thread
     connect(m_Worker, SIGNAL(AutoDetectToolsFinished(bool, QString)), this, SLOT(OnAutoDetectToolsFinished(bool, QString)));
     connect(m_Worker, SIGNAL(ConnectDeviceFinished(bool, QString)), this, SLOT(OnConnectFinished(bool, QString)));
     connect(m_Worker, SIGNAL(StartTrackingFinished(bool, QString)), this, SLOT(OnStartTrackingFinished(bool, QString)));
     connect(m_Worker, SIGNAL(StopTrackingFinished(bool, QString)), this, SLOT(OnStopTrackingFinished(bool, QString)));
     connect(m_Worker, SIGNAL(DisconnectDeviceFinished(bool, QString)), this, SLOT(OnDisconnectFinished(bool, QString)));
     connect(m_WorkerThread, SIGNAL(started()), m_Worker, SLOT(ThreadFunc()));
 
     connect(m_Worker, SIGNAL(ConnectDeviceFinished(bool, QString)), m_Controls->m_ConfigurationWidget, SLOT(OnConnected(bool)));
     connect(m_Worker, SIGNAL(DisconnectDeviceFinished(bool, QString)), m_Controls->m_ConfigurationWidget, SLOT(OnDisconnected(bool)));
     connect(m_Worker, SIGNAL(StartTrackingFinished(bool, QString)), m_Controls->m_ConfigurationWidget, SLOT(OnStartTracking(bool)));
     connect(m_Worker, SIGNAL(StopTrackingFinished(bool, QString)), m_Controls->m_ConfigurationWidget, SLOT(OnStopTracking(bool)));
 
 
     //Add Listener, so that we know when the toolStorage changed.
     std::string m_Filter = "(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.NavigationToolStorage" + ")";
     mitk::PluginActivator::GetContext()->connectServiceListener(this, "OnToolStorageChanged", QString(m_Filter.c_str()));
 
     //move the worker to the thread
     m_Worker->moveToThread(m_WorkerThread);
     //! [Thread 3]
 
     //initialize widgets
     m_Controls->m_TrackingToolsStatusWidget->SetShowPositions(true);
     m_Controls->m_TrackingToolsStatusWidget->SetTextAlignment(Qt::AlignLeft);
     m_Controls->m_simpleWidget->setVisible(false);
 
     //initialize tracking volume node
     m_TrackingVolumeNode = mitk::DataNode::New();
     m_TrackingVolumeNode->SetName("TrackingVolume");
     m_TrackingVolumeNode->SetBoolProperty("Backface Culling", true);
     mitk::Color red;
     red.SetRed(1);
     m_TrackingVolumeNode->SetColor(red);
 
     //initialize buttons
     m_Controls->m_AutoDetectTools->setVisible(false); //only visible if supported by tracking device
     m_Controls->m_StartStopTrackingButton->setEnabled(false);
     m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
     m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
 
     //initialize warning labels
     m_Controls->m_RenderWarningLabel->setVisible(false);
     m_Controls->m_TrackingFrozenLabel->setVisible(false);
 
     //Update List of available models for selected tool.
     std::vector<mitk::TrackingDeviceData> Compatibles;
     if ((m_Controls == nullptr) || //check all these stuff for NULL, latterly this causes crashes from time to time
       (m_Controls->m_ConfigurationWidget == nullptr) ||
       (m_Controls->m_ConfigurationWidget->GetTrackingDevice().IsNull()))
     {
       MITK_ERROR << "Couldn't get current tracking device or an object is nullptr, something went wrong!";
       return;
     }
     else
     {
       Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(m_Controls->m_ConfigurationWidget->GetTrackingDevice()->GetType());
     }
     m_Controls->m_VolumeSelectionBox->clear();
     for (std::size_t i = 0; i < Compatibles.size(); i++)
     {
       m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
     }
 
     //initialize tool storage
     m_toolStorage = mitk::NavigationToolStorage::New(GetDataStorage());
     m_toolStorage->SetName("TrackingToolbox Default Storage");
     m_toolStorage->RegisterAsMicroservice();
 
     //set home directory as default path for logfile
     m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(QDir::homePath()) + QDir::separator() + "logfile.csv");
 
     //tracking device may be changed already by the persistence of the
     //QmitkTrackingDeciveConfigurationWidget
     this->OnTrackingDeviceChanged();
 
     this->LoadUISettings();
 
     //add tracking volume node only to data storage
     this->GetDataStorage()->Add(m_TrackingVolumeNode);
     if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
     else m_TrackingVolumeNode->SetOpacity(0.25);
 
     //Update List of available models for selected tool.
     m_Controls->m_VolumeSelectionBox->clear();
     for (std::size_t i = 0; i < Compatibles.size(); i++)
     {
       m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
     }
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnLoadTools()
 {
   //read in filename
   QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Tool Storage"), "/", tr("Tool Storage Files (*.IGTToolStorage)"));
   if (filename.isNull()) return;
 
   //read tool storage from disk
   std::string errorMessage = "";
   mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
   // try-catch block for exceptions
   try
   {
     this->ReplaceCurrentToolStorage(myDeserializer->Deserialize(filename.toStdString()), filename.toStdString());
   }
   catch (mitk::IGTException)
   {
     std::string errormessage = "Error during loading the tool storage file. Please only load tool storage files created with the NavigationToolManager view.";
     QMessageBox::warning(nullptr, "Tool Storage Loading Error", errormessage.c_str());
     return;
   }
 
   if (m_toolStorage->isEmpty())
   {
     errorMessage = myDeserializer->GetErrorMessage();
     MessageBox(errorMessage);
     return;
   }
 
   //update label
   UpdateToolStorageLabel(filename);
 
   //update tool preview
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
 
   //save filename for persistent storage
   m_ToolStorageFilename = filename;
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnResetTools()
 {
   //remove data nodes of surfaces from data storage to clean up
   for (unsigned int i = 0; i < m_toolStorage->GetToolCount(); i++)
   {
     this->GetDataStorage()->Remove(m_toolStorage->GetTool(i)->GetDataNode());
   }
   this->ReplaceCurrentToolStorage(mitk::NavigationToolStorage::New(GetDataStorage()), "TrackingToolbox Default Storage");
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   QString toolLabel = QString("<none>");
   m_Controls->m_ToolLabel->setText(toolLabel);
   m_ToolStorageFilename = "";
 
 
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStartStopTracking()
 {
   if (!m_connected)
   {
     MITK_WARN << "Can't start tracking if no device is connected. Aborting";
     return;
   }
   if (m_tracking) { OnStopTracking(); }
   else { OnStartTracking(); }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnFreezeUnfreezeTracking()
 {
   if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Freeze Tracking")
   {
     m_Worker->GetTrackingDeviceSource()->Freeze();
     m_Controls->m_FreezeUnfreezeTrackingButton->setText("Unfreeze Tracking");
     m_Controls->m_TrackingFrozenLabel->setVisible(true);
   }
   else if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Unfreeze Tracking")
   {
     m_Worker->GetTrackingDeviceSource()->UnFreeze();
     m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
     m_Controls->m_TrackingFrozenLabel->setVisible(false);
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnShowHideToolProjectionClicked()
 {
   if( !m_ShowHideToolProjection )
   {
     //Activate and show the tool projection
     mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode("Tool Projection");
     //If node does not exist, create the node for the Pointset
     if( node.IsNull() )
     {
       node = mitk::DataNode::New();
       node->SetName("Tool Projection");
       node->SetData(m_NeedleProjectionFilter->GetProjection());
       node->SetBoolProperty("show contour", true);
       this->GetDataStorage()->Add(node);
     }
     else
     {
       node->SetBoolProperty("show contour", true);
     }
     //Enable the checkbox for displaying the (standard) tool axis
     m_Controls->showHideToolAxisCheckBox->setEnabled(true);
     m_ShowHideToolProjection = true;
   }
   else
   {
     //Deactivate and hide the tool projection
     mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode("Tool Projection");
     if( !node.IsNull() )
     {
       this->GetDataStorage()->Remove(node);
     }
     m_Controls->showHideToolAxisCheckBox->setEnabled(false);
     m_ShowHideToolProjection = false;
   }
   if( m_NeedleProjectionFilter.IsNotNull() )
   {
     m_NeedleProjectionFilter->Update();
   }
   //Refresh the view and the status widget
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   m_Controls->m_TrackingToolsStatusWidget->Refresh();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnShowHideToolAxisClicked()
 {
   if( !m_ShowHideToolAxis )
   {
     //Activate and show the tool axis
     m_NeedleProjectionFilter->ShowToolAxis(true);
     m_ShowHideToolAxis = true;
   }
   else
   {
     //Deactivate and hide the tool axis
     m_NeedleProjectionFilter->ShowToolAxis(false);
     m_NeedleProjectionFilter->GetProjection()->RemovePointIfExists(2);
     m_ShowHideToolAxis = false;
   }
   //Update the filter
   if( m_NeedleProjectionFilter.IsNotNull() )
   {
     m_NeedleProjectionFilter->Update();
   }
   //Refresh the view and the status widget
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   m_Controls->m_TrackingToolsStatusWidget->Refresh();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnConnectDisconnect()
 {
   if (m_connected) { OnDisconnect(); }
   else { OnConnect(); }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnConnect()
 {
   MITK_DEBUG << "Connect Clicked";
   //check if everything is ready to start tracking
   if (this->m_toolStorage.IsNull())
   {
     MessageBox("Error: No Tools Loaded Yet!");
     return;
   }
   else if (this->m_toolStorage->GetToolCount() == 0)
   {
     MessageBox("Error: No Way To Track Without Tools!");
     return;
   }
 
   //parse tracking device data
   mitk::TrackingDeviceData data = mitk::UnspecifiedTrackingTypeInformation::GetDeviceDataUnspecified();
   QString qstr = m_Controls->m_VolumeSelectionBox->currentText();
   if ((!qstr.isNull()) || (!qstr.isEmpty())) {
     std::string str = qstr.toStdString();
     data = m_DeviceTypeCollection->GetDeviceDataByName(str); //Data will be set later, after device generation
   }
 
   //! [Thread 4]
   //initialize worker thread
   m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eConnectDevice);
   m_Worker->SetTrackingDevice(this->m_Controls->m_ConfigurationWidget->GetTrackingDevice());
   m_Worker->SetInverseMode(m_Controls->m_InverseMode->isChecked());
   m_Worker->SetNavigationToolStorage(this->m_toolStorage);
   m_Worker->SetTrackingDeviceData(data);
   //start worker thread
   m_WorkerThread->start();
   //! [Thread 4]
 
   //disable buttons
   this->m_Controls->m_MainWidget->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableDisableTimerButtons(int enable)
 {
   bool enableBool = enable;
   m_Controls->m_UpdateRateOptionsGroupBox->setEnabled(!enableBool);
   m_Controls->m_RenderWarningLabel->setVisible(enableBool);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnConnectFinished(bool success, QString errorMessage)
 {
   m_WorkerThread->quit();
   m_WorkerThread->wait();
 
   //enable buttons
   this->m_Controls->m_MainWidget->setEnabled(true);
 
   if (!success)
   {
     MITK_WARN << errorMessage.toStdString();
     MessageBox(errorMessage.toStdString());
     return;
   }
 
   //! [Thread 6]
   //get data from worker thread
   m_TrackingDeviceData = m_Worker->GetTrackingDeviceData();
   m_ToolVisualizationFilter = m_Worker->GetToolVisualizationFilter();
   if( m_ToolVisualizationFilter.IsNotNull() )
   {
     //Connect the NeedleProjectionFilter to the ToolVisualizationFilter as third filter of the IGT pipeline
     m_NeedleProjectionFilter->ConnectTo(m_ToolVisualizationFilter);
     m_NeedleProjectionFilter->SelectInput(0);
   }
 
   //! [Thread 6]
 
   //enable/disable Buttons
   DisableOptionsButtons();
   DisableTrackingConfigurationButtons();
 
   m_Controls->m_TrackingControlLabel->setText("Status: connected");
   m_Controls->m_ConnectDisconnectButton->setText("Disconnect");
   m_Controls->m_ConnectSimpleMode->setText("Disconnect");
   m_Controls->m_StartStopTrackingButton->setEnabled(true);
   m_Controls->m_StartTrackingSimpleMode->setEnabled(true);
   m_connected = true;
 
   //During connection, thi sourceID of the tool storage changed. However, Microservice can't be updated on a different thread.
   //UpdateMicroservice is necessary to use filter to get the right storage belonging to a source.
   //Don't do it before m_connected is true, as we don't want to call content of OnToolStorageChanged.
   m_toolStorage->UpdateMicroservice();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnDisconnect()
 {
   m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eDisconnectDevice);
   m_WorkerThread->start();
   m_Controls->m_MainWidget->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnDisconnectFinished(bool success, QString errorMessage)
 {
   m_WorkerThread->quit();
   m_WorkerThread->wait();
   m_Controls->m_MainWidget->setEnabled(true);
 
   if (!success)
   {
     MITK_WARN << errorMessage.toStdString();
     MessageBox(errorMessage.toStdString());
     return;
   }
 
   //enable/disable Buttons
   m_Controls->m_StartStopTrackingButton->setEnabled(false);
   m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
   EnableOptionsButtons();
   EnableTrackingConfigurationButtons();
   m_Controls->m_TrackingControlLabel->setText("Status: disconnected");
   m_Controls->m_ConnectDisconnectButton->setText("Connect");
   m_Controls->m_ConnectSimpleMode->setText("Connect");
   m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
   m_Controls->m_TrackingFrozenLabel->setVisible(false);
   m_connected = false;
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStartTracking()
 {
   //show tracking volume
   this->OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
   //Reset the view to a defined start. Do it here and not in OnStartTrackingFinished, to give other tracking devices the chance to reset the view to a different direction.
   this->GlobalReinit();
   m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStartTracking);
   m_WorkerThread->start();
   this->m_Controls->m_MainWidget->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStartTrackingFinished(bool success, QString errorMessage)
 {
   //! [Thread 5]
   m_WorkerThread->quit();
   m_WorkerThread->wait();
   //! [Thread 5]
   this->m_Controls->m_MainWidget->setEnabled(true);
 
   if (!success)
   {
     MessageBox(errorMessage.toStdString());
     MITK_WARN << errorMessage.toStdString();
     return;
   }
 
   if (!(m_Controls->m_DisableAllTimers->isChecked()))
   {
     if (m_Controls->m_UseDifferentUpdateRates->isChecked())
     {
       if (m_Controls->m_RenderUpdateRate->value() != 0)
         m_TrackingRenderTimer->start(1000 / (m_Controls->m_RenderUpdateRate->value()));
       m_TrackingLoggingTimer->start(1000 / (m_Controls->m_LogUpdateRate->value()));
     }
     else
     {
       m_TrackingRenderTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
       m_TrackingLoggingTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
     }
   }
 
   m_Controls->m_TrackingControlLabel->setText("Status: tracking");
 
   //connect the tool visualization widget
   for (std::size_t i = 0; i < m_Worker->GetTrackingDeviceSource()->GetNumberOfOutputs(); i++)
   {
     m_Controls->m_TrackingToolsStatusWidget->AddNavigationData(m_Worker->GetTrackingDeviceSource()->GetOutput(i));
   }
   m_Controls->m_TrackingToolsStatusWidget->ShowStatusLabels();
   if (m_Controls->m_ShowToolQuaternions->isChecked()) { m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(true); }
   else { m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(false); }
 
   //if activated enable open IGT link microservice
   if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
   {
     //create convertion filter
     m_IGTLConversionFilter = mitk::NavigationDataToIGTLMessageFilter::New();
     m_IGTLConversionFilter->SetName("IGT Tracking Toolbox");
     QString dataModeSelection = this->m_Controls->m_OpenIGTLinkDataFormat->currentText();
     if (dataModeSelection == "TDATA")
     {
       m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendTDataMsg);
     }
     else if (dataModeSelection == "TRANSFORM")
     {
       m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendTransMsg);
     }
     else if (dataModeSelection == "QTDATA")
     {
       m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendQTDataMsg);
     }
     else if (dataModeSelection == "POSITION")
     {
       m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendQTransMsg);
     }
     m_IGTLConversionFilter->ConnectTo(m_ToolVisualizationFilter);
     m_IGTLConversionFilter->RegisterAsMicroservice();
 
     //create server and message provider
     m_IGTLServer = mitk::IGTLServer::New(false);
     m_IGTLServer->SetName("Tracking Toolbox IGTL Server");
     m_IGTLMessageProvider = mitk::IGTLMessageProvider::New();
     m_IGTLMessageProvider->SetIGTLDevice(m_IGTLServer);
     m_IGTLMessageProvider->RegisterAsMicroservice();
   }
 
   m_tracking = true;
   m_Controls->m_ConnectDisconnectButton->setEnabled(false);
   m_Controls->m_StartStopTrackingButton->setText("Stop Tracking");
   m_Controls->m_StartTrackingSimpleMode->setText("Stop\nTracking");
   m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStopTracking()
 {
   if (!m_tracking) return;
   m_TrackingRenderTimer->stop();
   m_TrackingLoggingTimer->stop();
 
   m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStopTracking);
   m_WorkerThread->start();
   m_Controls->m_MainWidget->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStopTrackingFinished(bool success, QString errorMessage)
 {
   m_WorkerThread->quit();
   m_WorkerThread->wait();
   m_Controls->m_MainWidget->setEnabled(true);
   if (!success)
   {
     MessageBox(errorMessage.toStdString());
     MITK_WARN << errorMessage.toStdString();
     return;
   }
 
   m_Controls->m_TrackingControlLabel->setText("Status: connected");
   if (m_logging) StopLogging();
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
   m_tracking = false;
   m_Controls->m_StartStopTrackingButton->setText("Start Tracking");
   m_Controls->m_StartTrackingSimpleMode->setText("Start\nTracking");
   m_Controls->m_ConnectDisconnectButton->setEnabled(true);
   m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
 
   //unregister open IGT link micro service
   if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
   {
     m_IGTLConversionFilter->UnRegisterMicroservice();
     m_IGTLMessageProvider->UnRegisterMicroservice();
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnTrackingDeviceChanged()
 {
   mitk::TrackingDeviceType Type;
 
   if (m_Controls->m_ConfigurationWidget->GetTrackingDevice().IsNotNull())
   {
     Type = m_Controls->m_ConfigurationWidget->GetTrackingDevice()->GetType();
     //enable controls because device is valid
-    m_Controls->m_TrackingToolsGoupBox->setEnabled(true);
-    m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
+    m_Controls->m_TrackingToolsFrame->setEnabled(true);
+    m_Controls->m_TrackingControlsFrame->setEnabled(true);
   }
   else
   {
     Type = mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName();
     MessageBox("Error: This tracking device is not included in this project. Please make sure that the device is installed and activated in your MITK build.");
-    m_Controls->m_TrackingToolsGoupBox->setEnabled(false);
-    m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
+    m_Controls->m_TrackingToolsFrame->setEnabled(false);
+    m_Controls->m_TrackingControlsFrame->setEnabled(false);
     return;
   }
 
   // Code to enable/disable device specific buttons
   if (m_Controls->m_ConfigurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
   {
     m_Controls->m_AutoDetectTools->setVisible(true);
   }
   else
   {
     m_Controls->m_AutoDetectTools->setVisible(false);
   }
 
   m_Controls->m_AddSingleTool->setEnabled(this->m_Controls->m_ConfigurationWidget->GetTrackingDevice()->AddSingleToolIsAvailable());
 
   // Code to select appropriate tracking volume for current type
   std::vector<mitk::TrackingDeviceData> Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(Type);
   m_Controls->m_VolumeSelectionBox->clear();
   for (std::size_t i = 0; i < Compatibles.size(); i++)
   {
     m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnTrackingVolumeChanged(QString qstr)
 {
   if (qstr.isNull()) return;
   if (qstr.isEmpty()) return;
 
   mitk::TrackingVolumeGenerator::Pointer volumeGenerator = mitk::TrackingVolumeGenerator::New();
 
   std::string str = qstr.toStdString();
 
   mitk::TrackingDeviceData data = m_DeviceTypeCollection->GetDeviceDataByName(str);
   m_TrackingDeviceData = data;
 
   volumeGenerator->SetTrackingDeviceData(data);
   volumeGenerator->Update();
 
   mitk::Surface::Pointer volumeSurface = volumeGenerator->GetOutput();
 
   m_TrackingVolumeNode->SetData(volumeSurface);
 
   if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
   else m_TrackingVolumeNode->SetOpacity(0.25);
 
   GlobalReinit();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnShowTrackingVolumeChanged()
 {
   if (m_Controls->m_ShowTrackingVolume->isChecked())
   {
     OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
     m_TrackingVolumeNode->SetOpacity(0.25);
   }
   else
   {
     m_TrackingVolumeNode->SetOpacity(0.0);
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAutoDetectTools()
 {
   if (m_Controls->m_ConfigurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
   {
     DisableTrackingConfigurationButtons();
     m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eAutoDetectTools);
     m_Worker->SetTrackingDevice(m_Controls->m_ConfigurationWidget->GetTrackingDevice().GetPointer());
     m_Worker->SetDataStorage(this->GetDataStorage());
     m_WorkerThread->start();
     m_TimeoutTimer->start(7000);
     //disable controls until worker thread is finished
     this->m_Controls->m_MainWidget->setEnabled(false);
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAutoDetectToolsFinished(bool success, QString errorMessage)
 {
   //Check, if the thread is running. There might have been a timeOut inbetween and this causes crashes...
   if (m_WorkerThread->isRunning())
   {
     m_TimeoutTimer->stop();
     m_WorkerThread->quit();
     m_WorkerThread->wait();
   }
 
   //enable controls again
   this->m_Controls->m_MainWidget->setEnabled(true);
   EnableTrackingConfigurationButtons();
 
   if (!success)
   {
     MITK_WARN << errorMessage.toStdString();
     MessageBox(errorMessage.toStdString());
     EnableTrackingConfigurationButtons();
     return;
   }
 
   mitk::NavigationToolStorage::Pointer autoDetectedStorage = m_Worker->GetNavigationToolStorage();
 
   //save detected tools
   std::string _autoDetectText;
   _autoDetectText = "Autodetected ";
   _autoDetectText.append(this->m_TrackingDeviceData.Line); //This is the device name as string of the current TrackingDevice.
   _autoDetectText.append(" Storage");
   this->ReplaceCurrentToolStorage(autoDetectedStorage, _autoDetectText);
   //auto save the new storage to hard disc (for persistence)
   AutoSaveToolStorage();
   //update label
   QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools (Auto Detected)";
   m_Controls->m_ToolLabel->setText(toolLabel);
   //update tool preview
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
 
   EnableTrackingConfigurationButtons();
 
   //print a logging message about the detected tools
   switch (m_toolStorage->GetToolCount())
   {
   case 0:
     MITK_INFO("IGT Tracking Toolbox") << "Found no tools. Empty ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
     break;
   case 1:
     MITK_INFO("IGT Tracking Toolbox") << "Found one tool. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
     break;
   default:
     MITK_INFO("IGT Tracking Toolbox") << "Found " << m_toolStorage->GetToolCount() << " tools. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::MessageBox(std::string s)
 {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
 }
 
 void QmitkMITKIGTTrackingToolboxView::UpdateRenderTrackingTimer()
 {
   //update filter
   m_ToolVisualizationFilter->Update();
   MITK_DEBUG << "Number of outputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedOutputs();
   MITK_DEBUG << "Number of inputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedInputs();
 
   //update tool colors to show tool status
   for (unsigned int i = 0; i < m_ToolVisualizationFilter->GetNumberOfIndexedOutputs(); i++)
   {
     mitk::NavigationData::Pointer currentTool = m_ToolVisualizationFilter->GetOutput(i);
     if (currentTool->IsDataValid())
     {
       this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_VALID);
     }
     else
     {
       this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_WARNING);
     }
   }
 
   //Update the NeedleProjectionFilter
   if( m_NeedleProjectionFilter.IsNotNull() )
   {
     m_NeedleProjectionFilter->Update();
   }
 
   //refresh view and status widget
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   m_Controls->m_TrackingToolsStatusWidget->Refresh();
 }
 
 void QmitkMITKIGTTrackingToolboxView::UpdateLoggingTrackingTimer()
 {
   //update logging
   if (m_logging)
   {
     this->m_loggingFilter->Update();
     m_loggedFrames = this->m_loggingFilter->GetNumberOfRecordedSteps();
     this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: " + QString::number(m_loggedFrames));
     //check if logging stopped automatically
     if ((m_loggedFrames > 1) && (!m_loggingFilter->GetRecording())){ StopLogging(); }
   }
   //refresh status widget
   m_Controls->m_TrackingToolsStatusWidget->Refresh();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnChooseFileClicked()
 {
   QDir currentPath = QFileInfo(m_Controls->m_LoggingFileName->text()).dir();
 
   // if no path was selected (QDir would select current working dir then) or the
   // selected path does not exist -> use home directory
   if (currentPath == QDir() || !currentPath.exists())
   {
     currentPath = QDir(QDir::homePath());
   }
 
   QString filename = QFileDialog::getSaveFileName(nullptr, tr("Choose Logging File"), currentPath.absolutePath(), "*.*");
   if (filename == "") return;
   this->m_Controls->m_LoggingFileName->setText(filename);
   this->OnToggleFileExtension();
 }
 // bug-16470: toggle file extension after clicking on radio button
 void QmitkMITKIGTTrackingToolboxView::OnToggleFileExtension()
 {
   QString currentInputText = this->m_Controls->m_LoggingFileName->text();
   QString currentFile = QFileInfo(currentInputText).baseName();
   QDir currentPath = QFileInfo(currentInputText).dir();
   if (currentFile.isEmpty())
   {
     currentFile = "logfile";
   }
   // Setting currentPath to default home path when currentPath is empty or it does not exist
   if (currentPath == QDir() || !currentPath.exists())
   {
     currentPath = QDir::homePath();
   }
   // check if csv radio button is clicked
   if (this->m_Controls->m_CsvFormat->isChecked())
   {
     // you needn't add a seperator to the input text when currentpath is the rootpath
     if (currentPath.isRoot())
     {
       this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".csv");
     }
 
     else
     {
       this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".csv");
     }
   }
   // check if xml radio button is clicked
   else if (this->m_Controls->m_XmlFormat->isChecked())
   {
     // you needn't add a seperator to the input text when currentpath is the rootpath
     if (currentPath.isRoot())
     {
       this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".xml");
     }
     else
     {
       this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".xml");
     }
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnToggleAdvancedSimpleMode()
 {
   if (m_SimpleModeEnabled)
   {
     m_Controls->m_simpleWidget->setVisible(false);
     m_Controls->m_MainWidget->setVisible(true);
     m_Controls->m_SimpleUI->setChecked(false);
     m_SimpleModeEnabled = false;
   }
   else
   {
     m_Controls->m_simpleWidget->setVisible(true);
     m_Controls->m_MainWidget->setVisible(false);
     m_SimpleModeEnabled = true;
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnToggleDifferentUpdateRates()
 {
   if (m_Controls->m_UseDifferentUpdateRates->isChecked())
   {
     if (m_Controls->m_RenderUpdateRate->value() == 0)
       m_Controls->m_RenderWarningLabel->setVisible(true);
     else
       m_Controls->m_RenderWarningLabel->setVisible(false);
 
     m_Controls->m_UpdateRate->setEnabled(false);
     m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
 
     m_Controls->m_RenderUpdateRate->setEnabled(true);
     m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(true);
 
     m_Controls->m_LogUpdateRate->setEnabled(true);
     m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(true);
   }
 
   else
   {
     m_Controls->m_RenderWarningLabel->setVisible(false);
 
     m_Controls->m_UpdateRate->setEnabled(true);
     m_Controls->m_OptionsUpdateRateLabel->setEnabled(true);
 
     m_Controls->m_RenderUpdateRate->setEnabled(false);
     m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
 
     m_Controls->m_LogUpdateRate->setEnabled(false);
     m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnChangeRenderUpdateRate()
 {
   if (m_Controls->m_RenderUpdateRate->value() == 0)
     m_Controls->m_RenderWarningLabel->setVisible(true);
   else
     m_Controls->m_RenderWarningLabel->setVisible(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::StartLogging()
 {
   if (m_ToolVisualizationFilter.IsNull())
   {
     MessageBox("Cannot activate logging without a connected device. Configure and connect a tracking device first.");
     return;
   }
 
   if (!m_logging)
   {
     //initialize logging filter
     m_loggingFilter = mitk::NavigationDataRecorder::New();
     m_loggingFilter->SetRecordOnlyValidData(m_Controls->m_SkipInvalidData->isChecked());
 
     m_loggingFilter->ConnectTo(m_ToolVisualizationFilter);
 
     if (m_Controls->m_LoggingLimit->isChecked()){ m_loggingFilter->SetRecordCountLimit(m_Controls->m_LoggedFramesLimit->value()); }
 
     //start filter with try-catch block for exceptions
     try
     {
       m_loggingFilter->StartRecording();
     }
     catch (mitk::IGTException)
     {
       std::string errormessage = "Error during start recording. Recorder already started recording?";
       QMessageBox::warning(nullptr, "IGTPlayer: Error", errormessage.c_str());
       m_loggingFilter->StopRecording();
       return;
     }
 
     //update labels / logging variables
     this->m_Controls->m_LoggingLabel->setText("Logging ON");
     this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: 0");
     m_loggedFrames = 0;
     m_logging = true;
     DisableLoggingButtons();
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::StopLogging()
 {
   if (m_logging)
   {
     //stop logging
     m_loggingFilter->StopRecording();
     m_logging = false;
 
     //update GUI
     this->m_Controls->m_LoggingLabel->setText("Logging OFF");
     EnableLoggingButtons();
 
     //write the results to a file
     if (m_Controls->m_CsvFormat->isChecked())
     {
       mitk::IOUtil::Save(m_loggingFilter->GetNavigationDataSet(), this->m_Controls->m_LoggingFileName->text().toStdString());
     }
     else if (m_Controls->m_XmlFormat->isChecked())
     {
       mitk::IOUtil::Save(m_loggingFilter->GetNavigationDataSet(), this->m_Controls->m_LoggingFileName->text().toStdString());
     }
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::SetFocus()
 {
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAddSingleTool()
 {
   QString Identifier = "Tool#";
   QString Name = "NewTool";
   if (m_toolStorage.IsNotNull()) {
     Identifier += QString::number(m_toolStorage->GetToolCount());
     Name += QString::number(m_toolStorage->GetToolCount());
   }
   else {
     Identifier += "0";
     Name += "0";
   }
   m_Controls->m_NavigationToolCreationWidget->Initialize(GetDataStorage(), Identifier.toStdString(), Name.toStdString());
   m_Controls->m_NavigationToolCreationWidget->SetTrackingDeviceType(m_Controls->m_ConfigurationWidget->GetTrackingDevice()->GetType(), false);
   m_Controls->m_TrackingToolsWidget->setCurrentIndex(1);
 
   //disable tracking volume during tool editing
   lastTrackingVolumeState = m_Controls->m_ShowTrackingVolume->isChecked();
   if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
   GlobalReinit();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolFinished()
 {
   m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
   if (this->m_toolStorage.IsNull())
   {
     //this shouldn't happen!
     MITK_WARN << "No ToolStorage available, cannot add tool, aborting!";
     return;
   }
   m_toolStorage->AddTool(m_Controls->m_NavigationToolCreationWidget->GetCreatedTool());
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
   m_Controls->m_ToolLabel->setText("<manually added>");
 
   //auto save current storage for persistence
   MITK_INFO << "Auto saving manually added tools for persistence.";
   AutoSaveToolStorage();
 
   //enable tracking volume again
   if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
   GlobalReinit();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolCanceled()
 {
   m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
 
   //enable tracking volume again
   if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
   GlobalReinit();
 }
 
 void QmitkMITKIGTTrackingToolboxView::GlobalReinit()
 {
   // get all nodes that have not set "includeInBoundingBox" to false
   mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
 
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
   // calculate bounding geometry of these nodes
   mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
   // initialize the views to the bounding geometry
   mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableLoggingButtons()
 {
   m_Controls->m_StartLogging->setEnabled(false);
   m_Controls->m_LoggingFileName->setEnabled(false);
   m_Controls->m_ChooseFile->setEnabled(false);
   m_Controls->m_LoggingLimit->setEnabled(false);
   m_Controls->m_LoggedFramesLimit->setEnabled(false);
   m_Controls->m_CsvFormat->setEnabled(false);
   m_Controls->m_XmlFormat->setEnabled(false);
   m_Controls->m_SkipInvalidData->setEnabled(false);
   m_Controls->m_StopLogging->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableLoggingButtons()
 {
   m_Controls->m_StartLogging->setEnabled(true);
   m_Controls->m_LoggingFileName->setEnabled(true);
   m_Controls->m_ChooseFile->setEnabled(true);
   m_Controls->m_LoggingLimit->setEnabled(true);
   m_Controls->m_LoggedFramesLimit->setEnabled(true);
   m_Controls->m_CsvFormat->setEnabled(true);
   m_Controls->m_XmlFormat->setEnabled(true);
   m_Controls->m_SkipInvalidData->setEnabled(true);
   m_Controls->m_StopLogging->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableOptionsButtons()
 {
   m_Controls->m_ShowTrackingVolume->setEnabled(false);
   m_Controls->m_UseDifferentUpdateRates->setEnabled(false);
   m_Controls->m_UpdateRate->setEnabled(false);
   m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
   m_Controls->m_RenderUpdateRate->setEnabled(false);
   m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
   m_Controls->m_LogUpdateRate->setEnabled(false);
   m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
   m_Controls->m_DisableAllTimers->setEnabled(false);
   m_Controls->m_OtherOptionsGroupBox->setEnabled(false);
   m_Controls->m_EnableOpenIGTLinkMicroService->setEnabled(false);
   m_Controls->m_OpenIGTLinkDataFormat->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableOptionsButtons()
 {
   m_Controls->m_ShowTrackingVolume->setEnabled(true);
   m_Controls->m_UseDifferentUpdateRates->setEnabled(true);
   m_Controls->m_DisableAllTimers->setEnabled(true);
   m_Controls->m_OtherOptionsGroupBox->setEnabled(true);
   m_Controls->m_EnableOpenIGTLinkMicroService->setEnabled(true);
   m_Controls->m_OpenIGTLinkDataFormat->setEnabled(true);
   OnToggleDifferentUpdateRates();
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableTrackingControls()
 {
-  m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
+  m_Controls->m_TrackingControlsFrame->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableTrackingControls()
 {
-  m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
+  m_Controls->m_TrackingControlsFrame->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableTrackingConfigurationButtons()
 {
   m_Controls->m_AutoDetectTools->setEnabled(true);
   m_Controls->m_AddSingleTool->setEnabled(this->m_Controls->m_ConfigurationWidget->GetTrackingDevice()->AddSingleToolIsAvailable());
   m_Controls->m_LoadTools->setEnabled(true);
   m_Controls->m_ResetTools->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableTrackingConfigurationButtons()
 {
   m_Controls->m_AutoDetectTools->setEnabled(false);
   m_Controls->m_AddSingleTool->setEnabled(false);
   m_Controls->m_LoadTools->setEnabled(false);
   m_Controls->m_ResetTools->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::ReplaceCurrentToolStorage(mitk::NavigationToolStorage::Pointer newStorage, std::string newStorageName)
 {
   //first: get rid of the old one
   //don't reset if there is no tool storage. BugFix #17793
   if (m_toolStorage.IsNotNull()){
     m_toolStorage->UnLockStorage(); //only to be sure...
     m_toolStorage->UnRegisterMicroservice();
     m_toolStorage = nullptr;
   }
 
   //now: replace by the new one
   m_toolStorage = newStorage;
   m_toolStorage->SetName(newStorageName);
   m_toolStorage->RegisterAsMicroservice();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnTimeOut()
 {
   MITK_WARN << "TimeOut. Quitting the thread...";
   m_WorkerThread->quit();
   //only if we can't quit use terminate.
   if (!m_WorkerThread->wait(1000))
   {
     MITK_ERROR << "Can't quit the thread. Terminating... Might cause further problems, be careful!";
     m_WorkerThread->terminate();
     m_WorkerThread->wait();
   }
   m_TimeoutTimer->stop();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnToolStorageChanged(const ctkServiceEvent event)
 {
   //don't listen to any changes during connection, toolStorage is locked anyway, so this are only changes of e.g. sourceID which are not relevant for the widget.
   if (!m_connected && (event.getType() == ctkServiceEvent::MODIFIED))
   {
     m_Controls->m_ConfigurationWidget->OnToolStorageChanged();
   }
 }
 
 //! [StoreUISettings]
 void QmitkMITKIGTTrackingToolboxView::StoreUISettings()
 {
   // persistence service does not directly work in plugins for now
   // -> using QSettings
   QSettings settings;
 
   settings.beginGroup(QString::fromStdString(VIEW_ID));
   MITK_DEBUG << "Store UI settings";
   // set the values of some widgets and attrbutes to the QSettings
   settings.setValue("ShowTrackingVolume", QVariant(m_Controls->m_ShowTrackingVolume->isChecked()));
   settings.setValue("toolStorageFilename", QVariant(m_ToolStorageFilename));
   settings.setValue("VolumeSelectionBox", QVariant(m_Controls->m_VolumeSelectionBox->currentIndex()));
   settings.setValue("SimpleModeEnabled", QVariant(m_SimpleModeEnabled));
   settings.setValue("OpenIGTLinkDataFormat", QVariant(m_Controls->m_OpenIGTLinkDataFormat->currentIndex()));
   settings.setValue("EnableOpenIGTLinkMicroService", QVariant(m_Controls->m_EnableOpenIGTLinkMicroService->isChecked()));
   settings.endGroup();
 }
 //! [StoreUISettings]
 
 //! [LoadUISettings]
 void QmitkMITKIGTTrackingToolboxView::LoadUISettings()
 {
   // persistence service does not directly work in plugins for now -> using QSettings
   QSettings settings;
 
   settings.beginGroup(QString::fromStdString(VIEW_ID));
 
   // set some widgets and attributes by the values from the QSettings
   m_Controls->m_ShowTrackingVolume->setChecked(settings.value("ShowTrackingVolume", true).toBool());
   m_Controls->m_EnableOpenIGTLinkMicroService->setChecked(settings.value("EnableOpenIGTLinkMicroService", true).toBool());
   m_Controls->m_VolumeSelectionBox->setCurrentIndex(settings.value("VolumeSelectionBox", 0).toInt());
   m_Controls->m_OpenIGTLinkDataFormat->setCurrentIndex(settings.value("OpenIGTLinkDataFormat", 0).toInt());
   m_ToolStorageFilename = settings.value("toolStorageFilename", QVariant("")).toString();
   if (settings.value("SimpleModeEnabled", false).toBool()) { this->OnToggleAdvancedSimpleMode(); }
   settings.endGroup();
   //! [LoadUISettings]
 
   //! [LoadToolStorage]
   // try to deserialize the tool storage from the given tool storage file name
   if (!m_ToolStorageFilename.isEmpty())
   {
     // try-catch block for exceptions
     try
     {
       mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
       m_toolStorage->UnRegisterMicroservice();
       m_toolStorage = myDeserializer->Deserialize(m_ToolStorageFilename.toStdString());
       m_toolStorage->RegisterAsMicroservice();
 
       //update label
       UpdateToolStorageLabel(m_ToolStorageFilename);
 
       //update tool preview
       m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
       m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
     }
     catch (mitk::IGTException)
     {
       MITK_WARN("QmitkMITKIGTTrackingToolBoxView") << "Error during restoring tools. Problems with file (" << m_ToolStorageFilename.toStdString() << "), please check the file?";
       this->OnResetTools(); //if there where errors reset the tool storage to avoid problems later on
     }
   }
   //! [LoadToolStorage]
 }
 
 void QmitkMITKIGTTrackingToolboxView::UpdateToolStorageLabel(QString pathOfLoadedStorage)
 {
   QFileInfo myPath(pathOfLoadedStorage); //use this to seperate filename from path
   QString toolLabel = myPath.fileName();
   if (toolLabel.size() > 45) //if the tool storage name is to long trimm the string
   {
     toolLabel.resize(40);
     toolLabel += "[...]";
   }
   m_Controls->m_ToolLabel->setText(toolLabel);
 }
 
 void QmitkMITKIGTTrackingToolboxView::AutoSaveToolStorage()
 {
   m_ToolStorageFilename = m_AutoSaveFilename;
   mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
   mySerializer->Serialize(m_ToolStorageFilename.toStdString(), m_toolStorage);
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui
index 5b33d3bb49..3fbf0de008 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui
@@ -1,963 +1,942 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkMITKIGTTrackingToolboxViewControls</class>
  <widget class="QWidget" name="QmitkMITKIGTTrackingToolboxViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>662</width>
-    <height>648</height>
+    <height>630</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
-  <layout class="QGridLayout" name="gridLayout_6">
+  <layout class="QGridLayout" name="gridLayout_2">
    <item row="0" column="0">
     <widget class="QTabWidget" name="m_MainWidget">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="tab">
       <attribute name="title">
        <string>Tracking</string>
       </attribute>
-      <layout class="QGridLayout" name="gridLayout_5">
-       <item row="1" column="0">
-        <widget class="QGroupBox" name="m_TrackingToolsGoupBox">
-         <property name="sizePolicy">
-          <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
+      <layout class="QVBoxLayout" name="verticalLayout_4">
+       <item>
+        <widget class="QFrame" name="m_ConfigurationWidgetFrame">
+         <property name="frameShape">
+          <enum>QFrame::NoFrame</enum>
          </property>
-         <property name="title">
-          <string/>
+         <property name="frameShadow">
+          <enum>QFrame::Raised</enum>
          </property>
-         <layout class="QGridLayout" name="gridLayout_2">
+         <layout class="QGridLayout" name="gridLayout">
           <item row="0" column="0">
+           <widget class="QmitkTrackingDeviceConfigurationWidget" name="m_ConfigurationWidget" native="true">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QFrame" name="m_TrackingToolsFrame">
+         <property name="frameShape">
+          <enum>QFrame::NoFrame</enum>
+         </property>
+         <property name="frameShadow">
+          <enum>QFrame::Raised</enum>
+         </property>
+         <layout class="QVBoxLayout" name="verticalLayout_2">
+          <item>
            <widget class="QLabel" name="label_2">
             <property name="font">
              <font>
               <pointsize>10</pointsize>
               <weight>75</weight>
               <bold>true</bold>
               <kerning>true</kerning>
              </font>
             </property>
             <property name="text">
              <string>Tracking Tools</string>
             </property>
             <property name="alignment">
              <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
             </property>
            </widget>
           </item>
-          <item row="1" column="0">
+          <item>
            <widget class="QStackedWidget" name="m_TrackingToolsWidget">
             <property name="lineWidth">
              <number>0</number>
             </property>
             <property name="currentIndex">
              <number>0</number>
             </property>
             <widget class="QWidget" name="page">
              <layout class="QVBoxLayout" name="verticalLayout_11">
               <item>
                <layout class="QHBoxLayout" name="horizontalLayout_3">
                 <item>
                  <widget class="QLabel" name="label_4">
                   <property name="text">
                    <string>ToolStorage:</string>
                   </property>
                  </widget>
                 </item>
                 <item>
                  <widget class="QLabel" name="m_ToolLabel">
                   <property name="text">
                    <string>&lt;none&gt;</string>
                   </property>
                  </widget>
                 </item>
                 <item>
                  <spacer name="horizontalSpacer">
                   <property name="orientation">
                    <enum>Qt::Horizontal</enum>
                   </property>
                   <property name="sizeHint" stdset="0">
                    <size>
                     <width>40</width>
                     <height>20</height>
                    </size>
                   </property>
                  </spacer>
                 </item>
                </layout>
               </item>
               <item>
                <widget class="QmitkToolTrackingStatusWidget" name="m_TrackingToolsStatusWidget" native="true">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                </widget>
               </item>
               <item>
                <layout class="QHBoxLayout" name="horizontalLayout_9">
                 <item>
                  <spacer name="horizontalSpacer_7">
                   <property name="orientation">
                    <enum>Qt::Horizontal</enum>
                   </property>
                   <property name="sizeHint" stdset="0">
                    <size>
                     <width>13</width>
                     <height>49</height>
                    </size>
                   </property>
                  </spacer>
                 </item>
                 <item>
                  <layout class="QVBoxLayout" name="verticalLayout">
                   <item>
                    <widget class="QPushButton" name="m_AutoDetectTools">
                     <property name="minimumSize">
                      <size>
                       <width>120</width>
                       <height>0</height>
                      </size>
                     </property>
                     <property name="text">
                      <string>Auto Detection</string>
                     </property>
                    </widget>
                   </item>
                   <item>
                    <widget class="QPushButton" name="m_AddSingleTool">
                     <property name="minimumSize">
                      <size>
                       <width>120</width>
                       <height>0</height>
                      </size>
                     </property>
                     <property name="text">
                      <string>Add Single Tool</string>
                     </property>
                    </widget>
                   </item>
                   <item>
                    <widget class="QPushButton" name="m_LoadTools">
                     <property name="minimumSize">
                      <size>
                       <width>120</width>
                       <height>0</height>
                      </size>
                     </property>
                     <property name="text">
                      <string>Load Tool Storage</string>
                     </property>
                    </widget>
                   </item>
                   <item>
                    <widget class="QPushButton" name="m_ResetTools">
                     <property name="minimumSize">
                      <size>
                       <width>120</width>
                       <height>0</height>
                      </size>
                     </property>
                     <property name="text">
                      <string>Reset</string>
                     </property>
                    </widget>
                   </item>
                  </layout>
                 </item>
                </layout>
               </item>
              </layout>
             </widget>
             <widget class="QWidget" name="page_2">
              <layout class="QVBoxLayout" name="verticalLayout_10">
               <item>
                <widget class="QmitkNavigationToolCreationWidget" name="m_NavigationToolCreationWidget" native="true"/>
               </item>
              </layout>
             </widget>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
-       <item row="2" column="0">
-        <widget class="QGroupBox" name="m_TrackingControlsGroupBox">
-         <property name="sizePolicy">
-          <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
+       <item>
+        <widget class="QFrame" name="m_TrackingControlsFrame">
+         <property name="frameShape">
+          <enum>QFrame::NoFrame</enum>
          </property>
-         <property name="title">
-          <string/>
+         <property name="frameShadow">
+          <enum>QFrame::Raised</enum>
          </property>
-         <layout class="QGridLayout" name="gridLayout_3">
-          <item row="1" column="0">
-           <widget class="QLabel" name="m_TrackingControlLabel">
-            <property name="text">
-             <string>Status: disconnected</string>
-            </property>
-           </widget>
-          </item>
-          <item row="0" column="0">
+         <layout class="QVBoxLayout" name="verticalLayout_3">
+          <item>
            <widget class="QLabel" name="label_3">
             <property name="font">
              <font>
               <pointsize>10</pointsize>
               <weight>75</weight>
               <bold>true</bold>
              </font>
             </property>
             <property name="text">
              <string>Tracking Control</string>
             </property>
             <property name="alignment">
              <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
             </property>
            </widget>
           </item>
-          <item row="2" column="0">
+          <item>
+           <widget class="QLabel" name="m_TrackingControlLabel">
+            <property name="text">
+             <string>Status: disconnected</string>
+            </property>
+           </widget>
+          </item>
+          <item>
            <layout class="QHBoxLayout" name="horizontalLayout">
             <item>
              <spacer name="horizontalSpacer_11">
               <property name="orientation">
                <enum>Qt::Horizontal</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>40</width>
                 <height>20</height>
                </size>
               </property>
              </spacer>
             </item>
             <item>
              <widget class="QPushButton" name="m_ConnectDisconnectButton">
               <property name="minimumSize">
                <size>
                 <width>142</width>
                 <height>0</height>
                </size>
               </property>
               <property name="text">
                <string>Connect</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
-          <item row="3" column="0">
+          <item>
            <layout class="QHBoxLayout" name="horizontalLayout_2">
             <item>
              <spacer name="horizontalSpacer_2">
               <property name="orientation">
                <enum>Qt::Horizontal</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>40</width>
                 <height>20</height>
                </size>
               </property>
              </spacer>
             </item>
             <item>
              <widget class="QPushButton" name="m_StartStopTrackingButton">
               <property name="minimumSize">
                <size>
                 <width>142</width>
                 <height>0</height>
                </size>
               </property>
               <property name="text">
                <string>Start Tracking</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
-          <item row="4" column="0">
+          <item>
            <layout class="QHBoxLayout" name="horizontalLayout_11">
             <item>
              <spacer name="horizontalSpacer_9">
               <property name="orientation">
                <enum>Qt::Horizontal</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>40</width>
                 <height>20</height>
                </size>
               </property>
              </spacer>
             </item>
             <item>
              <widget class="QLabel" name="m_TrackingFrozenLabel">
               <property name="text">
                <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;Tracking Frozen!&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QPushButton" name="m_FreezeUnfreezeTrackingButton">
               <property name="enabled">
                <bool>true</bool>
               </property>
               <property name="minimumSize">
                <size>
                 <width>142</width>
                 <height>0</height>
                </size>
               </property>
               <property name="text">
                <string>Freeze Tracking</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
-       <item row="0" column="0">
-        <widget class="QGroupBox" name="groupBox_3">
-         <property name="sizePolicy">
-          <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="minimumSize">
-          <size>
-           <width>0</width>
-           <height>0</height>
-          </size>
-         </property>
-         <property name="maximumSize">
-          <size>
-           <width>16777215</width>
-           <height>16777215</height>
-          </size>
-         </property>
-         <property name="title">
-          <string/>
-         </property>
-         <layout class="QGridLayout" name="gridLayout">
-          <item row="0" column="0">
-           <widget class="QmitkTrackingDeviceConfigurationWidget" name="m_ConfigurationWidget" native="true">
-            <property name="sizePolicy">
-             <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
-              <horstretch>0</horstretch>
-              <verstretch>0</verstretch>
-             </sizepolicy>
-            </property>
-           </widget>
-          </item>
-         </layout>
-        </widget>
-       </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_2">
       <attribute name="title">
        <string>Options</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_13">
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_12">
          <item>
           <widget class="QCheckBox" name="m_DisableAllTimers">
            <property name="text">
             <string>Disable All Timers</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QLabel" name="m_RenderWarningLabel">
            <property name="enabled">
             <bool>true</bool>
            </property>
            <property name="text">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p align=&quot;right&quot;&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;Rendering Disabled!&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="textFormat">
             <enum>Qt::AutoText</enum>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <widget class="QGroupBox" name="m_UpdateRateOptionsGroupBox">
          <property name="title">
           <string>Update Rate Options</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_14">
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_6">
             <item>
              <widget class="QLabel" name="m_OptionsUpdateRateLabel">
               <property name="text">
                <string>Update Rate [per second]</string>
               </property>
              </widget>
             </item>
             <item>
              <spacer name="horizontalSpacer_5">
               <property name="orientation">
                <enum>Qt::Horizontal</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>40</width>
                 <height>20</height>
                </size>
               </property>
              </spacer>
             </item>
             <item>
              <widget class="QSpinBox" name="m_UpdateRate">
               <property name="maximum">
                <number>100</number>
               </property>
               <property name="value">
                <number>10</number>
               </property>
              </widget>
             </item>
            </layout>
           </item>
           <item>
            <widget class="QCheckBox" name="m_UseDifferentUpdateRates">
             <property name="text">
              <string>Use different Render and Log Update Rates</string>
             </property>
            </widget>
           </item>
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_8" stretch="0,0,0">
             <item>
              <widget class="QLabel" name="m_OptionsRenderUpdateRateLabel">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="text">
                <string>Render Update Rate [fps]</string>
               </property>
              </widget>
             </item>
             <item>
              <spacer name="horizontalSpacer_3">
               <property name="orientation">
                <enum>Qt::Horizontal</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>40</width>
                 <height>20</height>
                </size>
               </property>
              </spacer>
             </item>
             <item>
              <widget class="QSpinBox" name="m_RenderUpdateRate">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="minimum">
                <number>0</number>
               </property>
               <property name="maximum">
                <number>100</number>
               </property>
               <property name="value">
                <number>10</number>
               </property>
              </widget>
             </item>
            </layout>
           </item>
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_10">
             <item>
              <widget class="QLabel" name="m_OptionsLogUpdateRateLabel">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="text">
                <string>Log Update Rate [per second]</string>
               </property>
              </widget>
             </item>
             <item>
              <spacer name="horizontalSpacer_8">
               <property name="orientation">
                <enum>Qt::Horizontal</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>40</width>
                 <height>20</height>
                </size>
               </property>
              </spacer>
             </item>
             <item>
              <widget class="QSpinBox" name="m_LogUpdateRate">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="minimum">
                <number>1</number>
               </property>
               <property name="maximum">
                <number>120</number>
               </property>
               <property name="singleStep">
                <number>10</number>
               </property>
               <property name="value">
                <number>60</number>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox">
          <property name="title">
           <string>Tracking Volume Options</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_7">
           <item>
            <widget class="QCheckBox" name="m_ShowTrackingVolume">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="text">
              <string>Show Tracking Volume</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QLabel" name="label_5">
             <property name="text">
              <string>Select Model:</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QComboBox" name="m_VolumeSelectionBox"/>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox_2">
          <property name="title">
           <string>Open IGT Link</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_15">
           <item>
            <widget class="QCheckBox" name="m_EnableOpenIGTLinkMicroService">
             <property name="text">
              <string>Enable Open IGT Link MicroService</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QLabel" name="label_7">
             <property name="text">
              <string>Select Open IGT Link Data Format:</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QComboBox" name="m_OpenIGTLinkDataFormat">
             <item>
              <property name="text">
               <string>TRANSFORM</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>QTDATA</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>TDATA</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>POSITION</string>
              </property>
             </item>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="m_OtherOptionsGroupBox">
          <property name="title">
           <string>Other Options</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_12">
           <item>
            <widget class="QCheckBox" name="m_ShowToolQuaternions">
             <property name="text">
              <string>Show Tool Quaternions</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QCheckBox" name="m_SimpleUI">
             <property name="text">
              <string>Simple UI</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QLabel" name="label_6">
             <property name="text">
              <string>Caution, only for backward compatibility:</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QCheckBox" name="m_InverseMode">
             <property name="text">
              <string>Inverse mode (Quaternions are stored inverse)</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox_5">
          <property name="title">
           <string>Tool Visualization Options</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_17">
           <item>
            <widget class="QCheckBox" name="showHideToolProjectionCheckBox">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="text">
              <string>Show Tool Projection</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QCheckBox" name="showHideToolAxisCheckBox">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="text">
              <string>Show Tool Axis</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_3">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>600</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_3">
       <attribute name="title">
        <string>Logging</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_8">
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_4">
          <item>
           <widget class="QLabel" name="label">
            <property name="text">
             <string>Filename:</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QLineEdit" name="m_LoggingFileName"/>
          </item>
          <item>
           <widget class="QPushButton" name="m_ChooseFile">
            <property name="text">
             <string>Choose File</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_7">
          <item>
           <widget class="QCheckBox" name="m_LoggingLimit">
            <property name="text">
             <string>Limit Number Of Logged Frames:</string>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer_6">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QSpinBox" name="m_LoggedFramesLimit">
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>9999</number>
            </property>
            <property name="value">
             <number>300</number>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <widget class="QRadioButton" name="m_CsvFormat">
          <property name="text">
           <string>CSV format</string>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QRadioButton" name="m_XmlFormat">
          <property name="text">
           <string>XML format</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="m_SkipInvalidData">
          <property name="text">
           <string>Skip invalid data</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox_4">
          <property name="title">
           <string>Logging Status</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_6">
           <item>
            <widget class="QLabel" name="m_LoggingLabel">
             <property name="text">
              <string>Logging OFF</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QLabel" name="m_LoggedFramesLabel">
             <property name="text">
              <string>Logged Frames: 0</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_5">
          <item>
           <spacer name="horizontalSpacer_4">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QPushButton" name="m_StartLogging">
            <property name="text">
             <string>Start Logging</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="m_StopLogging">
            <property name="text">
             <string>Stop Logging</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
   <widget class="QWidget" name="m_simpleWidget" native="true">
    <property name="geometry">
     <rect>
      <x>9</x>
-     <y>810</y>
+     <y>742</y>
      <width>303</width>
      <height>70</height>
     </rect>
    </property>
    <layout class="QGridLayout" name="gridLayout_4">
     <item row="0" column="0">
      <layout class="QHBoxLayout" name="horizontalLayout_25">
       <item>
        <widget class="QPushButton" name="m_ConnectSimpleMode">
         <property name="minimumSize">
          <size>
           <width>70</width>
           <height>50</height>
          </size>
         </property>
         <property name="text">
          <string>Connect</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QPushButton" name="m_StartTrackingSimpleMode">
         <property name="minimumSize">
          <size>
           <width>70</width>
           <height>50</height>
          </size>
         </property>
         <property name="text">
          <string>Start
 Tracking</string>
         </property>
        </widget>
       </item>
       <item>
        <spacer name="horizontalSpacer_21">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item>
        <widget class="QPushButton" name="m_advancedUI">
         <property name="minimumSize">
          <size>
           <width>70</width>
           <height>50</height>
          </size>
         </property>
         <property name="text">
          <string>Advanced
 Mode</string>
         </property>
        </widget>
       </item>
      </layout>
     </item>
    </layout>
   </widget>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>QmitkToolTrackingStatusWidget</class>
    <extends>QWidget</extends>
    <header>QmitkToolTrackingStatusWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkTrackingDeviceConfigurationWidget</class>
    <extends>QWidget</extends>
    <header>QmitkTrackingDeviceConfigurationWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkNavigationToolCreationWidget</class>
    <extends>QWidget</extends>
    <header>QmitkNavigationToolCreationWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>