diff --git a/Modules/SegmentationUI/Qmitk/QmitkToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkToolGUI.cpp
index 4cf5e9e968..0b87a9a734 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkToolGUI.cpp
@@ -1,42 +1,47 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkToolGUI.h"
 
 #include <iostream>
 
 QmitkToolGUI::~QmitkToolGUI()
 {
   m_ReferenceCount = 0; // otherwise ITK will complain in LightObject's destructor
 }
 
 void QmitkToolGUI::Register() const
 {
   // empty on purpose, just don't let ITK handle calls to Register()
 }
 
 void QmitkToolGUI::UnRegister() const ITK_NOEXCEPT
 {
   // empty on purpose, just don't let ITK handle calls to UnRegister()
 }
 
 void QmitkToolGUI::SetReferenceCount(int)
 {
   // empty on purpose, just don't let ITK handle calls to SetReferenceCount()
 }
 
 void QmitkToolGUI::SetTool(mitk::Tool *tool)
 {
   m_Tool = tool;
 
   emit(NewToolAssociated(tool));
 }
+
+bool QmitkToolGUI::ConfirmExit()
+{
+  return true;
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkToolGUI.h
index f47df87bc5..fa55575dc0 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkToolGUI.h
@@ -1,59 +1,60 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkToolGUI_h
 #define QmitkToolGUI_h
 
 #include <MitkSegmentationUIExports.h>
 #include <qwidget.h>
 
 #include "mitkCommon.h"
 #include "mitkTool.h"
 
 /**
   \brief Base class for GUIs belonging to mitk::Tool classes.
 
   \ingroup org_mitk_gui_qt_interactivesegmentation
 
   Created through ITK object factory. TODO May be changed to a toolkit specific way later?
 
   Last contributor: $Author$
 */
 
 class MITKSEGMENTATIONUI_EXPORT QmitkToolGUI : public QWidget, public itk::Object
 {
   Q_OBJECT
 
 public:
   mitkClassMacroItkParent(QmitkToolGUI, itk::Object);
 
   void SetTool(mitk::Tool *tool);
 
   // just make sure ITK won't take care of anything (especially not destruction)
   void Register() const override;
   void UnRegister() const ITK_NOEXCEPT ITK_OVERRIDE;
   void SetReferenceCount(int) override;
 
   ~QmitkToolGUI() override;
+  virtual bool ConfirmExit();
 
 signals:
   void NewToolAssociated(mitk::Tool *);
 
 protected:
   QmitkToolGUI() = default;
 
   mitk::Tool::Pointer m_Tool;
 
   virtual void BusyStateChanged(bool){};
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.cpp b/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.cpp
index 995433d58e..4aa348ee9f 100755
--- a/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.cpp
@@ -1,623 +1,627 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 //#define MBILOG_ENABLE_DEBUG 1
 
 #include <QmitkStyleManager.h>
 #include "QmitkToolSelectionBox.h"
 #include "QmitkToolGUI.h"
 #include "mitkBaseRenderer.h"
 
 #include <QList>
 #include <QApplication>
 #include <QLayout>
 #include <QMessageBox>
 #include <QToolButton>
 #include <QToolTip>
 #include <QRegularExpression>
 
 #include <queue>
 
 #include "usModuleResource.h"
 #include "usModuleResourceStream.h"
 
 #include "mitkToolManagerProvider.h"
 
 QmitkToolSelectionBox::QmitkToolSelectionBox(QWidget *parent, mitk::DataStorage *)
   : QWidget(parent),
     m_SelfCall(false),
     m_DisplayedGroups("default"),
     m_LayoutColumns(2),
     m_ShowNames(true),
     m_GenerateAccelerators(false),
     m_ToolGUIWidget(nullptr),
     m_LastToolGUI(nullptr),
     m_ToolButtonGroup(nullptr),
     m_ButtonLayout(nullptr)
 {
   QFont currentFont = QWidget::font();
   currentFont.setBold(true);
   QWidget::setFont(currentFont);
 
   m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
 
   // QButtonGroup
   m_ToolButtonGroup = new QButtonGroup(this);
   // some features of QButtonGroup
   m_ToolButtonGroup->setExclusive(false); // mutually exclusive toggle buttons
 
   RecreateButtons();
 
   QWidget::setContentsMargins(0, 0, 0, 0);
   if (layout() != nullptr)
   {
     layout()->setContentsMargins(0, 0, 0, 0);
   }
 
   // reactions to signals
   connect(m_ToolButtonGroup, &QButtonGroup::idClicked, this, &QmitkToolSelectionBox::toolButtonClicked);
 
   // reactions to ToolManager events
 
   m_ToolManager->ActiveToolChanged +=
     mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerToolModified);
   m_ToolManager->ReferenceDataChanged +=
     mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified);
   m_ToolManager->WorkingDataChanged +=
     mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified);
 
   // show active tool
   SetOrUnsetButtonForActiveTool();
 
   QWidget::setEnabled(false);
 }
 
 QmitkToolSelectionBox::~QmitkToolSelectionBox()
 {
   m_ToolManager->ActiveToolChanged -=
     mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerToolModified);
   m_ToolManager->ReferenceDataChanged -=
     mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified);
   m_ToolManager->WorkingDataChanged -=
     mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified);
 }
 
 mitk::ToolManager *QmitkToolSelectionBox::GetToolManager()
 {
   return m_ToolManager;
 }
 
 void QmitkToolSelectionBox::SetToolManager(
   mitk::ToolManager &newManager) // no nullptr pointer allowed here, a manager is required
 {
   // say bye to the old manager
   m_ToolManager->ActiveToolChanged -=
     mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerToolModified);
   m_ToolManager->ReferenceDataChanged -=
     mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified);
   m_ToolManager->WorkingDataChanged -=
     mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified);
 
   if (QWidget::isEnabled())
   {
     m_ToolManager->UnregisterClient();
   }
 
   m_ToolManager = &newManager;
   RecreateButtons();
 
   // greet the new one
   m_ToolManager->ActiveToolChanged +=
     mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerToolModified);
   m_ToolManager->ReferenceDataChanged +=
     mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerReferenceDataModified);
   m_ToolManager->WorkingDataChanged +=
     mitk::MessageDelegate<QmitkToolSelectionBox>(this, &QmitkToolSelectionBox::OnToolManagerWorkingDataModified);
 
   if (QWidget::isEnabled())
   {
     m_ToolManager->RegisterClient();
   }
 
   // ask the new one what the situation is like
   SetOrUnsetButtonForActiveTool();
 }
 
 void QmitkToolSelectionBox::toolButtonClicked(int id)
 {
   if (!QWidget::isEnabled())
     return; // this method could be triggered from the constructor, when we are still disabled
 
   MITK_DEBUG << "toolButtonClicked(" << id << "): id translates to tool ID " << m_ToolIDForButtonID[id];
-
+  if (m_LastToolGUI && !m_LastToolGUI->ConfirmExit())
+  {
+    return;
+  }
+  
   QToolButton *toolButton = dynamic_cast<QToolButton *>(m_ToolButtonGroup->buttons().at(id));
   if (toolButton)
   {
     if ((m_ButtonIDForToolID.find(m_ToolManager->GetActiveToolID()) !=
          m_ButtonIDForToolID.end()) // if we have this tool in our box
         &&
         (m_ButtonIDForToolID[m_ToolManager->GetActiveToolID()] ==
          id)) // the tool corresponding to this button is already active
     {
       // disable this button, disable all tools
       toolButton->setChecked(false);
       m_ToolManager->ActivateTool(-1); // disable everything
     }
     else
     {
       // enable the corresponding tool
       m_SelfCall = true;
 
       m_ToolManager->ActivateTool(m_ToolIDForButtonID[id]);
 
       m_SelfCall = false;
     }
   }
 }
 
 void QmitkToolSelectionBox::OnToolManagerToolModified()
 {
   SetOrUnsetButtonForActiveTool();
 }
 
 void QmitkToolSelectionBox::SetOrUnsetButtonForActiveTool()
 {
   // we want to emit a signal in any case, whether we selected ourselves or somebody else changes "our" tool manager.
   // --> emit before check on m_SelfCall
   int id = m_ToolManager->GetActiveToolID();
 
   // don't emit signal for shape model tools
   bool emitSignal = true;
   mitk::Tool *tool = m_ToolManager->GetActiveTool();
   if (tool && std::string(tool->GetGroup()) == "organ_segmentation")
     emitSignal = false;
 
   if (emitSignal)
     emit ToolSelected(id);
 
   // delete old GUI (if any)
   if (m_LastToolGUI && m_ToolGUIWidget)
   {
     if (m_ToolGUIWidget->layout())
     {
       m_ToolGUIWidget->layout()->removeWidget(m_LastToolGUI);
     }
 
     m_LastToolGUI->setParent(nullptr);
     delete m_LastToolGUI; // will hopefully notify parent and layouts
     m_LastToolGUI = nullptr;
 
     QLayout *layout = m_ToolGUIWidget->layout();
     if (layout)
     {
       layout->activate();
     }
   }
 
   QToolButton *toolButton(nullptr);
 
   if (m_ButtonIDForToolID.find(id) != m_ButtonIDForToolID.end()) // if this tool is in our box
   {
     toolButton = dynamic_cast<QToolButton *>(m_ToolButtonGroup->buttons().at(m_ButtonIDForToolID[id]));
   }
 
   if (toolButton)
   {
     // mmueller
     // uncheck all other buttons
     QAbstractButton *tmpBtn = nullptr;
 
     for (int i = 0; i < m_ToolButtonGroup->buttons().size(); ++i)
     {
       tmpBtn = m_ToolButtonGroup->buttons().at(i);
       if (tmpBtn != toolButton)
         dynamic_cast<QToolButton *>(tmpBtn)->setChecked(false);
     }
 
     toolButton->setChecked(true);
 
     if (m_ToolGUIWidget && tool)
     {
       // create and reparent new GUI (if any)
       itk::Object::Pointer possibleGUI = tool->GetGUI("Qmitk", "GUI").GetPointer(); // prefix and postfix
 
       if (possibleGUI.IsNull())
         possibleGUI = tool->GetGUI("", "GUI").GetPointer();
 
       QmitkToolGUI *gui = dynamic_cast<QmitkToolGUI *>(possibleGUI.GetPointer());
 
       //!
       m_LastToolGUI = gui;
       if (gui)
       {
         gui->SetTool(tool);
 
         gui->setParent(m_ToolGUIWidget);
         gui->move(gui->geometry().topLeft());
         gui->show();
 
         QLayout *layout = m_ToolGUIWidget->layout();
         if (!layout)
         {
           layout = new QVBoxLayout(m_ToolGUIWidget);
         }
         if (layout)
         {
           layout->addWidget(gui);
           layout->activate();
         }
       }
     }
   }
   else
   {
     // disable all buttons
     QToolButton *selectedToolButton = dynamic_cast<QToolButton *>(m_ToolButtonGroup->checkedButton());
     if (selectedToolButton)
     {
       selectedToolButton->setChecked(false);
     }
   }
 }
 
 void QmitkToolSelectionBox::OnToolManagerReferenceDataModified()
 {
   if (m_SelfCall)
     return;
 
   MITK_DEBUG << "OnToolManagerReferenceDataModified()";
 
   this->UpdateButtonsEnabledState();
 }
 
 void QmitkToolSelectionBox::OnToolManagerWorkingDataModified()
 {
   if (m_SelfCall)
     return;
 
   MITK_DEBUG << "OnToolManagerWorkingDataModified()";
 
   this->UpdateButtonsEnabledState();
 }
 
 void QmitkToolSelectionBox::setEnabled(bool enable)
 {
   if (QWidget::isEnabled() == enable)
     return;
 
   QWidget::setEnabled(enable);
 
   if (enable)
   {
     m_ToolManager->RegisterClient();
 
     auto id = m_ToolManager->GetActiveToolID();
     emit ToolSelected(id);
   }
   else
   {
     m_ToolManager->ActivateTool(-1);
     m_ToolManager->UnregisterClient();
 
     emit ToolSelected(-1);
   }
 }
 
 void QmitkToolSelectionBox::UpdateButtonsEnabledState()
 {
   auto buttons = m_ToolButtonGroup->buttons();
 
   const auto refDataNode = m_ToolManager->GetReferenceData(0);
   const mitk::BaseData* refData = nullptr;
   if (nullptr != refDataNode)
   {
     refData = refDataNode->GetData();
   }
 
   const auto workingDataNode = m_ToolManager->GetWorkingData(0);
   const mitk::BaseData* workingData = nullptr;
   if (nullptr != workingDataNode)
   {
     workingData = workingDataNode->GetData();
   }
 
   for (const auto& button : std::as_const(buttons))
   {
     const auto buttonID = m_ToolButtonGroup->id(button);
     const auto toolID = m_ToolIDForButtonID[buttonID];
     const auto tool = m_ToolManager->GetToolById(toolID);
 
     button->setEnabled(tool->CanHandle(refData, workingData));
   }
 }
 
 void QmitkToolSelectionBox::RecreateButtons()
 {
   if (m_ToolManager.IsNull())
     return;
 
   QList<QAbstractButton *> l = m_ToolButtonGroup->buttons();
   // remove all buttons that are there
   QList<QAbstractButton *>::iterator it;
   QAbstractButton *btn;
 
   for (it = l.begin(); it != l.end(); ++it)
   {
     btn = *it;
     m_ToolButtonGroup->removeButton(btn);
     delete btn;
   }
 
   mitk::ToolManager::ToolVectorTypeConst allPossibleTools = m_ToolManager->GetTools();
   mitk::ToolManager::ToolVectorTypeConst allTools;
 
   typedef std::pair<std::string::size_type, const mitk::Tool *> SortPairType;
   typedef std::priority_queue<SortPairType> SortedToolQueueType;
   SortedToolQueueType toolPositions;
 
   // clear and sort all tools
   // step one: find name/group of all tools in m_DisplayedGroups string. remember these positions for all tools.
   for (mitk::ToolManager::ToolVectorTypeConst::const_iterator iter = allPossibleTools.begin();
        iter != allPossibleTools.end();
        ++iter)
   {
     const mitk::Tool *tool = *iter;
 
     std::string::size_type namePos = m_DisplayedGroups.find(std::string("'") + tool->GetName() + "'");
     std::string::size_type groupPos = m_DisplayedGroups.find(std::string("'") + tool->GetGroup() + "'");
 
     if (!m_DisplayedGroups.empty() && namePos == std::string::npos && groupPos == std::string::npos)
       continue; // skip
 
     if (m_DisplayedGroups.empty() && std::string(tool->GetName()).length() > 0)
     {
       namePos = static_cast<std::string::size_type>(tool->GetName()[0]);
     }
 
     SortPairType thisPair = std::make_pair(namePos < groupPos ? namePos : groupPos, *iter);
     toolPositions.push(thisPair);
   }
 
   // step two: sort tools according to previously found positions in m_DisplayedGroups
   MITK_DEBUG << "Sorting order of tools (lower number --> earlier in button group)";
   while (!toolPositions.empty())
   {
     SortPairType thisPair = toolPositions.top();
     MITK_DEBUG << "Position " << thisPair.first << " : " << thisPair.second->GetName();
 
     allTools.push_back(thisPair.second);
     toolPositions.pop();
   }
   std::reverse(allTools.begin(), allTools.end());
 
   MITK_DEBUG << "Sorted tools:";
   for (mitk::ToolManager::ToolVectorTypeConst::const_iterator iter = allTools.begin(); iter != allTools.end(); ++iter)
   {
     MITK_DEBUG << (*iter)->GetName();
   }
 
   if (m_ButtonLayout == nullptr)
     m_ButtonLayout = new QGridLayout;
 
   int row(0);
   int column(-1);
 
   int currentButtonID(0);
   m_ButtonIDForToolID.clear();
   m_ToolIDForButtonID.clear();
   QToolButton *button = nullptr;
 
   MITK_DEBUG << "Creating buttons for tools";
   // fill group box with buttons
   for (mitk::ToolManager::ToolVectorTypeConst::const_iterator iter = allTools.begin(); iter != allTools.end(); ++iter)
   {
     const mitk::Tool *tool = *iter;
     int currentToolID(m_ToolManager->GetToolID(tool));
 
     ++column;
     // new line if we are at the maximum columns
     if (column == m_LayoutColumns)
     {
       ++row;
       column = 0;
     }
 
     button = new QToolButton;
     button->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum));
     // add new button to the group
     MITK_DEBUG << "Adding button with ID " << currentToolID;
     m_ToolButtonGroup->addButton(button, currentButtonID);
     // ... and to the layout
     MITK_DEBUG << "Adding button in row/column " << row << "/" << column;
     m_ButtonLayout->addWidget(button, row, column);
 
     if (m_LayoutColumns == 1)
     {
       button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
     }
     else
     {
       button->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
     }
 
     button->setCheckable(true);
 
     if (currentToolID == m_ToolManager->GetActiveToolID())
       button->setChecked(true);
 
     QString label;
     if (m_GenerateAccelerators)
     {
       label += "&";
     }
     label += tool->GetName();
     QString tooltip = tool->GetName();
     MITK_DEBUG << tool->GetName() << ", " << label.toLocal8Bit().constData() << ", '"
                << tooltip.toLocal8Bit().constData();
 
     if (m_ShowNames)
     {
       button->setText(label); // a label
       button->setToolTip(tooltip);
 
       QFont currentFont = button->font();
       currentFont.setBold(false);
       button->setFont(currentFont);
     }
 
     us::ModuleResource iconResource = tool->GetIconResource();
 
     if (!iconResource.IsValid())
     {
       button->setIcon(QIcon(QPixmap(tool->GetXPM())));
     }
     else
     {
       auto isSVG = "svg" == iconResource.GetSuffix();
       auto openmode = isSVG ? std::ios_base::in : std::ios_base::binary;
 
       us::ModuleResourceStream resourceStream(iconResource, openmode);
       resourceStream.seekg(0, std::ios::end);
       std::ios::pos_type length = resourceStream.tellg();
       resourceStream.seekg(0, std::ios::beg);
 
       char *data = new char[length];
       resourceStream.read(data, length);
 
       if (isSVG)
       {
         button->setIcon(QmitkStyleManager::ThemeIcon(QByteArray::fromRawData(data, length)));
       }
       else
       {
         QPixmap pixmap;
         pixmap.loadFromData(QByteArray::fromRawData(data, length));
         button->setIcon(QIcon(pixmap));
       }
 
       delete[] data;
 
       if (m_ShowNames)
       {
         if (m_LayoutColumns == 1)
           button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
         else
           button->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
 
         button->setIconSize(QSize(24, 24));
       }
       else
       {
         button->setToolButtonStyle(Qt::ToolButtonIconOnly);
         button->setIconSize(QSize(32, 32));
         button->setToolTip(tooltip);
       }
     }
 
     if (m_GenerateAccelerators)
     {
       QString firstLetter = QString(tool->GetName());
       firstLetter.truncate(1);
       button->setShortcut(
         firstLetter); // a keyboard shortcut (just the first letter of the given name w/o any CTRL or something)
     }
 
     m_ButtonIDForToolID[currentToolID] = currentButtonID;
     m_ToolIDForButtonID[currentButtonID] = currentToolID;
 
     MITK_DEBUG << "m_ButtonIDForToolID[" << currentToolID << "] == " << currentButtonID;
     MITK_DEBUG << "m_ToolIDForButtonID[" << currentButtonID << "] == " << currentToolID;
 
     tool->GUIProcessEventsMessage += mitk::MessageDelegate<QmitkToolSelectionBox>(
       this, &QmitkToolSelectionBox::OnToolGUIProcessEventsMessage); // will never add a listener twice, so we don't have
                                                                     // to check here
     tool->ErrorMessage += mitk::MessageDelegate1<QmitkToolSelectionBox, std::string>(
       this,
       &QmitkToolSelectionBox::OnToolErrorMessage); // will never add a listener twice, so we don't have to check here
     tool->GeneralMessage +=
       mitk::MessageDelegate1<QmitkToolSelectionBox, std::string>(this, &QmitkToolSelectionBox::OnGeneralToolMessage);
 
     ++currentButtonID;
   }
   // setting grid layout for this groupbox
   this->setLayout(m_ButtonLayout);
 
   this->UpdateButtonsEnabledState();
   // this->update();
 }
 
 void QmitkToolSelectionBox::OnToolGUIProcessEventsMessage()
 {
   qApp->processEvents();
 }
 
 void QmitkToolSelectionBox::OnToolErrorMessage(std::string s)
 {
   QMessageBox::critical(
     this, "MITK", QString(s.c_str()), QMessageBox::Ok | QMessageBox::NoButton, QMessageBox::NoButton);
 }
 
 void QmitkToolSelectionBox::OnGeneralToolMessage(std::string s)
 {
   QMessageBox::information(
     this, "MITK", QString(s.c_str()), QMessageBox::Ok | QMessageBox::NoButton, QMessageBox::NoButton);
 }
 
 void QmitkToolSelectionBox::SetDisplayedToolGroups(const std::string &toolGroups)
 {
   if (m_DisplayedGroups != toolGroups)
   {
     QString q_DisplayedGroups = toolGroups.c_str();
     // quote all unquoted single words
     q_DisplayedGroups = q_DisplayedGroups.replace(QRegularExpression("\\b(\\w+)\\b|'([^']+)'"), "'\\1\\2'");
     MITK_DEBUG << "m_DisplayedGroups was \"" << toolGroups << "\"";
 
     m_DisplayedGroups = q_DisplayedGroups.toLocal8Bit().constData();
     MITK_DEBUG << "m_DisplayedGroups is \"" << m_DisplayedGroups << "\"";
 
     RecreateButtons();
     SetOrUnsetButtonForActiveTool();
   }
 }
 
 void QmitkToolSelectionBox::SetLayoutColumns(int columns)
 {
   if (columns > 0 && columns != m_LayoutColumns)
   {
     m_LayoutColumns = columns;
     RecreateButtons();
   }
 }
 
 void QmitkToolSelectionBox::SetShowNames(bool show)
 {
   if (show != m_ShowNames)
   {
     m_ShowNames = show;
     RecreateButtons();
   }
 }
 
 void QmitkToolSelectionBox::SetGenerateAccelerators(bool accel)
 {
   if (accel != m_GenerateAccelerators)
   {
     m_GenerateAccelerators = accel;
     RecreateButtons();
   }
 }
 
 void QmitkToolSelectionBox::SetToolGUIArea(QWidget *parentWidget)
 {
   m_ToolGUIWidget = parentWidget;
 }
 
diff --git a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp
index 2d2bdb4f75..d36b564780 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp
@@ -1,497 +1,513 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkTotalSegmentatorToolGUI.h"
 
 #include "mitkProcessExecutor.h"
 #include "mitkTotalSegmentatorTool.h"
 #include <QApplication>
 #include <QDir>
 #include <QDirIterator>
 #include <QFileDialog>
 #include <QIcon>
 #include <QmitkStyleManager.h>
 #include <QMessageBox>
 
 MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkTotalSegmentatorToolGUI, "")
 
 QmitkTotalSegmentatorToolGUI::QmitkTotalSegmentatorToolGUI()
   : QmitkMultiLabelSegWithPreviewToolGUIBase(), m_SuperclassEnableConfirmSegBtnFnc(m_EnableConfirmSegBtnFnc)
 {
   // Nvidia-smi command returning zero doesn't always imply lack of GPUs.
   // Pytorch uses its own libraries to communicate to the GPUs. Hence, only a warning can be given.
   if (m_GpuLoader.GetGPUCount() == 0)
   {
     std::string warning = "WARNING: No GPUs were detected on your machine. The TotalSegmentator tool can be very slow.";
     this->ShowErrorMessage(warning);
   }
   m_EnableConfirmSegBtnFnc = [this](bool enabled)
   { return !m_FirstPreviewComputation ? m_SuperclassEnableConfirmSegBtnFnc(enabled) : false; };
 }
 
 void QmitkTotalSegmentatorToolGUI::ConnectNewTool(mitk::SegWithPreviewTool *newTool)
 {
   Superclass::ConnectNewTool(newTool);
   m_FirstPreviewComputation = true;
 }
 
+bool QmitkTotalSegmentatorToolGUI::ConfirmExit()
+{
+  if (m_FirstPreviewComputation)
+    return true;
+  else if (QMessageBox::Yes ==
+           QMessageBox::question(nullptr,
+                                 "TotalSegmentator",
+                                 QString("WARNING: There might unconfirmed labels after Preview. Are you sure you want to exit the tool?"),
+                                 QMessageBox::Yes | QMessageBox::No,
+                                 QMessageBox::No))
+  {
+    return true;
+  }
+  return false;
+}
+
 void QmitkTotalSegmentatorToolGUI::InitializeUI(QBoxLayout *mainLayout)
 {
   m_Controls.setupUi(this);
 #ifndef _WIN32
   m_Controls.sysPythonComboBox->addItem("/usr/bin");
 #endif
   this->AutoParsePythonPaths();
   m_Controls.sysPythonComboBox->addItem("Select");
   m_Controls.sysPythonComboBox->setCurrentIndex(0);
   m_Controls.pythonEnvComboBox->addItem("Select");
   m_Controls.pythonEnvComboBox->setDuplicatesEnabled(false);
   m_Controls.pythonEnvComboBox->setDisabled(true);
   m_Controls.previewButton->setDisabled(true);
   m_Controls.statusLabel->setTextFormat(Qt::RichText);
   m_Controls.subtaskComboBox->addItems(VALID_TASKS);
   QString welcomeText;
   this->SetGPUInfo();
   if (m_GpuLoader.GetGPUCount() != 0)
   {
     welcomeText = "<b>STATUS: </b><i>Welcome to TotalSegmentator tool. You're in luck: " +
                                QString::number(m_GpuLoader.GetGPUCount()) + " GPU(s) were detected.</i>";
   }
   else
   {
     welcomeText = "<b>STATUS: </b><i>Welcome to TotalSegmentator tool. Sorry, " +
                               QString::number(m_GpuLoader.GetGPUCount()) + " GPUs were detected.</i>";
   }
 
   connect(m_Controls.previewButton, SIGNAL(clicked()), this, SLOT(OnPreviewBtnClicked()));
   connect(m_Controls.clearButton, SIGNAL(clicked()), this, SLOT(OnClearInstall()));
   connect(m_Controls.installButton, SIGNAL(clicked()), this, SLOT(OnInstallBtnClicked()));
   connect(m_Controls.overrideBox, SIGNAL(stateChanged(int)), this, SLOT(OnOverrideChecked(int)));
   connect(m_Controls.pythonEnvComboBox,
           QOverload<int>::of(&QComboBox::activated),
           [=](int index) { OnPythonPathChanged(m_Controls.pythonEnvComboBox->itemText(index)); });
   connect(m_Controls.sysPythonComboBox,
           QOverload<int>::of(&QComboBox::activated),
           [=](int index) { OnSystemPythonChanged(m_Controls.sysPythonComboBox->itemText(index)); });
 
   QString lastSelectedPyEnv = m_Settings.value("TotalSeg/LastCustomPythonPath").toString();
   if (!lastSelectedPyEnv.isEmpty() && lastSelectedPyEnv!= "Select")
   {
     m_Controls.pythonEnvComboBox->insertItem(0, lastSelectedPyEnv);
   }
   const QString storageDir = m_Installer.GetVirtualEnvPath();
   m_IsInstalled = this->IsTotalSegmentatorInstalled(storageDir);
   if (m_IsInstalled)
   {
     m_PythonPath = QmitkSetupVirtualEnvUtil::GetExactPythonPath(storageDir).first;
     m_Installer.SetVirtualEnvPath(m_PythonPath);
     this->EnableAll(m_IsInstalled);
     welcomeText += " TotalSegmentator is already found installed."; 
   }
   else
   {
     welcomeText += " TotalSegmentator is not installed. Please click on \"Install TotalSegmentator\" above.";
   }
   this->WriteStatusMessage(welcomeText);
 
   QIcon deleteIcon =
     QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/edit-delete.svg"));
   QIcon arrowIcon =
     QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/tango/scalable/actions/media-playback-start.svg"));
   m_Controls.clearButton->setIcon(deleteIcon);
   m_Controls.previewButton->setIcon(arrowIcon);
 
   mainLayout->addLayout(m_Controls.verticalLayout);
   Superclass::InitializeUI(mainLayout);
 }
 
 void QmitkTotalSegmentatorToolGUI::SetGPUInfo()
 {
   std::vector<QmitkGPUSpec> specs = m_GpuLoader.GetAllGPUSpecs();
   for (const QmitkGPUSpec &gpuSpec : specs)
   {
     m_Controls.gpuComboBox->addItem(QString::number(gpuSpec.id) + ": " + gpuSpec.name + " (" + gpuSpec.memory + ")");
   }
   if (specs.empty())
   {
     m_Controls.gpuComboBox->setEditable(true);
     m_Controls.gpuComboBox->addItem(QString::number(0));
     m_Controls.gpuComboBox->setValidator(new QIntValidator(0, 999, this));
   }
 }
 
 unsigned int QmitkTotalSegmentatorToolGUI::FetchSelectedGPUFromUI() const
 {
   QString gpuInfo = m_Controls.gpuComboBox->currentText();
   if (m_GpuLoader.GetGPUCount() == 0)
   {
     return static_cast<unsigned int>(gpuInfo.toInt());
   }
   else
   {
     QString gpuId = gpuInfo.split(":", Qt::SkipEmptyParts).first();
     return static_cast<unsigned int>(gpuId.toInt());
   }
 }
 
 void QmitkTotalSegmentatorToolGUI::EnableAll(bool isEnable)
 {
   m_Controls.previewButton->setEnabled(isEnable);
   m_Controls.subtaskComboBox->setEnabled(isEnable);
   m_Controls.installButton->setEnabled((!isEnable));
 }
 
 void QmitkTotalSegmentatorToolGUI::OnInstallBtnClicked()
 {
   bool isInstalled = false;
   const auto [path, version] = OnSystemPythonChanged(m_Controls.sysPythonComboBox->currentText());
   if (path.isEmpty())
   {
     this->WriteErrorMessage("<b>ERROR: </b>Couldn't find compatible Python.");
     return;
   }
   // check if python 3.12 and ask for confirmation
   if (version.startsWith("3.12") &&
       QMessageBox::No == QMessageBox::question(
                           nullptr,
                           "Installing TotalSegmentator",
                           QString("WARNING: This is an unsupported version of Python that may not work. "
                                   "We recommend using a supported Python version between 3.9 and 3.11.\n\n"
                                   "Continue anyway?"),
                           QMessageBox::Yes | QMessageBox::No,
                           QMessageBox::No))
   {
     return;
   }
   this->WriteStatusMessage("<b>STATUS: </b>Installing TotalSegmentator...");
   m_Installer.SetSystemPythonPath(path);
   isInstalled = m_Installer.SetupVirtualEnv(m_Installer.VENV_NAME);
   if (isInstalled)
   {
     m_PythonPath = QmitkSetupVirtualEnvUtil::GetExactPythonPath(m_Installer.GetVirtualEnvPath()).first;
     this->WriteStatusMessage("<b>STATUS: </b>Successfully installed TotalSegmentator.");
   }
   else
   {
     this->WriteErrorMessage("<b>ERROR: </b>Couldn't install TotalSegmentator.");
   }
   this->EnableAll(isInstalled);
 }
 
 void QmitkTotalSegmentatorToolGUI::OnPreviewBtnClicked()
 {
   auto tool = this->GetConnectedToolAs<mitk::TotalSegmentatorTool>();
   if (nullptr == tool)
   {
     return;
   }
   try
   {
     m_Controls.previewButton->setEnabled(false);
     qApp->processEvents();
     if (!this->IsTotalSegmentatorInstalled(m_PythonPath))
     {
       throw std::runtime_error(WARNING_TOTALSEG_NOT_FOUND);
     }
     bool isFast = m_Controls.fastBox->isChecked();
     QString subTask = m_Controls.subtaskComboBox->currentText();
     if (subTask != VALID_TASKS[0])
     {
       isFast = true;
     }
     tool->SetPythonPath(m_PythonPath.toStdString());
     tool->SetGpuId(FetchSelectedGPUFromUI());
     tool->SetFast(isFast);
     tool->SetSubTask(subTask.toStdString());
     this->WriteStatusMessage(QString("<b>STATUS: </b><i>Starting Segmentation task... This might take a while.</i>"));
     tool->UpdatePreview();
     m_Controls.previewButton->setEnabled(true);
     m_FirstPreviewComputation = false;
   }
   catch (const std::exception &e)
   {
     std::stringstream errorMsg;
     errorMsg << "<b>STATUS: </b>Error while processing parameters for TotalSegmentator segmentation. Reason: "
              << e.what();
     this->ShowErrorMessage(errorMsg.str());
     this->WriteErrorMessage(QString::fromStdString(errorMsg.str()));
     m_Controls.previewButton->setEnabled(true);
     return;
   }
   catch (...)
   {
     std::string errorMsg = "Unkown error occured while generation TotalSegmentator segmentation.";
     this->ShowErrorMessage(errorMsg);
     m_Controls.previewButton->setEnabled(true);
     return;
   }
   this->SetLabelSetPreview(tool->GetPreviewSegmentation());
   this->ActualizePreviewLabelVisibility();
   this->WriteStatusMessage("<b>STATUS: </b><i>Segmentation task finished successfully.</i>");
   QString pythonPathTextItem = m_Controls.pythonEnvComboBox->currentText();
   if (!pythonPathTextItem.isEmpty() && pythonPathTextItem != "Select") // only cache if the prediction ended without errors.
   {
     QString lastSelectedPyEnv = m_Settings.value("TotalSeg/LastCustomPythonPath").toString();
     if (lastSelectedPyEnv != pythonPathTextItem)
     {
       m_Settings.setValue("TotalSeg/LastCustomPythonPath", pythonPathTextItem);
     }
   }
 }
 
 void QmitkTotalSegmentatorToolGUI::ShowErrorMessage(const std::string &message, QMessageBox::Icon icon)
 {
   this->setCursor(Qt::ArrowCursor);
   QMessageBox *messageBox = new QMessageBox(icon, nullptr, message.c_str());
   messageBox->exec();
   delete messageBox;
   MITK_WARN << message;
 }
 
 void QmitkTotalSegmentatorToolGUI::WriteStatusMessage(const QString &message)
 {
   m_Controls.statusLabel->setText(message);
   m_Controls.statusLabel->setStyleSheet("font-weight: bold; color: white");
   qApp->processEvents();
 }
 
 void QmitkTotalSegmentatorToolGUI::WriteErrorMessage(const QString &message)
 {
   m_Controls.statusLabel->setText(message);
   m_Controls.statusLabel->setStyleSheet("font-weight: bold; color: red");
   qApp->processEvents();
 }
 
 bool QmitkTotalSegmentatorToolGUI::IsTotalSegmentatorInstalled(const QString &pythonPath)
 {
   QString fullPath = pythonPath;
   bool isPythonExists = false, isExists = false;
 #ifdef _WIN32
   isPythonExists = QFile::exists(fullPath + QDir::separator() + QString("python.exe"));
   if (!(fullPath.endsWith("Scripts", Qt::CaseInsensitive) || fullPath.endsWith("Scripts/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("Scripts");
     isPythonExists =
       (!isPythonExists) ? QFile::exists(fullPath + QDir::separator() + QString("python.exe")) : isPythonExists;
   }
   isExists = QFile::exists(fullPath + QDir::separator() + QString("TotalSegmentator.exe")) && isPythonExists;
 #else
   isPythonExists = QFile::exists(fullPath + QDir::separator() + QString("python3"));
   if (!(fullPath.endsWith("bin", Qt::CaseInsensitive) || fullPath.endsWith("bin/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("bin");
     isPythonExists =
       (!isPythonExists) ? QFile::exists(fullPath + QDir::separator() + QString("python3")) : isPythonExists;
   }
   isExists = QFile::exists(fullPath + QDir::separator() + QString("TotalSegmentator")) && isPythonExists;
 #endif
   return isExists;
 }
 
 void QmitkTotalSegmentatorToolGUI::AutoParsePythonPaths()
 {
   QString homeDir = QDir::homePath();
   std::vector<QString> searchDirs;
 #ifdef _WIN32
   searchDirs.push_back(QString("C:") + QDir::separator() + QString("ProgramData") + QDir::separator() +
                        QString("anaconda3"));
 #else
   // Add search locations for possible standard python paths here
   searchDirs.push_back(homeDir + QDir::separator() + "environments");
   searchDirs.push_back(homeDir + QDir::separator() + "anaconda3");
   searchDirs.push_back(homeDir + QDir::separator() + "miniconda3");
   searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "miniconda3");
   searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "anaconda3");
 #endif
   for (QString searchDir : searchDirs)
   {
     if (searchDir.endsWith("anaconda3", Qt::CaseInsensitive))
     {
       if (QDir(searchDir).exists())
       {
         m_Controls.sysPythonComboBox->addItem("(base): " + searchDir);
         searchDir.append((QDir::separator() + QString("envs")));
       }
     }
     for (QDirIterator subIt(searchDir, QDir::AllDirs, QDirIterator::NoIteratorFlags); subIt.hasNext();)
     {
       subIt.next();
       QString envName = subIt.fileName();
       if (!envName.startsWith('.')) // Filter out irrelevent hidden folders, if any.
       {
         m_Controls.pythonEnvComboBox->addItem("(" + envName + "): " + subIt.filePath());
       }
     }
   }
 }
 
 std::pair<QString, QString> QmitkTotalSegmentatorToolGUI::OnSystemPythonChanged(const QString &pyEnv)
 {
   std::pair<QString, QString> pyPath;
   if (pyEnv == QString("Select"))
   {
     m_Controls.previewButton->setDisabled(true);
     QString path =
       QFileDialog::getExistingDirectory(m_Controls.sysPythonComboBox->parentWidget(), "Python Path", "dir");
     if (!path.isEmpty())
     {
       this->OnSystemPythonChanged(path);                                // recall same function for new path validation
       bool oldState = m_Controls.sysPythonComboBox->blockSignals(true); // block signal firing while inserting item
       m_Controls.sysPythonComboBox->insertItem(0, path);
       m_Controls.sysPythonComboBox->setCurrentIndex(0);
       m_Controls.sysPythonComboBox->blockSignals(
         oldState); // unblock signal firing after inserting item. Remove this after Qt6 migration
     }
   }
   else
   { 
     QString uiPyPath = this->GetPythonPathFromUI(pyEnv);
     pyPath = QmitkSetupVirtualEnvUtil::GetExactPythonPath(uiPyPath);
   }
   return pyPath;
 }
 
 void QmitkTotalSegmentatorToolGUI::OnPythonPathChanged(const QString &pyEnv)
 {
   if (pyEnv == QString("Select"))
   {
     m_Controls.previewButton->setDisabled(true);
     QString path =
       QFileDialog::getExistingDirectory(m_Controls.pythonEnvComboBox->parentWidget(), "Python Path", "dir");
     if (!path.isEmpty())
     {
       this->OnPythonPathChanged(path);                                  // recall same function for new path validation
       bool oldState = m_Controls.pythonEnvComboBox->blockSignals(true); // block signal firing while inserting item
       m_Controls.pythonEnvComboBox->insertItem(0, path);
       m_Controls.pythonEnvComboBox->setCurrentIndex(0);
       m_Controls.pythonEnvComboBox->blockSignals(
         oldState); // unblock signal firing after inserting item. Remove this after Qt6 migration
     }
   }
   else if (!this->IsTotalSegmentatorInstalled(this->GetPythonPathFromUI(pyEnv)))
   {
     this->ShowErrorMessage(WARNING_TOTALSEG_NOT_FOUND);
     m_Controls.previewButton->setDisabled(true);
   }
   else
   {// Show positive status meeage
     m_Controls.previewButton->setDisabled(false);
     QString uiPyPath = this->GetPythonPathFromUI(pyEnv);
     m_PythonPath = QmitkSetupVirtualEnvUtil::GetExactPythonPath(uiPyPath).first;
   }
 }
 
 QString QmitkTotalSegmentatorToolGUI::GetPythonPathFromUI(const QString &pyUI) const
 {
   QString fullPath = pyUI;
   if (-1 != fullPath.indexOf(")"))
   {
     fullPath = fullPath.mid(fullPath.indexOf(")") + 2);
   }
   return fullPath.simplified();
 }
 
 void QmitkTotalSegmentatorToolGUI::OnOverrideChecked(int state)
 {
   bool isEnabled = false;
   if (state == Qt::Checked)
   {
     isEnabled = true;
     m_Controls.previewButton->setDisabled(true);
     m_PythonPath.clear();
   }
   else
   {
     m_PythonPath.clear();
     m_Controls.previewButton->setDisabled(true);
     if (m_IsInstalled)
     {
       const QString pythonPath = m_Installer.GetVirtualEnvPath();
       auto pathObject = QmitkSetupVirtualEnvUtil::GetExactPythonPath(pythonPath);
       m_PythonPath = pathObject.first;
       this->EnableAll(m_IsInstalled);
     }
   }
   m_Controls.pythonEnvComboBox->setEnabled(isEnabled);
 }
 
 void QmitkTotalSegmentatorToolGUI::OnClearInstall()
 {
   QDir folderPath(m_Installer.GetVirtualEnvPath());
   if (folderPath.removeRecursively())
   {
     m_Controls.installButton->setEnabled(true);
     m_IsInstalled = false;
     if (!m_Controls.overrideBox->isChecked())
     {
       m_Controls.previewButton->setEnabled(false);
     }
   }
   else
   {
     MITK_ERROR
       << "The virtual environment couldn't be removed. Please check if you have the required access privileges or, some other process is accessing the folders.";
   }
 }
 
 bool QmitkTotalSegmentatorToolInstaller::SetupVirtualEnv(const QString& venvName)
 {
   if (GetSystemPythonPath().isEmpty())
   {
     return false;
   }
   QDir folderPath(GetBaseDir());
   folderPath.mkdir(venvName);
   if (!folderPath.cd(venvName))
   {
     return false; // Check if directory creation was successful.
   }
   mitk::ProcessExecutor::ArgumentListType args;
   auto spExec = mitk::ProcessExecutor::New();
   auto spCommand = itk::CStyleCommand::New();
   spCommand->SetCallback(&PrintProcessEvent);
   spExec->AddObserver(mitk::ExternalProcessOutputEvent(), spCommand);
 
   args.push_back("-m");
   args.push_back("venv");
   args.push_back(venvName.toStdString());
 #ifdef _WIN32
   QString pythonFile = GetSystemPythonPath() + QDir::separator() + "python.exe";
   QString pythonExeFolder = "Scripts";
 #else
   QString pythonFile = GetSystemPythonPath() + QDir::separator() + "python3";
   QString pythonExeFolder = "bin";
 #endif
   spExec->Execute(GetBaseDir().toStdString(), pythonFile.toStdString(), args); // Setup local virtual environment
   if (folderPath.cd(pythonExeFolder))
   {
     this->SetPythonPath(folderPath.absolutePath());
     this->SetPipPath(folderPath.absolutePath());
     this->InstallPytorch();
     for (auto &package : PACKAGES)
     {
       this->PipInstall(package.toStdString(), &PrintProcessEvent);
     }
     std::string pythonCode; // python syntax to check if torch is installed with CUDA.
     pythonCode.append("import torch;");
     pythonCode.append("print('Pytorch was installed with CUDA') if torch.cuda.is_available() else print('PyTorch was "
                       "installed WITHOUT CUDA');");
     this->ExecutePython(pythonCode, &PrintProcessEvent);
     return true;
   }
   return false;
 }
 
 QString QmitkTotalSegmentatorToolInstaller::GetVirtualEnvPath() 
 {
   return STORAGE_DIR + VENV_NAME;
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.h
index ac0c787f4c..f07a6a2faa 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.h
@@ -1,181 +1,182 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkTotalSegmentatorToolGUI_h_Included
 #define QmitkTotalSegmentatorToolGUI_h_Included
 
 #include "QmitkMultiLabelSegWithPreviewToolGUIBase.h"
 #include "QmitkSetupVirtualEnvUtil.h"
 #include "QmitknnUNetGPU.h"
 #include "ui_QmitkTotalSegmentatorGUIControls.h"
 #include <MitkSegmentationUIExports.h>
 #include <QMessageBox>
 #include <QSettings>
 #include <QStandardPaths>
 #include <QDir>
 
 /**
  * @brief Installer class for TotalSegmentator Tool.
  * Class specifies the virtual environment name, install version, packages required to pip install
  * and implements SetupVirtualEnv method.
  * 
  */
 class QmitkTotalSegmentatorToolInstaller : public QmitkSetupVirtualEnvUtil
 {
 public:
   const QString VENV_NAME = ".totalsegmentator_v2";
   const QString TOTALSEGMENTATOR_VERSION = "2.0.5";
   const std::vector<QString> PACKAGES = {QString("Totalsegmentator==") + TOTALSEGMENTATOR_VERSION};
   const QString STORAGE_DIR;
   inline QmitkTotalSegmentatorToolInstaller(
     const QString baseDir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QDir::separator() 
                             + qApp->organizationName() + QDir::separator())
     : QmitkSetupVirtualEnvUtil(baseDir), STORAGE_DIR(baseDir){};
   bool SetupVirtualEnv(const QString &) override;
   QString GetVirtualEnvPath() override;
 };
 
 /**
   \ingroup org_mitk_gui_qt_interactivesegmentation_internal
   \brief GUI for mitk::TotalSegmentatorTool.
   \sa mitk::
 */
 class MITKSEGMENTATIONUI_EXPORT QmitkTotalSegmentatorToolGUI : public QmitkMultiLabelSegWithPreviewToolGUIBase
 {
   Q_OBJECT
 
 public:
   mitkClassMacro(QmitkTotalSegmentatorToolGUI, QmitkMultiLabelSegWithPreviewToolGUIBase);
   itkFactorylessNewMacro(Self);
   itkCloneMacro(Self);
 
 protected slots:
 
   /**
    * @brief Qt Slot
    */
   void OnPreviewBtnClicked();
 
   /**
    * @brief Qt Slot
    */
   void OnPythonPathChanged(const QString &);
 
   /**
    * @brief Qt Slot
    */
   std::pair<QString, QString> OnSystemPythonChanged(const QString &);
 
   /**
    * @brief Qt Slot
    */
   void OnInstallBtnClicked();
 
   /**
    * @brief Qt Slot
    */
   void OnOverrideChecked(int);
 
   /**
    * @brief Qt Slot
    */
   void OnClearInstall();
 
 protected:
   QmitkTotalSegmentatorToolGUI();
   ~QmitkTotalSegmentatorToolGUI() = default;
 
   void ConnectNewTool(mitk::SegWithPreviewTool *newTool) override;
   void InitializeUI(QBoxLayout *mainLayout) override;
+  bool ConfirmExit() override;
 
   /**
    * @brief Enable (or Disable) GUI elements.
    */
   void EnableAll(bool);
 
   /**
    * @brief Searches and parses paths of python virtual enviroments
    * from predefined lookout locations
    */
   void AutoParsePythonPaths();
 
   /**
    * @brief Checks if TotalSegmentator command is valid in the selected python virtual environment.
    *
    * @return bool
    */
   bool IsTotalSegmentatorInstalled(const QString &);
 
   /**
    * @brief Creates a QMessage object and shows on screen.
    */
   void ShowErrorMessage(const std::string &, QMessageBox::Icon = QMessageBox::Critical);
 
   /**
    * @brief Writes any message in white on the tool pane.
    */
   void WriteStatusMessage(const QString &);
 
   /**
    * @brief Writes any message in red on the tool pane.
    */
   void WriteErrorMessage(const QString &);
 
   /**
    * @brief Adds GPU information to the gpu combo box.
    * In case, there aren't any GPUs avaialble, the combo box will be
    * rendered editable.
    */
   void SetGPUInfo();
 
   /**
    * @brief Returns GPU id of the selected GPU from the Combo box.
    *
    * @return unsigned int
    */
   unsigned int FetchSelectedGPUFromUI() const;
 
   /**
    * @brief Get the virtual env path from UI combobox removing any 
    * extra special characters.
    * 
    * @return QString 
    */
   QString GetPythonPathFromUI(const QString &) const;
 
   /**
    * @brief For storing values like Python path across sessions.
    */
   QSettings m_Settings;
 
   QString m_PythonPath;
   QmitkGPULoader m_GpuLoader;
   Ui_QmitkTotalSegmentatorToolGUIControls m_Controls;
   bool m_FirstPreviewComputation = true;
   bool m_IsInstalled = false;
   EnableConfirmSegBtnFunctionType m_SuperclassEnableConfirmSegBtnFnc;
 
   const std::string WARNING_TOTALSEG_NOT_FOUND =
     "TotalSegmentator is not detected in the selected python environment.Please select a valid "
     "python environment or install TotalSegmentator.";
   const QStringList VALID_TASKS = {
     "total",
     "cerebral_bleed",
     "hip_implant",
     "coronary_arteries",
     "body",
     "lung_vessels",
     "pleural_pericard_effusion"
   };
   QmitkTotalSegmentatorToolInstaller m_Installer;
 };
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetGPU.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetGPU.cpp
index 68dfb6aa6b..be53422f7e 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetGPU.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetGPU.cpp
@@ -1,55 +1,55 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.s
 
 ============================================================================*/
 
 #include "QmitknnUNetGPU.h"
 #include <QProcess>
 
 QmitkGPULoader::QmitkGPULoader()
 {
   QProcess process;
-  process.start("nvidia-smi --query-gpu=name,memory.total --format=csv");
+  process.start("nvidia-smi", QStringList() << "--query-gpu=name,memory.total" << "--format=csv");
   process.waitForFinished(-1);
   QStringList infoStringList;
   while (process.canReadLine())
   {
     QString line = process.readLine();
     if (!line.startsWith("name"))
     {
       infoStringList << line;
     }
   }
   unsigned int count = 0;
   foreach (QString infoString, infoStringList)
   {
     QmitkGPUSpec spec;
     QStringList gpuDetails;
     gpuDetails = infoString.split(",");
     if(gpuDetails.count() == 2)
     {
       spec.name = gpuDetails.at(0).trimmed();
       spec.id = count;
       spec.memory = gpuDetails.at(1).trimmed();
       this->m_Gpus.push_back(spec);
       ++count;
     }
   }
 }
 
 int QmitkGPULoader::GetGPUCount() const
 {
   return static_cast<int>(m_Gpus.size());
 }
 
 std::vector<QmitkGPUSpec> QmitkGPULoader::GetAllGPUSpecs()
 {
   return m_Gpus;
 }