diff --git a/Modules/AppUtil/src/mitkBaseApplication.cpp b/Modules/AppUtil/src/mitkBaseApplication.cpp
index 99ab8a04e8..31a0604c51 100644
--- a/Modules/AppUtil/src/mitkBaseApplication.cpp
+++ b/Modules/AppUtil/src/mitkBaseApplication.cpp
@@ -1,896 +1,899 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkBaseApplication.h"
 #include "mitkLogMacros.h"
 #include "mitkExceptionMacro.h"
 
 #include "QmitkSafeApplication.h"
 #include "QmitkSingleApplication.h"
 #include "mitkProvisioningInfo.h"
 
 #include <ctkPluginConstants.h>
 #include <ctkPluginFramework.h>
 #include <ctkPluginFrameworkLauncher.h>
 #include <ctkPluginFramework_global.h>
 
 #include <usModuleSettings.h>
 
 #include <Poco/Util/HelpFormatter.h>
 
 #include <QSplashScreen>
 #include <QRunnable>
 #include <QFileInfo>
 #include <QCoreApplication>
 #include <QDebug>
 #include <QDesktopServices>
 #include <QDir>
 #include <QStringList>
 #include <QTime>
 
 #include <iostream>
 #include <string>
 
 #include <QVTKOpenGLWidget.h>
 #include <vtkGenericOpenGLRenderWindow.h>
 
 namespace mitk
 {
   QString BaseApplication::ARG_NEWINSTANCE = "BlueBerry.newInstance";
   QString BaseApplication::ARG_CLEAN = "BlueBerry.clean";
   QString BaseApplication::ARG_APPLICATION = "BlueBerry.application";
   QString BaseApplication::ARG_PRODUCT = "BlueBerry.product";
   QString BaseApplication::ARG_HOME = "BlueBerry.home";
   QString BaseApplication::ARG_STORAGE_DIR = "BlueBerry.storageDir";
   QString BaseApplication::ARG_PLUGIN_CACHE = "BlueBerry.plugin_cache_dir";
   QString BaseApplication::ARG_PLUGIN_DIRS = "BlueBerry.plugin_dirs";
   QString BaseApplication::ARG_FORCE_PLUGIN_INSTALL = "BlueBerry.forcePlugins";
   QString BaseApplication::ARG_PRELOAD_LIBRARY = "BlueBerry.preloadLibrary";
   QString BaseApplication::ARG_PROVISIONING = "BlueBerry.provisioning";
   QString BaseApplication::ARG_DEBUG = "BlueBerry.debug";
   QString BaseApplication::ARG_CONSOLELOG = "BlueBerry.consoleLog";
   QString BaseApplication::ARG_TESTPLUGIN = "BlueBerry.testplugin";
   QString BaseApplication::ARG_TESTAPPLICATION = "BlueBerry.testapplication";
 
   QString BaseApplication::ARG_SPLASH_IMAGE = "BlueBerry.splashscreen";
 
   QString BaseApplication::ARG_NO_REGISTRY_CACHE = "BlueBerry.noRegistryCache";
   QString BaseApplication::ARG_NO_LAZY_REGISTRY_CACHE_LOADING = "BlueBerry.noLazyRegistryCacheLoading";
   QString BaseApplication::ARG_REGISTRY_MULTI_LANGUAGE = "BlueBerry.registryMultiLanguage";
 
   QString BaseApplication::ARG_XARGS = "xargs";
 
   QString BaseApplication::PROP_NEWINSTANCE = BaseApplication::ARG_NEWINSTANCE;
   QString BaseApplication::PROP_FORCE_PLUGIN_INSTALL = BaseApplication::ARG_FORCE_PLUGIN_INSTALL;
   QString BaseApplication::PROP_NO_REGISTRY_CACHE = BaseApplication::ARG_NO_REGISTRY_CACHE;
   QString BaseApplication::PROP_NO_LAZY_REGISTRY_CACHE_LOADING = BaseApplication::ARG_NO_LAZY_REGISTRY_CACHE_LOADING;
   QString BaseApplication::PROP_REGISTRY_MULTI_LANGUAGE = BaseApplication::ARG_REGISTRY_MULTI_LANGUAGE;
 
   QString BaseApplication::PROP_PRODUCT = "blueberry.product";
   QString BaseApplication::PROP_APPLICATION = "blueberry.application";
   QString BaseApplication::PROP_TESTPLUGIN = "BlueBerry.testplugin";
   QString BaseApplication::PROP_TESTAPPLICATION = "BlueBerry.testapplication";
 
   static void outputQtMessage(QtMsgType type, const QMessageLogContext &, const QString &msg)
   {
     auto message = msg.toStdString();
 
     switch (type)
     {
       case QtDebugMsg:
         MITK_DEBUG << message;
         break;
 
       case QtInfoMsg:
         MITK_INFO << message;
         break;
 
       case QtWarningMsg:
         MITK_WARN << message;
         break;
 
       case QtCriticalMsg:
         MITK_ERROR << message;
         break;
 
       case QtFatalMsg:
         MITK_ERROR << message;
         abort();
 
       default:
         MITK_INFO << message;
         break;
     }
   }
 
   class SplashCloserCallback : public QRunnable
   {
   public:
     SplashCloserCallback(QSplashScreen* splashscreen)
     {
       this->m_Splashscreen = splashscreen;
     }
 
     void run() override
     {
       this->m_Splashscreen->close();
     }
 
   private:
     QSplashScreen* m_Splashscreen;
   };
 
   struct BaseApplication::Impl
   {
     ctkProperties m_FWProps;
 
     QScopedPointer<QCoreApplication> m_QApp;
 
     int m_Argc;
     char **m_Argv;
 
     QString m_AppName;
     QString m_OrgaName;
     QString m_OrgaDomain;
 
     bool m_SingleMode;
     bool m_SafeMode;
 
     QSplashScreen* m_Splashscreen;
     SplashCloserCallback* m_SplashscreenClosingCallback;
 
     QStringList m_PreloadLibs;
     QString m_ProvFile;
 
     Impl(int argc, char **argv)
       : m_Argc(argc), m_Argv(argv), m_SingleMode(false), m_SafeMode(true),
         m_Splashscreen(nullptr), m_SplashscreenClosingCallback(nullptr)
     {
 #ifdef Q_OS_MAC
       /*
        * This is a workaround for bug 19080:
        * On Mac OS X the prosess serial number is passed as an commandline argument (-psn_<NUMBER>)
        * if the application is started via the.app bundle.
        * This option is unknown, which causes a Poco exception.
        * Since this is done by the system we have to manually remove the argument here.
        */
 
       int newArgc = m_Argc - 1;
       char **newArgs = new char *[newArgc];
       bool argFound(false);
       for (int i = 0; i < m_Argc; ++i)
       {
         if (QString::fromLatin1(m_Argv[i]).contains("-psn"))
         {
           argFound = true;
         }
         else
         {
           newArgs[i] = m_Argv[i];
         }
       }
       if (argFound)
       {
         m_Argc = newArgc;
         m_Argv = newArgs;
       }
 #endif
     }
 
     QVariant getProperty(const QString &property) const
     {
       auto iter = m_FWProps.find(property);
       return iter == m_FWProps.end() ? QVariant() : iter.value();
     }
 
     void handleBooleanOption(const std::string &name, const std::string & /*value*/)
     {
       QString fwKey = QString::fromStdString(name);
 
       // translate some keys to proper framework properties
       if (fwKey == ARG_CONSOLELOG)
       {
         fwKey = ctkPluginFrameworkLauncher::PROP_CONSOLE_LOG;
       }
 
       // For all other options we use the command line option name as the
       // framework property key.
       m_FWProps[fwKey] = true;
     }
 
     void handlePreloadLibraryOption(const std::string & /*name*/, const std::string &value)
     {
       m_PreloadLibs.push_back(QString::fromStdString(value));
     }
 
     void handleClean(const std::string & /*name*/, const std::string & /*value*/)
     {
       m_FWProps[ctkPluginConstants::FRAMEWORK_STORAGE_CLEAN] = ctkPluginConstants::FRAMEWORK_STORAGE_CLEAN_ONFIRSTINIT;
     }
 
     void initializeCTKPluginFrameworkProperties(Poco::Util::LayeredConfiguration &configuration)
     {
       // add all configuration key / value pairs as framework properties
       Poco::Util::LayeredConfiguration::Keys keys;
       Poco::Util::LayeredConfiguration::Keys keyStack;
       configuration.keys(keyStack);
       std::vector<std::string> keyChain;
       while (!keyStack.empty())
       {
         std::string currSubKey = keyStack.back();
         if (!keyChain.empty() && keyChain.back() == currSubKey)
         {
           keyChain.pop_back();
           keyStack.pop_back();
           continue;
         }
         Poco::Util::LayeredConfiguration::Keys subKeys;
         configuration.keys(currSubKey, subKeys);
         if (subKeys.empty())
         {
           keyStack.pop_back();
           std::string finalKey;
           for (auto k = keyChain.begin(); k != keyChain.end(); ++k)
           {
             finalKey += *k + ".";
           }
           finalKey += currSubKey;
           keys.push_back(finalKey);
         }
         else
         {
           keyChain.push_back(currSubKey);
           for (auto s : subKeys)
           {
             keyStack.push_back(s);
           }
         }
       }
 
       for (auto key : keys)
       {
         QString qKey = QString::fromStdString(key);
         if (configuration.hasProperty(key))
         {
           // ini and command line options overwrite already inserted keys
           m_FWProps[qKey] = QString::fromStdString(configuration.getString(key));
         }
       }
     }
 
     void parseProvisioningFile(const QString &filePath)
     {
       // Skip parsing if the file path is empty
       if (filePath.isEmpty())
         return;
 
       bool consoleLog = this->getProperty(ctkPluginFrameworkLauncher::PROP_CONSOLE_LOG).toBool();
 
       // read initial plugins from a provisioning file
       QStringList pluginsToStart;
 
       QFileInfo provFile(filePath);
 
       if (provFile.exists())
       {
         MITK_INFO(consoleLog) << "Using provisioning file: " << qPrintable(provFile.absoluteFilePath());
         ProvisioningInfo provInfo(provFile.absoluteFilePath());
         // it can still happen, that the encoding is not compatible with the fromUtf8 function ( i.e. when manipulating
         // the LANG variable
         // in such case, the QStringList in provInfo is empty which we can easily check for
         if (provInfo.getPluginDirs().empty())
         {
           MITK_ERROR << "Cannot search for provisioning file, the retrieved directory list is empty.\n"
                      << "This can occur if there are some special (non-ascii) characters in the install path.";
         }
         else
         {
           foreach (QString pluginPath, provInfo.getPluginDirs())
           {
             ctkPluginFrameworkLauncher::addSearchPath(pluginPath);
           }
 
           // bool forcePluginOverwrite = this->getProperty(ARG_FORCE_PLUGIN_INSTALL).toBool();
           QList<QUrl> pluginUrlsToStart = provInfo.getPluginsToStart();
           for (auto url : pluginUrlsToStart)
           {
             pluginsToStart.push_back(url.toString());
           }
           // foreach(QUrl pluginUrl, provInfo.getPluginsToInstall())
           //{
           // TODO for "uninstall", we need a proper configuration agent, e.g. a dedicated
           // plug-in for provisioning of the platform
           /*
           if (forcePluginOverwrite)
           {
             uninstallPugin(pluginUrl, context);
           }
           */
           // try
           //{
           // MITK_INFO(consoleLog) << "Installing CTK plug-in from: " << pluginUrl.toString().toStdString();
           /*
           QSharedPointer<ctkPlugin> plugin = context->installPlugin(pluginUrl);
           if (pluginsToStart.contains(pluginUrl))
           {
             m_CTKPluginsToStart << plugin->getPluginId();
           }
           */
           /*
         }
         catch (const ctkPluginException& e)
         {
           QString errorMsg;
           QDebug dbg(&errorMsg);
           dbg << e.printStackTrace();
           BERRY_ERROR << qPrintable(errorMsg);
         }
         */
           //}
         }
       }
       else
       {
         MITK_INFO(consoleLog) << "No provisioning file set.";
       }
 
       if (!pluginsToStart.isEmpty())
       {
         m_FWProps[ctkPluginFrameworkLauncher::PROP_PLUGINS] = pluginsToStart;
 
         // Use transient start with declared activation policy (this helps when
         // the provisioning file changes and some plug-ins should not be installed
         // in the application any more).
         ctkPlugin::StartOptions startOptions(ctkPlugin::START_TRANSIENT | ctkPlugin::START_ACTIVATION_POLICY);
         m_FWProps[ctkPluginFrameworkLauncher::PROP_PLUGINS_START_OPTIONS] = static_cast<int>(startOptions);
       }
     }
   };
 
   BaseApplication::BaseApplication(int argc, char **argv) : Application(), d(new Impl(argc, argv))
   {
   }
 
   BaseApplication::~BaseApplication()
   {
     if (d->m_Splashscreen != nullptr)
     {
       delete(d->m_Splashscreen);
     }
     if (d->m_SplashscreenClosingCallback != nullptr)
     {
       delete(d->m_SplashscreenClosingCallback);
     }
   }
 
   void BaseApplication::printHelp(const std::string & /*name*/, const std::string & /*value*/)
   {
     Poco::Util::HelpFormatter help(this->options());
     help.setAutoIndent();
     help.setCommand(this->commandName());
     help.format(std::cout);
 
     exit(EXIT_OK);
   }
 
   void BaseApplication::setApplicationName(const QString &name)
   {
     if (qApp)
     {
       qApp->setApplicationName(name);
     }
     d->m_AppName = name;
   }
 
   QString BaseApplication::getApplicationName() const
   {
     if (qApp)
     {
       return qApp->applicationName();
     }
     return d->m_AppName;
   }
 
   void BaseApplication::setOrganizationName(const QString &name)
   {
     if (qApp)
     {
       qApp->setOrganizationName(name);
     }
     d->m_OrgaName = name;
   }
 
   QString BaseApplication::getOrganizationName() const
   {
     if (qApp)
       return qApp->organizationName();
     return d->m_OrgaName;
   }
 
   void BaseApplication::setOrganizationDomain(const QString &domain)
   {
     if (qApp)
     {
       qApp->setOrganizationDomain(domain);
     }
     d->m_OrgaDomain = domain;
   }
 
   QString BaseApplication::getOrganizationDomain() const
   {
     if (qApp)
       return qApp->organizationDomain();
     return d->m_OrgaDomain;
   }
 
   void BaseApplication::setSingleMode(bool singleMode)
   {
     if (qApp)
       return;
     d->m_SingleMode = singleMode;
   }
 
   bool BaseApplication::getSingleMode() const { return d->m_SingleMode; }
   void BaseApplication::setSafeMode(bool safeMode)
   {
     if (qApp && !d->m_QApp)
       return;
     d->m_SafeMode = safeMode;
     if (d->m_QApp)
     {
       if (getSingleMode())
       {
         static_cast<QmitkSingleApplication *>(d->m_QApp.data())->setSafeMode(safeMode);
       }
       else
       {
         static_cast<QmitkSafeApplication *>(d->m_QApp.data())->setSafeMode(safeMode);
       }
     }
   }
 
   bool BaseApplication::getSafeMode() const { return d->m_SafeMode; }
   void BaseApplication::setPreloadLibraries(const QStringList &libraryBaseNames)
   {
     d->m_PreloadLibs = libraryBaseNames;
   }
 
   QStringList BaseApplication::getPreloadLibraries() const { return d->m_PreloadLibs; }
   void BaseApplication::setProvisioningFilePath(const QString &filePath) { d->m_ProvFile = filePath; }
   QString BaseApplication::getProvisioningFilePath() const
   {
     QString provFilePath = d->m_ProvFile;
 
     // A null QString means look up a default provisioning file
     if (provFilePath.isNull() && qApp)
     {
       QFileInfo appFilePath(QCoreApplication::applicationFilePath());
       QDir basePath(QCoreApplication::applicationDirPath());
 
       QString provFileName = appFilePath.baseName() + ".provisioning";
 
       QFileInfo provFile(basePath.absoluteFilePath(provFileName));
 
 #ifdef Q_OS_MAC
       /*
        * On Mac, if started from the build directory the .provisioning file is located at:
        * <MITK-build/bin/MitkWorkbench.provisioning>
        * but the executable path is:
        * <MITK-build/bin/MitkWorkbench.app/Contents/MacOS/MitkWorkbench>
        * In this case we have to cdUp threetimes.
        *
        * During packaging however the MitkWorkbench.provisioning file is placed at the same
        * level like the executable, hence nothing has to be done.
        */
 
       if (!provFile.exists())
       {
         basePath.cdUp();
         basePath.cdUp();
         basePath.cdUp();
         provFile = basePath.absoluteFilePath(provFileName);
       }
 #endif
 
       if (provFile.exists())
       {
         provFilePath = provFile.absoluteFilePath();
       }
 #ifdef CMAKE_INTDIR
       else
       {
         basePath.cdUp();
         provFile.setFile(basePath.absoluteFilePath(provFileName));
         if (provFile.exists())
         {
           provFilePath = provFile.absoluteFilePath();
         }
       }
 #endif
     }
     return provFilePath;
   }
 
   void BaseApplication::initializeQt()
   {
     if (qApp)
       return;
 
     // If previously parameters have been set we have to store them
     // to hand them through to the application
     QString appName = this->getApplicationName();
     QString orgName = this->getOrganizationName();
     QString orgDomain = this->getOrganizationDomain();
 
     // Create a QCoreApplication instance
     this->getQApplication();
 
     // provide parameters to QCoreApplication
     this->setApplicationName(appName);
     this->setOrganizationName(orgName);
     this->setOrganizationDomain(orgDomain);
 
     qInstallMessageHandler(outputQtMessage);
   }
 
   void BaseApplication::initialize(Poco::Util::Application &self)
   {
     // 1. Call the super-class method
     Poco::Util::Application::initialize(self);
 
     // 2. Initialize the Qt framework (by creating a QCoreApplication)
     this->initializeQt();
 
     // 3. Seed the random number generator, once at startup.
     QTime time = QTime::currentTime();
     qsrand((uint)time.msec());
 
     // 4. Load the "default" configuration, which involves parsing
     //    an optional <executable-name>.ini file and parsing any
     //    command line arguments
     this->loadConfiguration();
 
     // 5. Add configuration data from the command line and the
     //    optional <executable-name>.ini file as CTK plugin
     //    framework properties.
     d->initializeCTKPluginFrameworkProperties(this->config());
 
   // 6. Initialize splash screen if an image path is provided
   //    in the .ini file
   this->initializeSplashScreen(qApp);
 
   // 7. Set the custom CTK Plugin Framework storage directory
     QString storageDir = this->getCTKFrameworkStorageDir();
     if (!storageDir.isEmpty())
     {
       d->m_FWProps[ctkPluginConstants::FRAMEWORK_STORAGE] = storageDir;
     }
 
   // 8. Set the library search paths and the pre-load library property
     this->initializeLibraryPaths();
     QStringList preloadLibs = this->getPreloadLibraries();
     if (!preloadLibs.isEmpty())
     {
       d->m_FWProps[ctkPluginConstants::FRAMEWORK_PRELOAD_LIBRARIES] = preloadLibs;
     }
 
   // 9. Initialize the CppMicroServices library.
     //    The initializeCppMicroServices() method reuses the
     //    FRAMEWORK_STORAGE property, so we call it after the
     //    getCTKFrameworkStorageDir method.
     this->initializeCppMicroServices();
 
   // 10. Parse the (optional) provisioning file and set the
     //    correct framework properties.
     d->parseProvisioningFile(this->getProvisioningFilePath());
 
     // Finally, set the CTK Plugin Framework properties
     ctkPluginFrameworkLauncher::setFrameworkProperties(d->m_FWProps);
   }
 
   void BaseApplication::uninitialize()
   {
     QSharedPointer<ctkPluginFramework> pfw = this->getFramework();
     if (pfw)
     {
       pfw->stop();
 
       // wait 10 seconds for the CTK plugin framework to stop
       pfw->waitForStop(10000);
     }
 
     Poco::Util::Application::uninitialize();
   }
 
   int BaseApplication::getArgc() const { return d->m_Argc; }
   char **BaseApplication::getArgv() const { return d->m_Argv; }
   QString BaseApplication::getCTKFrameworkStorageDir() const
   {
     QString storageDir;
     if (this->getSingleMode())
     {
       // This function checks if an instance is already running
       // and either sends a message to it (containing the command
       // line arguments) or checks if a new instance was forced by
       // providing the BlueBerry.newInstance command line argument.
       // In the latter case, a path to a temporary directory for
       // the new application's storage directory is returned.
       storageDir = handleNewAppInstance(
         static_cast<QtSingleApplication *>(d->m_QApp.data()), d->m_Argc, d->m_Argv, ARG_NEWINSTANCE);
     }
 
     if (storageDir.isEmpty())
     {
       // This is a new instance and no other instance is already running. We specify
       // the storage directory here (this is the same code as in berryInternalPlatform.cpp
       // so that we can re-use the location for the persistent data location of the
       // the CppMicroServices library.
 
       // Append a hash value of the absolute path of the executable to the data location.
       // This allows to start the same application from different build or install trees.
       storageDir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/" +
                    this->getOrganizationName() + "/" + this->getApplicationName() + '_';
       storageDir += QString::number(qHash(QCoreApplication::applicationDirPath())) + "/";
     }
     return storageDir;
   }
 
   void BaseApplication::initializeCppMicroServices()
   {
     QString storageDir = this->getProperty(ctkPluginConstants::FRAMEWORK_STORAGE).toString();
 
     if (!storageDir.isEmpty())
     {
       us::ModuleSettings::SetStoragePath((storageDir + QString("us") + QDir::separator()).toStdString());
     }
   }
 
   QCoreApplication *BaseApplication::getQApplication() const
   {
-    vtkOpenGLRenderWindow::SetGlobalMaximumNumberOfMultiSamples(0);
-    QSurfaceFormat::setDefaultFormat(QVTKOpenGLWidget::defaultFormat());
-
     QCoreApplication *qCoreApp = qApp;
 
-// Needed to fix bug #18521, i.e. not responding GUI on Mac OS X with Qt5
+    if (nullptr == qCoreApp)
+    {
+      vtkOpenGLRenderWindow::SetGlobalMaximumNumberOfMultiSamples(0);
+
+      auto defaultFormat = QVTKOpenGLWidget::defaultFormat();
+      defaultFormat.setSamples(0);
+      QSurfaceFormat::setDefaultFormat(defaultFormat);
+
 #ifdef Q_OS_OSX
-    qCoreApp->setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
+      QCoreApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
 #endif
 
-    qCoreApp->setAttribute(Qt::AA_ShareOpenGLContexts);
+      QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
 
-    if (!qCoreApp)
-    {
-      if (getSingleMode())
+      if (this->getSingleMode())
       {
         qCoreApp = new QmitkSingleApplication(d->m_Argc, d->m_Argv, getSafeMode());
       }
       else
       {
         auto safeApp = new QmitkSafeApplication(d->m_Argc, d->m_Argv);
         safeApp->setSafeMode(d->m_SafeMode);
         qCoreApp = safeApp;
       }
       d->m_QApp.reset(qCoreApp);
     }
+
     return qCoreApp;
   }
 
   void BaseApplication::initializeLibraryPaths()
   {
     QStringList suffixes;
     suffixes << "plugins";
 #ifdef Q_OS_WINDOWS
     suffixes << "bin/plugins";
 #ifdef CMAKE_INTDIR
     suffixes << "bin/" CMAKE_INTDIR "/plugins";
 #endif
 #else
     suffixes << "lib/plugins";
 #ifdef CMAKE_INTDIR
     suffixes << "lib/" CMAKE_INTDIR "/plugins";
 #endif
 #endif
 
 #ifdef Q_OS_MAC
     suffixes << "../../plugins";
 #endif
 
     // we add a couple of standard library search paths for plug-ins
     QDir appDir(QCoreApplication::applicationDirPath());
 
     // walk one directory up and add bin and lib sub-dirs; this
     // might be redundant
     appDir.cdUp();
 
     foreach (QString suffix, suffixes)
     {
       ctkPluginFrameworkLauncher::addSearchPath(appDir.absoluteFilePath(suffix));
     }
   }
 
   int BaseApplication::main(const std::vector<std::string> &args)
   {
     // Start the plugin framework and all installed plug-ins according with
     // their auto-start setting.
     QStringList arguments;
 
     for (auto const &arg : args)
     {
       arguments.push_back(QString::fromStdString(arg));
     }
 
     if (d->m_Splashscreen != nullptr)
     {
       // a splash screen is displayed,
       // creating the closing callback
       d->m_SplashscreenClosingCallback = new SplashCloserCallback(d->m_Splashscreen);
     }
 
     return ctkPluginFrameworkLauncher::run(d->m_SplashscreenClosingCallback, QVariant::fromValue(arguments)).toInt();
   }
 
   void BaseApplication::defineOptions(Poco::Util::OptionSet &options)
   {
     Poco::Util::Option helpOption("help", "h", "print this help text");
     helpOption.callback(Poco::Util::OptionCallback<BaseApplication>(this, &BaseApplication::printHelp));
     options.addOption(helpOption);
 
     Poco::Util::Option newInstanceOption(
       ARG_NEWINSTANCE.toStdString(), "", "forces a new instance of this application");
     newInstanceOption.callback(Poco::Util::OptionCallback<Impl>(d.data(), &Impl::handleBooleanOption));
     options.addOption(newInstanceOption);
 
     Poco::Util::Option cleanOption(ARG_CLEAN.toStdString(), "", "cleans the plugin cache");
     cleanOption.callback(Poco::Util::OptionCallback<Impl>(d.data(), &Impl::handleClean));
     options.addOption(cleanOption);
 
     Poco::Util::Option productOption(ARG_PRODUCT.toStdString(), "", "the id of the product to be launched");
     productOption.argument("<id>").binding(PROP_PRODUCT.toStdString());
     options.addOption(productOption);
 
     Poco::Util::Option appOption(
       ARG_APPLICATION.toStdString(), "", "the id of the application extension to be executed");
     appOption.argument("<id>").binding(PROP_APPLICATION.toStdString());
     options.addOption(appOption);
 
     Poco::Util::Option provOption(ARG_PROVISIONING.toStdString(), "", "the location of a provisioning file");
     provOption.argument("<prov file>").binding(ARG_PROVISIONING.toStdString());
     options.addOption(provOption);
 
     Poco::Util::Option storageDirOption(
       ARG_STORAGE_DIR.toStdString(), "", "the location for storing persistent application data");
     storageDirOption.argument("<dir>").binding(ctkPluginConstants::FRAMEWORK_STORAGE.toStdString());
     options.addOption(storageDirOption);
 
     Poco::Util::Option consoleLogOption(ARG_CONSOLELOG.toStdString(), "", "log messages to the console");
     consoleLogOption.callback(Poco::Util::OptionCallback<Impl>(d.data(), &Impl::handleBooleanOption));
     options.addOption(consoleLogOption);
 
     Poco::Util::Option debugOption(ARG_DEBUG.toStdString(), "", "enable debug mode");
     debugOption.argument("<options file>", false).binding(ctkPluginFrameworkLauncher::PROP_DEBUG.toStdString());
     options.addOption(debugOption);
 
     Poco::Util::Option forcePluginOption(
       ARG_FORCE_PLUGIN_INSTALL.toStdString(), "", "force installing plug-ins with same symbolic name");
     forcePluginOption.callback(Poco::Util::OptionCallback<Impl>(d.data(), &Impl::handleBooleanOption));
     options.addOption(forcePluginOption);
 
     Poco::Util::Option preloadLibsOption(ARG_PRELOAD_LIBRARY.toStdString(), "", "preload a library");
     preloadLibsOption.argument("<library>")
       .repeatable(true)
       .callback(Poco::Util::OptionCallback<Impl>(d.data(), &Impl::handlePreloadLibraryOption));
     options.addOption(preloadLibsOption);
 
     Poco::Util::Option testPluginOption(ARG_TESTPLUGIN.toStdString(), "", "the plug-in to be tested");
     testPluginOption.argument("<id>").binding(PROP_TESTPLUGIN.toStdString());
     options.addOption(testPluginOption);
 
     Poco::Util::Option testAppOption(ARG_TESTAPPLICATION.toStdString(), "", "the application to be tested");
     testAppOption.argument("<id>").binding(PROP_TESTAPPLICATION.toStdString());
     options.addOption(testAppOption);
 
     Poco::Util::Option noRegistryCacheOption(
       ARG_NO_REGISTRY_CACHE.toStdString(), "", "do not use a cache for the registry");
     noRegistryCacheOption.callback(Poco::Util::OptionCallback<Impl>(d.data(), &Impl::handleBooleanOption));
     options.addOption(noRegistryCacheOption);
 
     Poco::Util::Option noLazyRegistryCacheLoadingOption(
       ARG_NO_LAZY_REGISTRY_CACHE_LOADING.toStdString(), "", "do not use lazy cache loading for the registry");
     noLazyRegistryCacheLoadingOption.callback(Poco::Util::OptionCallback<Impl>(d.data(), &Impl::handleBooleanOption));
     options.addOption(noLazyRegistryCacheLoadingOption);
 
     Poco::Util::Option registryMultiLanguageOption(
       ARG_REGISTRY_MULTI_LANGUAGE.toStdString(), "", "enable multi-language support for the registry");
     registryMultiLanguageOption.callback(Poco::Util::OptionCallback<Impl>(d.data(), &Impl::handleBooleanOption));
     options.addOption(registryMultiLanguageOption);
 
   Poco::Util::Option splashScreenOption(ARG_SPLASH_IMAGE.toStdString(), "", "optional picture to use as a splash screen");
   splashScreenOption.argument("<filename>").binding(ARG_SPLASH_IMAGE.toStdString());
   options.addOption(splashScreenOption);
 
     Poco::Util::Option xargsOption(ARG_XARGS.toStdString(), "", "Extended argument list");
     xargsOption.argument("<args>").binding(ARG_XARGS.toStdString());
     options.addOption(xargsOption);
 
     Poco::Util::Application::defineOptions(options);
   }
 
   QSharedPointer<ctkPluginFramework> BaseApplication::getFramework() const
   {
     return ctkPluginFrameworkLauncher::getPluginFramework();
   }
 
   ctkPluginContext *BaseApplication::getFrameworkContext() const
   {
     QSharedPointer<ctkPluginFramework> framework = getFramework();
     if (framework)
       return framework->getPluginContext();
     return nullptr;
   }
 
   void BaseApplication::initializeSplashScreen(QCoreApplication * application) const
   {
     QVariant pixmapFileNameProp = d->getProperty(ARG_SPLASH_IMAGE);
     if (!pixmapFileNameProp.isNull()) {
       QString pixmapFileName = pixmapFileNameProp.toString();
       QFileInfo checkFile(pixmapFileName);
       if (checkFile.exists() && checkFile.isFile()) {
         QPixmap pixmap(checkFile.absoluteFilePath());
         d->m_Splashscreen = new QSplashScreen(pixmap, Qt::WindowStaysOnTopHint);
         d->m_Splashscreen->show();
         application->processEvents();
       }
     }
   }
 
   QHash<QString, QVariant> BaseApplication::getFrameworkProperties() const { return d->m_FWProps; }
 
   int BaseApplication::run()
   {
     this->init(d->m_Argc, d->m_Argv);
     return Application::run();
   }
 
   void BaseApplication::setProperty(const QString &property, const QVariant &value) { d->m_FWProps[property] = value; }
   QVariant BaseApplication::getProperty(const QString &property) const { return d->getProperty(property); }
 
   void BaseApplication::installTranslator(QTranslator* translator)
   {
     this->getQApplication()->installTranslator(translator);
   }
 
   bool BaseApplication::isRunning()
   {
     auto app = dynamic_cast<QtSingleApplication*>(this->getQApplication());
 
     if (nullptr != app)
       app->isRunning();
 
     mitkThrow() << "Method not implemented.";
   }
 
   void BaseApplication::sendMessage(const QByteArray msg)
   {
     auto app = dynamic_cast<QtSingleApplication*>(this->getQApplication());
 
     if (nullptr != app)
       app->sendMessage(msg);
 
     mitkThrow() << "Method not implemented.";
   }
 
 }
diff --git a/Modules/Core/include/mitkBaseRenderer.h b/Modules/Core/include/mitkBaseRenderer.h
index a1a924a309..9a702a84d6 100644
--- a/Modules/Core/include/mitkBaseRenderer.h
+++ b/Modules/Core/include/mitkBaseRenderer.h
@@ -1,558 +1,557 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4
 #define BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4
 
 #include "mitkCameraRotationController.h"
 #include "mitkDataStorage.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkPlaneGeometryData.h"
 #include "mitkSliceNavigationController.h"
 #include "mitkTimeGeometry.h"
 
 #include "mitkBindDispatcherInteractor.h"
 #include "mitkDispatcher.h"
 
 #include <vtkRenderWindow.h>
 #include <vtkRenderer.h>
 
 #include <map>
 #include <set>
 
 // DEPRECATED
 #include <mitkTimeSlicedGeometry.h>
 
 namespace mitk
 {
   class NavigationController;
   class SliceNavigationController;
   class CameraRotationController;
   class CameraController;
   class DataStorage;
   class Mapper;
   class BaseLocalStorageHandler;
   class KeyEvent;
 
   //##Documentation
   //## @brief Organizes the rendering process
   //##
   //## Organizes the rendering process. A Renderer contains a reference to a
   //## DataStorage and asks the mappers of the data objects to render
   //## the data into the renderwindow it is associated to.
   //##
   //## \#Render() checks if rendering is currently allowed by calling
   //## RenderWindow::PrepareRendering(). Initialization of a rendering context
   //## can also be performed in this method.
   //##
   //## The actual rendering code has been moved to \#Repaint()
   //## Both \#Repaint() and \#Update() are declared protected now.
   //##
   //## Note: Separation of the Repaint and Update processes (rendering vs
   //## creating a vtk prop tree) still needs to be worked on. The whole
   //## rendering process also should be reworked to use VTK based classes for
   //## both 2D and 3D rendering.
   //## @ingroup Renderer
   class MITKCORE_EXPORT BaseRenderer : public itk::Object
   {
   public:
     /** \brief This rendering mode enumeration is specified at various constructors
     *  of the Renderer and RenderWindow classes, which autoconfigures the
     *  respective VTK objects. This has to be done at construction time because later
     *  configuring turns out to be not working on most platforms.
     */
     struct RenderingMode
     {
       enum Type
       {
         Standard = 0,  // no multi-sampling, no depth-peeling
-        MultiSampling, // multi-sampling (antialiasing), no depth-peeling
         DepthPeeling   // no multi-sampling, depth-peeling is on (order-independant transparency)
       };
     };
 
     typedef std::map<vtkRenderWindow *, BaseRenderer *> BaseRendererMapType;
     static BaseRendererMapType baseRendererMap;
 
     static BaseRenderer *GetInstance(vtkRenderWindow *renWin);
     static void AddInstance(vtkRenderWindow *renWin, BaseRenderer *baseRenderer);
     static void RemoveInstance(vtkRenderWindow *renWin);
 
     static BaseRenderer *GetByName(const std::string &name);
     static vtkRenderWindow *GetRenderWindowByName(const std::string &name);
 
 #pragma GCC visibility push(default)
     itkEventMacro(RendererResetEvent, itk::AnyEvent);
 #pragma GCC visibility pop
 
     /** Standard class typedefs. */
     mitkClassMacroItkParent(BaseRenderer, itk::Object);
 
     BaseRenderer(const char *name = nullptr,
                  vtkRenderWindow *renWin = nullptr,
                  mitk::RenderingManager *rm = nullptr,
                  RenderingMode::Type mode = RenderingMode::Standard);
 
     //##Documentation
     //## @brief MapperSlotId defines which kind of mapper (e.g., 2D or 3D) shoud be used.
     typedef int MapperSlotId;
 
     enum StandardMapperSlot
     {
       Standard2D = 1,
       Standard3D = 2
     };
 
     virtual void SetDataStorage(DataStorage *storage); ///< set the datastorage that will be used for rendering
 
     //##Documentation
     //## return the DataStorage that is used for rendering
     virtual DataStorage::Pointer GetDataStorage() const { return m_DataStorage.GetPointer(); }
     //##Documentation
     //## @brief Access the RenderWindow into which this renderer renders.
     vtkRenderWindow *GetRenderWindow() const { return m_RenderWindow; }
     vtkRenderer *GetVtkRenderer() const { return m_VtkRenderer; }
     //##Documentation
     //## @brief Returns the Dispatcher which handles Events for this BaseRenderer
     Dispatcher::Pointer GetDispatcher() const;
 
     //##Documentation
     //## @brief Default mapper id to use.
     static const MapperSlotId defaultMapper;
 
     //##Documentation
     //## @brief Do the rendering and flush the result.
     virtual void Paint();
 
     //##Documentation
     //## @brief Initialize the RenderWindow. Should only be called from RenderWindow.
     virtual void Initialize();
 
     //##Documentation
     //## @brief Called to inform the renderer that the RenderWindow has been resized.
     virtual void Resize(int w, int h);
 
     //##Documentation
     //## @brief Initialize the renderer with a RenderWindow (@a renderwindow).
     virtual void InitRenderer(vtkRenderWindow *renderwindow);
 
     //##Documentation
     //## @brief Set the initial size. Called by RenderWindow after it has become
     //## visible for the first time.
     virtual void InitSize(int w, int h);
 
     //##Documentation
     //## @brief Draws a point on the widget.
     //## Should be used during conferences to show the position of the remote mouse
     virtual void DrawOverlayMouse(Point2D &p2d);
 
     //##Documentation
     //## @brief Set/Get the WorldGeometry (m_WorldGeometry) for 3D and 2D rendering, that describing the
     //## (maximal) area to be rendered.
     //##
     //## Depending of the type of the passed BaseGeometry more or less information can be extracted:
     //## \li if it is a PlaneGeometry (which is a sub-class of BaseGeometry), m_CurrentWorldPlaneGeometry is
     //## also set to point to it. m_WorldTimeGeometry is set to nullptr.
     //## \li if it is a TimeGeometry, m_WorldTimeGeometry is also set to point to it.
     //## If m_WorldTimeGeometry contains instances of SlicedGeometry3D, m_CurrentWorldPlaneGeometry is set to
     //## one of geometries stored in the SlicedGeometry3D according to the value of m_Slice;  otherwise
     //## a PlaneGeometry describing the top of the bounding-box of the BaseGeometry is set as the
     //## m_CurrentWorldPlaneGeometry.
     //## \li otherwise a PlaneGeometry describing the top of the bounding-box of the BaseGeometry
     //## is set as the m_CurrentWorldPlaneGeometry. m_WorldTimeGeometry is set to nullptr.
     //## @todo add calculation of PlaneGeometry describing the top of the bounding-box of the BaseGeometry
     //## when the passed BaseGeometry is not sliced.
     //## \sa m_WorldGeometry
     //## \sa m_WorldTimeGeometry
     //## \sa m_CurrentWorldPlaneGeometry
     virtual void SetWorldGeometry3D(BaseGeometry *geometry);
     virtual void SetWorldTimeGeometry(mitk::TimeGeometry *geometry);
 
     /**
     * \deprecatedSince{2013_09} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see
     * http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
     */
     DEPRECATED(void SetWorldGeometry3D(TimeSlicedGeometry *geometry));
 
     itkGetConstObjectMacro(WorldTimeGeometry, TimeGeometry) itkGetObjectMacro(WorldTimeGeometry, TimeGeometry)
 
       //##Documentation
       //## @brief Get the current 3D-worldgeometry (m_CurrentWorldGeometry) used for 3D-rendering
       itkGetConstObjectMacro(CurrentWorldGeometry, BaseGeometry)
 
       //##Documentation
       //## @brief Get the current 2D-worldgeometry (m_CurrentWorldPlaneGeometry) used for 2D-rendering
       itkGetConstObjectMacro(CurrentWorldPlaneGeometry, PlaneGeometry)
       /**
       * \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometry
       */
       DEPRECATED(const PlaneGeometry *GetCurrentWorldGeometry2D())
     {
       return GetCurrentWorldPlaneGeometry();
     };
 
     //##Documentation
     //## Calculates the bounds of the DataStorage (if it contains any valid data),
     //## creates a geometry from these bounds and sets it as world geometry of the renderer.
     //##
     //## Call this method to re-initialize the renderer to the current DataStorage
     //## (e.g. after loading an additional dataset), to ensure that the view is
     //## aligned correctly.
     //## \warn This is not implemented yet.
     virtual bool SetWorldGeometryToDataStorageBounds() { return false; }
     //##Documentation
     //## @brief Set/Get m_Slice which defines together with m_TimeStep the 2D geometry
     //## stored in m_WorldTimeGeometry used as m_CurrentWorldPlaneGeometry
     //##
     //## \sa m_Slice
     virtual void SetSlice(unsigned int slice);
 
     itkGetConstMacro(Slice, unsigned int)
 
       //##Documentation
       //## @brief Set/Get m_TimeStep which defines together with m_Slice the 2D geometry
       //## stored in m_WorldTimeGeometry used as m_CurrentWorldPlaneGeometry
       //##
       //## \sa m_TimeStep
       virtual void SetTimeStep(unsigned int timeStep);
 
     itkGetConstMacro(TimeStep, unsigned int)
 
       //##Documentation
       //## @brief Get the time-step of a BaseData object which
       //## exists at the time of the currently displayed content
       //##
       //## Returns -1 or mitk::BaseData::m_TimeSteps if there
       //## is no data at the current time.
       //## \sa GetTimeStep, m_TimeStep
       int GetTimeStep(const BaseData *data) const;
 
     //##Documentation
     //## @brief Get the time in ms of the currently displayed content
     //##
     //## \sa GetTimeStep, m_TimeStep
     ScalarType GetTime() const;
 
     //##Documentation
     //## @brief SetWorldGeometry is called according to the geometrySliceEvent,
     //## which is supposed to be a SliceNavigationController::GeometrySendEvent
     virtual void SetGeometry(const itk::EventObject &geometrySliceEvent);
 
     //##Documentation
     //## @brief UpdateWorldGeometry is called to re-read the 2D geometry from the
     //## slice navigation controller
     virtual void UpdateGeometry(const itk::EventObject &geometrySliceEvent);
 
     //##Documentation
     //## @brief SetSlice is called according to the geometrySliceEvent,
     //## which is supposed to be a SliceNavigationController::GeometrySliceEvent
     virtual void SetGeometrySlice(const itk::EventObject &geometrySliceEvent);
 
     //##Documentation
     //## @brief SetTimeStep is called according to the geometrySliceEvent,
     //## which is supposed to be a SliceNavigationController::GeometryTimeEvent
     virtual void SetGeometryTime(const itk::EventObject &geometryTimeEvent);
 
     //##Documentation
     //## @brief Get a DataNode pointing to a data object containing the current 2D-worldgeometry
     // m_CurrentWorldPlaneGeometry (for 2D rendering)
     itkGetObjectMacro(CurrentWorldPlaneGeometryNode, DataNode)
       /**
       * \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometryNode
       */
       DEPRECATED(DataNode *GetCurrentWorldGeometry2DNode())
     {
       return GetCurrentWorldPlaneGeometryNode();
     };
 
     //##Documentation
     //## @brief Sets timestamp of CurrentWorldPlaneGeometry and forces so reslicing in that renderwindow
     void SendUpdateSlice();
 
     //##Documentation
     //## @brief Get timestamp of last call of SetCurrentWorldPlaneGeometry
     unsigned long GetCurrentWorldPlaneGeometryUpdateTime() { return m_CurrentWorldPlaneGeometryUpdateTime; }
     /**
     * \deprecatedSince{2014_10} Please use GetCurrentWorldPlaneGeometryUpdateTime
     */
     DEPRECATED(unsigned long GetCurrentWorldGeometry2DUpdateTime())
     {
       return GetCurrentWorldPlaneGeometryUpdateTime();
     };
     //##Documentation
     //## @brief Get timestamp of last change of current TimeStep
     unsigned long GetTimeStepUpdateTime() { return m_TimeStepUpdateTime; }
     //##Documentation
     //## @brief Perform a picking: find the x,y,z world coordinate of a
     //## display x,y coordinate.
     //## @warning Has to be overwritten in subclasses for the 3D-case.
     //##
     //## Implemented here only for 2D-rendering
     virtual void PickWorldPoint(const Point2D &diplayPosition, Point3D &worldPosition) const = 0;
 
     /** \brief Determines the object (mitk::DataNode) closest to the current
     * position by means of picking
     *
     * \warning Implementation currently empty for 2D rendering; intended to be
     * implemented for 3D renderers */
     virtual DataNode *PickObject(const Point2D & /*displayPosition*/, Point3D & /*worldPosition*/) const
     {
       return nullptr;
     }
 
     //##Documentation
     //## @brief Get the MapperSlotId to use.
     itkGetMacro(MapperID, MapperSlotId) itkGetConstMacro(MapperID, MapperSlotId)
 
       //##Documentation
       //## @brief Set the MapperSlotId to use.
       itkSetMacro(MapperID, MapperSlotId)
 
         virtual int *GetSize() const;
     virtual int *GetViewportSize() const;
 
     void SetSliceNavigationController(SliceNavigationController *SlicenavigationController);
     itkGetObjectMacro(CameraController, CameraController)
       itkGetObjectMacro(SliceNavigationController, SliceNavigationController)
         itkGetObjectMacro(CameraRotationController, CameraRotationController)
 
           itkGetMacro(EmptyWorldGeometry, bool)
 
       //##Documentation
       //## @brief Tells if the displayed region is shifted and rescaled if the render window is resized.
       itkGetMacro(KeepDisplayedRegion, bool)
       //##Documentation
       //## @brief Tells if the displayed region should be shifted and rescaled if the render window is resized.
       itkSetMacro(KeepDisplayedRegion, bool)
 
       //##Documentation
       //## @brief get the name of the Renderer
       //## @note
       const char *GetName() const
     {
       return m_Name.c_str();
     }
 
     //##Documentation
     //## @brief get the x_size of the RendererWindow
     //## @note
     int GetSizeX() const { return GetSize()[0]; }
     //##Documentation
     //## @brief get the y_size of the RendererWindow
     //## @note
     int GetSizeY() const { return GetSize()[1]; }
     const double *GetBounds() const;
 
     void RequestUpdate();
     void ForceImmediateUpdate();
 
     /** Returns number of mappers which are visible and have level-of-detail
     * rendering enabled */
     unsigned int GetNumberOfVisibleLODEnabledMappers() const;
 
     ///**
     //* \brief Setter for the RenderingManager that handles this instance of BaseRenderer
     //*/
     // void SetRenderingManager( mitk::RenderingManager* );
 
     /**
     * \brief Getter for the RenderingManager that handles this instance of BaseRenderer
     */
     virtual mitk::RenderingManager *GetRenderingManager() const;
 
     //##Documentation
     //## @brief This method converts a display point to the 3D world index
     //## using the geometry of the renderWindow.
     void DisplayToWorld(const Point2D &displayPoint, Point3D &worldIndex) const;
 
     //##Documentation
     //## @brief This method converts a display point to the 2D world index, mapped onto the display plane
     //## using the geometry of the renderWindow.
     void DisplayToPlane(const Point2D &displayPoint, Point2D &planePointInMM) const;
 
     //##Documentation
     //## @brief This method converts a 3D world index to the display point
     //## using the geometry of the renderWindow.
     void WorldToDisplay(const Point3D &worldIndex, Point2D &displayPoint) const;
 
     //##Documentation
     //## @brief This method converts a 3D world index to the point on the viewport
     //## using the geometry of the renderWindow.
     void WorldToView(const Point3D &worldIndex, Point2D &viewPoint) const;
 
     //##Documentation
     //## @brief This method converts a 2D plane coordinate to the display point
     //## using the geometry of the renderWindow.
     void PlaneToDisplay(const Point2D &planePointInMM, Point2D &displayPoint) const;
 
     //##Documentation
     //## @brief This method converts a 2D plane coordinate to the point on the viewport
     //## using the geometry of the renderWindow.
     void PlaneToView(const Point2D &planePointInMM, Point2D &viewPoint) const;
 
 
     double GetScaleFactorMMPerDisplayUnit() const;
 
     Point2D GetDisplaySizeInMM() const;
     Point2D GetViewportSizeInMM() const;
 
     Point2D GetOriginInMM() const;
 
     itkGetConstMacro(ConstrainZoomingAndPanning, bool) virtual void SetConstrainZoomingAndPanning(bool constrain);
 
     /**
     * \brief Provides (1) world coordinates for a given mouse position and (2)
     * translates mousePosition to Display coordinates
     * \deprecated Map2DRendererPositionTo3DWorldPosition is deprecated. Please use DisplayToWorld instead.
     */
     DEPRECATED(virtual Point3D Map2DRendererPositionTo3DWorldPosition(const Point2D &mousePosition) const);
 
   protected:
     ~BaseRenderer() override;
 
     //##Documentation
     //## @brief Call update of all mappers. To be implemented in subclasses.
     virtual void Update() = 0;
 
     vtkRenderWindow *m_RenderWindow;
     vtkRenderer *m_VtkRenderer;
 
     //##Documentation
     //## @brief MapperSlotId to use. Defines which kind of mapper (e.g., 2D or 3D) shoud be used.
     MapperSlotId m_MapperID;
 
     //##Documentation
     //## @brief The DataStorage that is used for rendering.
     DataStorage::Pointer m_DataStorage;
 
     //##Documentation
     //## @brief The RenderingManager that manages this instance
     RenderingManager::Pointer m_RenderingManager;
 
     //##Documentation
     //## @brief Timestamp of last call of Update().
     unsigned long m_LastUpdateTime;
 
     //##Documentation
     //## @brief CameraController for 3D rendering
     //## @note preliminary.
     itk::SmartPointer<CameraController> m_CameraController;
     SliceNavigationController::Pointer m_SliceNavigationController;
     CameraRotationController::Pointer m_CameraRotationController;
 
     //##Documentation
     //## @brief Sets m_CurrentWorldPlaneGeometry
     virtual void SetCurrentWorldPlaneGeometry(PlaneGeometry *geometry2d);
     /**
     * \deprecatedSince{2014_10} Please use SetCurrentWorldPlaneGeometry
     */
     DEPRECATED(void SetCurrentWorldGeometry2D(PlaneGeometry *geometry2d)) { SetCurrentWorldPlaneGeometry(geometry2d); };
     //##Documentation
     //## @brief Sets m_CurrentWorldGeometry
     virtual void SetCurrentWorldGeometry(BaseGeometry *geometry);
 
   private:
     //##Documentation
     //## m_WorldTimeGeometry is set by SetWorldGeometry if the passed BaseGeometry is a
     //## TimeGeometry (or a sub-class of it). If it contains instances of SlicedGeometry3D,
     //## m_Slice and m_TimeStep (set via SetSlice and SetTimeStep, respectively) define
     //## which 2D geometry stored in m_WorldTimeGeometry (if available)
     //## is used as m_CurrentWorldPlaneGeometry.
     //## \sa m_CurrentWorldPlaneGeometry
     TimeGeometry::Pointer m_WorldTimeGeometry;
 
     //##Documentation
     //## Pointer to the current 3D-worldgeometry.
     BaseGeometry::Pointer m_CurrentWorldGeometry;
 
     //##Documentation
     //## Pointer to the current 2D-worldgeometry. The 2D-worldgeometry
     //## describes the maximal area (2D manifold) to be rendered in case we
     //## are doing 2D-rendering.
     //## It is const, since we are not allowed to change it (it may be taken
     //## directly from the geometry of an image-slice and thus it would be
     //## very strange when suddenly the image-slice changes its geometry).
     PlaneGeometry::Pointer m_CurrentWorldPlaneGeometry;
 
     //##Documentation
     //## Defines together with m_Slice which 2D geometry stored in m_WorldTimeGeometry
     //## is used as m_CurrentWorldPlaneGeometry: m_WorldTimeGeometry->GetPlaneGeometry(m_Slice, m_TimeStep).
     //## \sa m_WorldTimeGeometry
     unsigned int m_Slice;
     //##Documentation
     //## Defines together with m_TimeStep which 2D geometry stored in m_WorldTimeGeometry
     //## is used as m_CurrentWorldPlaneGeometry: m_WorldTimeGeometry->GetPlaneGeometry(m_Slice, m_TimeStep).
     //## \sa m_WorldTimeGeometry
     unsigned int m_TimeStep;
 
     //##Documentation
     //## @brief timestamp of last call of SetWorldGeometry
     itk::TimeStamp m_CurrentWorldPlaneGeometryUpdateTime;
 
     //##Documentation
     //## @brief timestamp of last change of the current time step
     itk::TimeStamp m_TimeStepUpdateTime;
 
     //##Documentation
     //## @brief Helper class which establishes connection between Interactors and Dispatcher via a common DataStorage.
     BindDispatcherInteractor *m_BindDispatcherInteractor;
 
     //##Documentation
     //## @brief Tells if the displayed region should be shifted or rescaled if the render window is resized.
     bool m_KeepDisplayedRegion;
 
   protected:
     void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
     //##Documentation
     //## Data object containing the m_CurrentWorldPlaneGeometry defined above.
     PlaneGeometryData::Pointer m_CurrentWorldPlaneGeometryData;
 
     //##Documentation
     //## DataNode objects containing the m_CurrentWorldPlaneGeometryData defined above.
     DataNode::Pointer m_CurrentWorldPlaneGeometryNode;
 
     //##Documentation
     //## @brief test only
     unsigned long m_CurrentWorldPlaneGeometryTransformTime;
 
     std::string m_Name;
 
     double m_Bounds[6];
 
     bool m_EmptyWorldGeometry;
 
     typedef std::set<Mapper *> LODEnabledMappersType;
 
     /** Number of mappers which are visible and have level-of-detail
     * rendering enabled */
     unsigned int m_NumberOfVisibleLODEnabledMappers;
 
     // Local Storage Handling for mappers
 
   protected:
     std::list<mitk::BaseLocalStorageHandler *> m_RegisteredLocalStorageHandlers;
 
     bool m_ConstrainZoomingAndPanning;
 
   public:
     void RemoveAllLocalStorages();
     void RegisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh);
     void UnregisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh);
   };
 } // namespace mitk
 
 #endif /* BASERENDERER_H_HEADER_INCLUDED_C1CCA0F4 */
diff --git a/Modules/Core/src/Rendering/mitkRenderWindow.cpp b/Modules/Core/src/Rendering/mitkRenderWindow.cpp
index 3507b08084..4a53f2640b 100644
--- a/Modules/Core/src/Rendering/mitkRenderWindow.cpp
+++ b/Modules/Core/src/Rendering/mitkRenderWindow.cpp
@@ -1,97 +1,85 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkRenderWindow.h"
 
 #include "mitkRenderingManager.h"
 #include "mitkVtkEventProvider.h"
 #include "mitkVtkLayerController.h"
 #include "vtkRenderWindowInteractor.h"
 #include "vtkRenderer.h"
 
 mitk::RenderWindow::RenderWindow(vtkRenderWindow *renWin,
                                  const char *name,
                                  mitk::RenderingManager *rm,
                                  mitk::BaseRenderer::RenderingMode::Type rmtype)
   : m_vtkRenderWindow(renWin), m_vtkRenderWindowInteractor(nullptr), m_vtkMitkEventProvider(nullptr)
 {
   if (m_vtkRenderWindow == nullptr)
   {
     m_vtkRenderWindow = vtkRenderWindow::New();
-
-    if (rmtype == mitk::BaseRenderer::RenderingMode::DepthPeeling)
-    {
-      m_vtkRenderWindow->SetMultiSamples(0);
-      m_vtkRenderWindow->SetAlphaBitPlanes(1);
-    }
-    else if (rmtype == mitk::BaseRenderer::RenderingMode::MultiSampling)
-    {
-      m_vtkRenderWindow->SetMultiSamples(8);
-    }
-    else if (rmtype == mitk::BaseRenderer::RenderingMode::Standard)
-    {
-      m_vtkRenderWindow->SetMultiSamples(0);
-    }
+    m_vtkRenderWindow->SetMultiSamples(0);
+    m_vtkRenderWindow->SetAlphaBitPlanes(rmtype == BaseRenderer::RenderingMode::DepthPeeling ? 1 : 0);
   }
 
   if (m_vtkRenderWindow->GetSize()[0] <= 10)
   {
     m_vtkRenderWindow->SetSize(100, 100);
   }
 
   m_vtkRenderWindowInteractor = vtkRenderWindowInteractor::New();
   m_vtkRenderWindowInteractor->SetRenderWindow(m_vtkRenderWindow);
   m_vtkRenderWindowInteractor->Initialize();
 
   // initialize from RenderWindowBase
   Initialize(rm, name, rmtype);
 
   m_vtkMitkEventProvider = vtkEventProvider::New();
   m_vtkMitkEventProvider->SetInteractor(this->GetVtkRenderWindowInteractor());
   m_vtkMitkEventProvider->SetMitkRenderWindow(this);
   m_vtkMitkEventProvider->SetEnabled(1);
 }
 
 mitk::RenderWindow::~RenderWindow()
 {
   Destroy();
   m_vtkRenderWindow->Delete();
   m_vtkRenderWindowInteractor->Delete();
   m_vtkMitkEventProvider->Delete();
 }
 
 vtkRenderWindow *mitk::RenderWindow::GetVtkRenderWindow()
 {
   return m_vtkRenderWindow;
 }
 
 vtkRenderWindowInteractor *mitk::RenderWindow::GetVtkRenderWindowInteractor()
 {
   return m_vtkRenderWindowInteractor;
 }
 
 void mitk::RenderWindow::SetSize(int width, int height)
 {
   this->GetVtkRenderWindow()->SetSize(width, height);
 }
 
 void mitk::RenderWindow::ReinitEventProvider()
 {
   m_vtkMitkEventProvider->SetEnabled(0);
   m_vtkMitkEventProvider->SetInteractor(this->GetVtkRenderWindowInteractor());
   m_vtkMitkEventProvider->SetMitkRenderWindow(this);
   m_vtkMitkEventProvider->SetEnabled(1);
 }
diff --git a/Modules/QtWidgets/include/QmitkRenderWindow.h b/Modules/QtWidgets/include/QmitkRenderWindow.h
index df07c15f69..fa8c988407 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindow.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindow.h
@@ -1,172 +1,172 @@
 /*===================================================================
 
  The Medical Imaging Interaction Toolkit (MITK)
 
  Copyright (c) German Cancer Research Center,
  Division of Medical and Biological Informatics.
  All rights reserved.
 
  This software is distributed WITHOUT ANY WARRANTY; without
  even the implied warranty of MERCHANTABILITY or FITNESS FOR
  A PARTICULAR PURPOSE.
 
  See LICENSE.txt or http://www.mitk.org for details.
 
  ===================================================================*/
 
 #ifndef QMITKRENDERWINDOW_H_HEADER_INCLUDED_C1C40D66
 #define QMITKRENDERWINDOW_H_HEADER_INCLUDED_C1C40D66
 
 #include "mitkRenderWindowBase.h"
 
 #include "QmitkRenderWindowMenu.h"
 #include <MitkQtWidgetsExports.h>
 
 #include <vtkGenericOpenGLRenderWindow.h>
 #include <QVTKOpenGLWidget.h>
 
 #include "mitkBaseRenderer.h"
 #include "mitkInteractionEventConst.h"
 
 class QmitkStdMultiWidget;
 class QDragEnterEvent;
 class QDropEvent;
 class QInputEvent;
 
 /**
  * \ingroup QmitkModule
  * \brief MITK implementation of the QVTKWidget
  */
 class MITKQTWIDGETS_EXPORT QmitkRenderWindow : public QVTKOpenGLWidget, public mitk::RenderWindowBase
 {
   Q_OBJECT
 
 public:
   QmitkRenderWindow(
     QWidget *parent = nullptr,
-    QString name = "unnamed renderwindow",
+    const QString &name = "unnamed renderwindow",
     mitk::VtkPropRenderer *renderer = nullptr,
     mitk::RenderingManager *renderingManager = nullptr,
     mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard);
   ~QmitkRenderWindow() override;
 
   /**
    * \brief Whether Qt events should be passed to parent (default: true)
    *
    * With introduction of the QVTKWidget the behaviour regarding Qt events changed.
    * QVTKWidget "accepts" Qt events like mouse clicks (i.e. set an "accepted" flag).
    * When this flag is set, Qt fininshed handling of this event -- otherwise it is
    * reached through to the widget's parent.
    *
    * This reaching through to the parent was implicitly required by QmitkMaterialWidget / QmitkMaterialShowCase.
    *QmitkStdMultiWidget
    * The default behaviour of QmitkRenderWindow is now to clear the "accepted" flag
    * of Qt events after they were handled by QVTKWidget. This way parents can also
    * handle events.
    *
    * If you don't want this behaviour, call SetResendQtEvents(true) on your render window.
    */
   virtual void SetResendQtEvents(bool resend);
 
   // Set Layout Index to define the Layout Type
   void SetLayoutIndex(unsigned int layoutIndex);
 
   // Get Layout Index to define the Layout Type
   unsigned int GetLayoutIndex();
 
   // MenuWidget need to update the Layout Design List when Layout had changed
   void LayoutDesignListChanged(int layoutDesignIndex);
 
   void HideRenderWindowMenu();
 
   // Activate or Deactivate MenuWidget.
   void ActivateMenuWidget(bool state, QmitkStdMultiWidget *stdMultiWidget = nullptr);
 
   bool GetActivateMenuWidgetFlag() { return m_MenuWidgetActivated; }
   // Get it from the QVTKWidget parent
   vtkRenderWindow *GetVtkRenderWindow() override { return GetRenderWindow(); }
   vtkRenderWindowInteractor *GetVtkRenderWindowInteractor() override { return nullptr; }
   void FullScreenMode(bool state);
 
 protected:
   // overloaded move handler
   void moveEvent(QMoveEvent *event) override;
   // overloaded show handler
   void showEvent(QShowEvent *event) override;
   // overloaded mouse press handler
   void mousePressEvent(QMouseEvent *event) override;
   // overloaded mouse double-click handler
   void mouseDoubleClickEvent(QMouseEvent *event) override;
   // overloaded mouse move handler
   void mouseMoveEvent(QMouseEvent *event) override;
   // overloaded mouse release handler
   void mouseReleaseEvent(QMouseEvent *event) override;
   // overloaded key press handler
   void keyPressEvent(QKeyEvent *event) override;
   // overloaded enter handler
   void enterEvent(QEvent *) override;
   // overloaded leave handler
   void leaveEvent(QEvent *) override;
 
   // Overloaded resize handler, see decs in QVTKOpenGLWidget.
   // Basically, we have to ensure the VTK rendering is updated for each change in window size.
   void resizeGL(int w, int h) Q_DECL_OVERRIDE;
 
   /// \brief Simply says we accept the event type.
   void dragEnterEvent(QDragEnterEvent *event) override;
 
   /// \brief If the dropped type is application/x-mitk-datanodes we process the request by converting to mitk::DataNode
   /// pointers and emitting the NodesDropped signal.
   void dropEvent(QDropEvent *event) override;
 
 #ifndef QT_NO_WHEELEVENT
   // overload wheel mouse event
   void wheelEvent(QWheelEvent *) override;
 #endif
 
   void AdjustRenderWindowMenuVisibility(const QPoint &pos);
 
 signals:
 
   void ResetView();
   // \brief int parameters are enum from QmitkStdMultiWidget
   void ChangeCrosshairRotationMode(int);
 
   void SignalLayoutDesignChanged(int layoutDesignIndex);
 
   void moved();
 
   /// \brief Emits a signal to say that this window has had the following nodes dropped on it.
   void NodesDropped(QmitkRenderWindow *thisWindow, std::vector<mitk::DataNode *> nodes);
 
 protected slots:
 
   void OnChangeLayoutDesign(int layoutDesignIndex);
 
   void OnWidgetPlaneModeChanged(int);
 
   void DeferredHideMenu();
 
 private:
   // Helper Functions to Convert Qt-Events to Mitk-Events
 
   mitk::Point2D GetMousePosition(QMouseEvent *me) const;
   mitk::Point2D GetMousePosition(QWheelEvent *we) const;
   mitk::InteractionEvent::MouseButtons GetEventButton(QMouseEvent *me) const;
   mitk::InteractionEvent::MouseButtons GetButtonState(QMouseEvent *me) const;
   mitk::InteractionEvent::ModifierKeys GetModifiers(QInputEvent *me) const;
   mitk::InteractionEvent::MouseButtons GetButtonState(QWheelEvent *we) const;
   std::string GetKeyLetter(QKeyEvent *ke) const;
   int GetDelta(QWheelEvent *we) const;
   bool m_ResendQtEvents;
 
   QmitkRenderWindowMenu *m_MenuWidget;
 
   bool m_MenuWidgetActivated;
 
   unsigned int m_LayoutIndex;
 
   vtkSmartPointer<vtkGenericOpenGLRenderWindow> m_InternalRenderWindow;
 };
 
 #endif
diff --git a/Modules/QtWidgets/src/QmitkRenderWindow.cpp b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
index 6ab8bb595b..107a4bdf69 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindow.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
@@ -1,515 +1,504 @@
 /*===================================================================
 
  The Medical Imaging Interaction Toolkit (MITK)
 
  Copyright (c) German Cancer Research Center,
  Division of Medical and Biological Informatics.
  All rights reserved.
 
  This software is distributed WITHOUT ANY WARRANTY; without
  even the implied warranty of MERCHANTABILITY or FITNESS FOR
  A PARTICULAR PURPOSE.
 
  See LICENSE.txt or http://www.mitk.org for details.
 
  ===================================================================*/
 
 #include "QmitkRenderWindow.h"
 
 #include "mitkInteractionKeyEvent.h"
 #include "mitkInternalEvent.h"
 #include "mitkMouseDoubleClickEvent.h"
 #include "mitkMouseMoveEvent.h"
 #include "mitkMousePressEvent.h"
 #include "mitkMouseReleaseEvent.h"
 #include "mitkMouseWheelEvent.h"
 #include <QCursor>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QKeyEvent>
 #include <QMouseEvent>
 #include <QResizeEvent>
 #include <QSurfaceFormat>
 #include <QTimer>
 #include <QWheelEvent>
 #include <QWindow>
 
 #include "QmitkMimeTypes.h"
 #include "QmitkRenderWindowMenu.h"
 
-QmitkRenderWindow::QmitkRenderWindow(QWidget *parent,
-                                     QString name,
-                                     mitk::VtkPropRenderer * /*renderer*/,
-                                     mitk::RenderingManager *renderingManager,
-                                     mitk::BaseRenderer::RenderingMode::Type renderingMode)
-  : QVTKOpenGLWidget(parent), m_ResendQtEvents(true), m_MenuWidget(nullptr), m_MenuWidgetActivated(false), m_LayoutIndex(0)
+QmitkRenderWindow::QmitkRenderWindow(QWidget *parent, const QString &name, mitk::VtkPropRenderer *, mitk::RenderingManager *renderingManager, mitk::BaseRenderer::RenderingMode::Type renderingMode)
+  : QVTKOpenGLWidget(parent),
+    m_ResendQtEvents(true),
+    m_MenuWidget(nullptr),
+    m_MenuWidgetActivated(false),
+    m_LayoutIndex(0)
 {
   m_InternalRenderWindow = vtkSmartPointer<vtkGenericOpenGLRenderWindow>::New();
-  this->SetRenderWindow(m_InternalRenderWindow);
+  m_InternalRenderWindow->SetMultiSamples(0);
+  m_InternalRenderWindow->SetAlphaBitPlanes(mitk::BaseRenderer::RenderingMode::DepthPeeling == renderingMode ? 1 : 0);
 
-  if (renderingMode == mitk::BaseRenderer::RenderingMode::DepthPeeling)
-  {
-    GetRenderWindow()->SetMultiSamples(0);
-    GetRenderWindow()->SetAlphaBitPlanes(1);
-  }
-  else if (renderingMode == mitk::BaseRenderer::RenderingMode::MultiSampling)
-  {
-    GetRenderWindow()->SetMultiSamples(8);
-  }
-  else if (renderingMode == mitk::BaseRenderer::RenderingMode::Standard)
-  {
-    GetRenderWindow()->SetMultiSamples(0);
-  }
+  this->SetRenderWindow(m_InternalRenderWindow);
 
-  Initialize(renderingManager, name.toStdString().c_str(), renderingMode); // Initialize mitkRenderWindowBase
+  this->Initialize(renderingManager, name.toStdString().c_str(), renderingMode);
 
-  setFocusPolicy(Qt::StrongFocus);
-  setMouseTracking(true);
+  this->setFocusPolicy(Qt::StrongFocus);
+  this->setMouseTracking(true);
 }
 
 QmitkRenderWindow::~QmitkRenderWindow()
 {
   Destroy(); // Destroy mitkRenderWindowBase
 }
 
 void QmitkRenderWindow::SetResendQtEvents(bool resend)
 {
   m_ResendQtEvents = resend;
 }
 
 void QmitkRenderWindow::SetLayoutIndex(unsigned int layoutIndex)
 {
   m_LayoutIndex = layoutIndex;
   if (m_MenuWidget)
     m_MenuWidget->SetLayoutIndex(layoutIndex);
 }
 
 unsigned int QmitkRenderWindow::GetLayoutIndex()
 {
   if (m_MenuWidget)
     return m_MenuWidget->GetLayoutIndex();
   else
     return 0;
 }
 
 void QmitkRenderWindow::LayoutDesignListChanged(int layoutDesignIndex)
 {
   if (m_MenuWidget)
     m_MenuWidget->UpdateLayoutDesignList(layoutDesignIndex);
 }
 
 void QmitkRenderWindow::mousePressEvent(QMouseEvent *me)
 {
   // Get mouse position in vtk display coordinate system. me contains qt display infos...
   mitk::Point2D displayPos = GetMousePosition(me);
 
   mitk::MousePressEvent::Pointer mPressEvent =
     mitk::MousePressEvent::New(m_Renderer, displayPos, GetButtonState(me), GetModifiers(me), GetEventButton(me));
 
   if (!this->HandleEvent(mPressEvent.GetPointer()))
   {
     QVTKOpenGLWidget::mousePressEvent(me);
   }
 
   if (m_ResendQtEvents)
     me->ignore();
 }
 
 void QmitkRenderWindow::mouseDoubleClickEvent(QMouseEvent *me)
 {
   mitk::Point2D displayPos = GetMousePosition(me);
   mitk::MouseDoubleClickEvent::Pointer mPressEvent =
     mitk::MouseDoubleClickEvent::New(m_Renderer, displayPos, GetButtonState(me), GetModifiers(me), GetEventButton(me));
 
   if (!this->HandleEvent(mPressEvent.GetPointer()))
   {
     QVTKOpenGLWidget::mousePressEvent(me);
   }
 
   if (m_ResendQtEvents)
     me->ignore();
 }
 
 void QmitkRenderWindow::mouseReleaseEvent(QMouseEvent *me)
 {
   mitk::Point2D displayPos = GetMousePosition(me);
   mitk::MouseReleaseEvent::Pointer mReleaseEvent =
     mitk::MouseReleaseEvent::New(m_Renderer, displayPos, GetButtonState(me), GetModifiers(me), GetEventButton(me));
 
   if (!this->HandleEvent(mReleaseEvent.GetPointer()))
   {
     QVTKOpenGLWidget::mouseReleaseEvent(me);
   }
 
   if (m_ResendQtEvents)
     me->ignore();
 }
 
 void QmitkRenderWindow::mouseMoveEvent(QMouseEvent *me)
 {
   mitk::Point2D displayPos = GetMousePosition(me);
 
   this->AdjustRenderWindowMenuVisibility(me->pos());
 
   mitk::MouseMoveEvent::Pointer mMoveEvent =
     mitk::MouseMoveEvent::New(m_Renderer, displayPos, GetButtonState(me), GetModifiers(me));
 
   if (!this->HandleEvent(mMoveEvent.GetPointer()))
   {
     QVTKOpenGLWidget::mouseMoveEvent(me);
   }
 }
 
 void QmitkRenderWindow::wheelEvent(QWheelEvent *we)
 {
   mitk::Point2D displayPos = GetMousePosition(we);
   mitk::MouseWheelEvent::Pointer mWheelEvent =
     mitk::MouseWheelEvent::New(m_Renderer, displayPos, GetButtonState(we), GetModifiers(we), GetDelta(we));
 
   if (!this->HandleEvent(mWheelEvent.GetPointer()))
   {
     QVTKOpenGLWidget::wheelEvent(we);
   }
 
   if (m_ResendQtEvents)
     we->ignore();
 }
 
 void QmitkRenderWindow::keyPressEvent(QKeyEvent *ke)
 {
   mitk::InteractionEvent::ModifierKeys modifiers = GetModifiers(ke);
   std::string key = GetKeyLetter(ke);
 
   mitk::InteractionKeyEvent::Pointer keyEvent = mitk::InteractionKeyEvent::New(m_Renderer, key, modifiers);
   if (!this->HandleEvent(keyEvent.GetPointer()))
   {
     QVTKOpenGLWidget::keyPressEvent(ke);
   }
 
   if (m_ResendQtEvents)
     ke->ignore();
 }
 
 void QmitkRenderWindow::enterEvent(QEvent *e)
 {
   // TODO implement new event
   QVTKOpenGLWidget::enterEvent(e);
 }
 
 void QmitkRenderWindow::DeferredHideMenu()
 {
   MITK_DEBUG << "QmitkRenderWindow::DeferredHideMenu";
 
   if (m_MenuWidget)
     m_MenuWidget->HideMenu();
 }
 
 void QmitkRenderWindow::leaveEvent(QEvent *e)
 {
   mitk::InternalEvent::Pointer internalEvent = mitk::InternalEvent::New(this->m_Renderer, nullptr, "LeaveRenderWindow");
 
   this->HandleEvent(internalEvent.GetPointer());
 
   if (m_MenuWidget)
     m_MenuWidget->smoothHide();
 
   QVTKOpenGLWidget::leaveEvent(e);
 }
 
 //-----------------------------------------------------------------------------
 void QmitkRenderWindow::resizeGL(int w, int h)
 {
   this->GetRenderer()->GetRenderingManager()->ForceImmediateUpdate(GetRenderWindow());
   QVTKOpenGLWidget::resizeGL(w, h);
 }
 
 void QmitkRenderWindow::moveEvent(QMoveEvent *event)
 {
   QVTKOpenGLWidget::moveEvent(event);
 
   // after a move the overlays need to be positioned
   emit moved();
 }
 
 void QmitkRenderWindow::showEvent(QShowEvent *event)
 {
   QVTKOpenGLWidget::showEvent(event);
 
   // this singleshot is necessary to have the overlays positioned correctly after initial show
   // simple call of moved() is no use here!!
   QTimer::singleShot(0, this, SIGNAL(moved()));
 }
 
 void QmitkRenderWindow::ActivateMenuWidget(bool state, QmitkStdMultiWidget *stdMultiWidget)
 {
   m_MenuWidgetActivated = state;
 
   if (!m_MenuWidgetActivated && m_MenuWidget)
   {
     // disconnect Signal/Slot Connection
     disconnect(m_MenuWidget, SIGNAL(SignalChangeLayoutDesign(int)), this, SLOT(OnChangeLayoutDesign(int)));
     disconnect(m_MenuWidget, SIGNAL(ResetView()), this, SIGNAL(ResetView()));
     disconnect(m_MenuWidget, SIGNAL(ChangeCrosshairRotationMode(int)), this, SIGNAL(ChangeCrosshairRotationMode(int)));
 
     delete m_MenuWidget;
     m_MenuWidget = nullptr;
   }
   else if (m_MenuWidgetActivated && !m_MenuWidget)
   {
     // create render window MenuBar for split, close Window or set new setting.
     m_MenuWidget = new QmitkRenderWindowMenu(this, nullptr, m_Renderer, stdMultiWidget);
     m_MenuWidget->SetLayoutIndex(m_LayoutIndex);
 
     // create Signal/Slot Connection
     connect(m_MenuWidget, SIGNAL(SignalChangeLayoutDesign(int)), this, SLOT(OnChangeLayoutDesign(int)));
     connect(m_MenuWidget, SIGNAL(ResetView()), this, SIGNAL(ResetView()));
     connect(m_MenuWidget, SIGNAL(ChangeCrosshairRotationMode(int)), this, SIGNAL(ChangeCrosshairRotationMode(int)));
   }
 }
 
 void QmitkRenderWindow::AdjustRenderWindowMenuVisibility(const QPoint & /*pos*/)
 {
   if (m_MenuWidget)
   {
     m_MenuWidget->ShowMenu();
     m_MenuWidget->MoveWidgetToCorrectPos(1.0f);
   }
 }
 
 void QmitkRenderWindow::HideRenderWindowMenu()
 {
   // DEPRECATED METHOD
 }
 
 void QmitkRenderWindow::OnChangeLayoutDesign(int layoutDesignIndex)
 {
   emit SignalLayoutDesignChanged(layoutDesignIndex);
 }
 
 void QmitkRenderWindow::OnWidgetPlaneModeChanged(int mode)
 {
   if (m_MenuWidget)
     m_MenuWidget->NotifyNewWidgetPlanesMode(mode);
 }
 
 void QmitkRenderWindow::FullScreenMode(bool state)
 {
   if (m_MenuWidget)
     m_MenuWidget->ChangeFullScreenMode(state);
 }
 
 void QmitkRenderWindow::dragEnterEvent(QDragEnterEvent *event)
 {
   if (event->mimeData()->hasFormat("application/x-mitk-datanodes"))
   {
     event->accept();
   }
 }
 
 void QmitkRenderWindow::dropEvent(QDropEvent *event)
 {
   QList<mitk::DataNode *> dataNodeList = QmitkMimeTypes::ToDataNodePtrList(event->mimeData());
   if (!dataNodeList.empty())
   {
     emit NodesDropped(this, dataNodeList.toVector().toStdVector());
   }
 }
 
 mitk::Point2D QmitkRenderWindow::GetMousePosition(QMouseEvent *me) const
 {
   mitk::Point2D point;
   point[0] = me->x();
   // We need to convert the y component, as the display and vtk have other definitions for the y direction
   point[1] = m_Renderer->GetSizeY() - me->y();
   return point;
 }
 
 mitk::Point2D QmitkRenderWindow::GetMousePosition(QWheelEvent *we) const
 {
   mitk::Point2D point;
   point[0] = we->x();
   // We need to convert the y component, as the display and vtk have other definitions for the y direction
   point[1] = m_Renderer->GetSizeY() - we->y();
   return point;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetEventButton(QMouseEvent *me) const
 {
   mitk::InteractionEvent::MouseButtons eventButton;
   switch (me->button())
   {
     case Qt::LeftButton:
       eventButton = mitk::InteractionEvent::LeftMouseButton;
       break;
     case Qt::RightButton:
       eventButton = mitk::InteractionEvent::RightMouseButton;
       break;
     case Qt::MidButton:
       eventButton = mitk::InteractionEvent::MiddleMouseButton;
       break;
     default:
       eventButton = mitk::InteractionEvent::NoButton;
       break;
   }
   return eventButton;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QMouseEvent *me) const
 {
   mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
 
   if (me->buttons() & Qt::LeftButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
   }
   if (me->buttons() & Qt::RightButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
   }
   if (me->buttons() & Qt::MidButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
   }
   return buttonState;
 }
 
 mitk::InteractionEvent::ModifierKeys QmitkRenderWindow::GetModifiers(QInputEvent *me) const
 {
   mitk::InteractionEvent::ModifierKeys modifiers = mitk::InteractionEvent::NoKey;
 
   if (me->modifiers() & Qt::ALT)
   {
     modifiers = modifiers | mitk::InteractionEvent::AltKey;
   }
   if (me->modifiers() & Qt::CTRL)
   {
     modifiers = modifiers | mitk::InteractionEvent::ControlKey;
   }
   if (me->modifiers() & Qt::SHIFT)
   {
     modifiers = modifiers | mitk::InteractionEvent::ShiftKey;
   }
   return modifiers;
 }
 
 mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QWheelEvent *we) const
 {
   mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
 
   if (we->buttons() & Qt::LeftButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
   }
   if (we->buttons() & Qt::RightButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
   }
   if (we->buttons() & Qt::MidButton)
   {
     buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
   }
   return buttonState;
 }
 
 std::string QmitkRenderWindow::GetKeyLetter(QKeyEvent *ke) const
 {
   // Converting Qt Key Event to string element.
   std::string key = "";
   int tkey = ke->key();
   if (tkey < 128)
   { // standard ascii letter
     key = (char)toupper(tkey);
   }
   else
   { // special keys
     switch (tkey)
     {
       case Qt::Key_Return:
         key = mitk::InteractionEvent::KeyReturn;
         break;
       case Qt::Key_Enter:
         key = mitk::InteractionEvent::KeyEnter;
         break;
       case Qt::Key_Escape:
         key = mitk::InteractionEvent::KeyEsc;
         break;
       case Qt::Key_Delete:
         key = mitk::InteractionEvent::KeyDelete;
         break;
       case Qt::Key_Up:
         key = mitk::InteractionEvent::KeyArrowUp;
         break;
       case Qt::Key_Down:
         key = mitk::InteractionEvent::KeyArrowDown;
         break;
       case Qt::Key_Left:
         key = mitk::InteractionEvent::KeyArrowLeft;
         break;
       case Qt::Key_Right:
         key = mitk::InteractionEvent::KeyArrowRight;
         break;
 
       case Qt::Key_F1:
         key = mitk::InteractionEvent::KeyF1;
         break;
       case Qt::Key_F2:
         key = mitk::InteractionEvent::KeyF2;
         break;
       case Qt::Key_F3:
         key = mitk::InteractionEvent::KeyF3;
         break;
       case Qt::Key_F4:
         key = mitk::InteractionEvent::KeyF4;
         break;
       case Qt::Key_F5:
         key = mitk::InteractionEvent::KeyF5;
         break;
       case Qt::Key_F6:
         key = mitk::InteractionEvent::KeyF6;
         break;
       case Qt::Key_F7:
         key = mitk::InteractionEvent::KeyF7;
         break;
       case Qt::Key_F8:
         key = mitk::InteractionEvent::KeyF8;
         break;
       case Qt::Key_F9:
         key = mitk::InteractionEvent::KeyF9;
         break;
       case Qt::Key_F10:
         key = mitk::InteractionEvent::KeyF10;
         break;
       case Qt::Key_F11:
         key = mitk::InteractionEvent::KeyF11;
         break;
       case Qt::Key_F12:
         key = mitk::InteractionEvent::KeyF12;
         break;
 
       case Qt::Key_End:
         key = mitk::InteractionEvent::KeyEnd;
         break;
       case Qt::Key_Home:
         key = mitk::InteractionEvent::KeyPos1;
         break;
       case Qt::Key_Insert:
         key = mitk::InteractionEvent::KeyInsert;
         break;
       case Qt::Key_PageDown:
         key = mitk::InteractionEvent::KeyPageDown;
         break;
       case Qt::Key_PageUp:
         key = mitk::InteractionEvent::KeyPageUp;
         break;
       case Qt::Key_Space:
         key = mitk::InteractionEvent::KeySpace;
         break;
     }
   }
   return key;
 }
 
 int QmitkRenderWindow::GetDelta(QWheelEvent *we) const
 {
   return we->delta();
 }
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.cpp b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.cpp
index fe288fbf78..2425ce73bd 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.cpp
@@ -1,271 +1,267 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include <ui_QmitkStdMultiWidgetEditorPreferencePage.h>
 #include "QmitkStdMultiWidgetEditorPreferencePage.h"
 #include <QmitkStdMultiWidgetEditor.h>
 
 #include <berryIPreferencesService.h>
 #include <berryPlatform.h>
 
 #include <QColorDialog>
 
 QmitkStdMultiWidgetEditorPreferencePage::QmitkStdMultiWidgetEditorPreferencePage()
   : m_Preferences(nullptr),
     m_Ui(new Ui::QmitkStdMultiWidgetEditorPreferencePage),
     m_Control(nullptr)
 {
 }
 
 QmitkStdMultiWidgetEditorPreferencePage::~QmitkStdMultiWidgetEditorPreferencePage()
 {
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::CreateQtControl(QWidget* parent)
 {
   m_Control = new QWidget(parent);
 
   m_Ui->setupUi(m_Control);
 
   berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
   Q_ASSERT(prefService);
 
   m_Preferences = prefService->GetSystemPreferences()->Node(QmitkStdMultiWidgetEditor::EDITOR_ID);
 
   QObject::connect( m_Ui->m_ColorButton1, SIGNAL( clicked() )
                     , this, SLOT( ColorChooserButtonClicked() ) );
 
   QObject::connect( m_Ui->m_ColorButton2, SIGNAL( clicked() )
                     , this, SLOT( ColorChooserButtonClicked() ) );
 
   QObject::connect( m_Ui->m_ResetButton, SIGNAL( clicked() )
                     , this, SLOT( ResetPreferencesAndGUI() ) );
 
   QObject::connect( m_Ui->m_RenderingMode, SIGNAL(activated(int) )
                     , this, SLOT( ChangeRenderingMode(int) ) );
 
   QObject::connect( m_Ui->m_RenderWindowDecorationColor, SIGNAL( clicked() )
                     , this, SLOT( ColorChooserButtonClicked() ) );
 
   QObject::connect( m_Ui->m_RenderWindowChooser, SIGNAL(activated(int) )
                     , this, SLOT( OnWidgetComboBoxChanged(int) ) );
   QObject::connect( m_Ui->m_RenderWindowDecorationText, SIGNAL(textChanged(QString) )
                     , this, SLOT( AnnotationTextChanged(QString) ) );
 
   this->Update();
 }
 
 QWidget* QmitkStdMultiWidgetEditorPreferencePage::GetQtControl() const
 {
   return m_Control;
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::Init(berry::IWorkbench::Pointer)
 {
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::PerformCancel()
 {
 }
 
 bool QmitkStdMultiWidgetEditorPreferencePage::PerformOk()
 {
   m_Preferences->Put("widget1 corner annotation", m_WidgetAnnotation[0]);
   m_Preferences->Put("widget2 corner annotation", m_WidgetAnnotation[1]);
   m_Preferences->Put("widget3 corner annotation", m_WidgetAnnotation[2]);
   m_Preferences->Put("widget4 corner annotation", m_WidgetAnnotation[3]);
 
   m_Preferences->Put("widget1 decoration color", m_WidgetDecorationColor[0]);
   m_Preferences->Put("widget2 decoration color", m_WidgetDecorationColor[1]);
   m_Preferences->Put("widget3 decoration color", m_WidgetDecorationColor[2]);
   m_Preferences->Put("widget4 decoration color", m_WidgetDecorationColor[3]);
 
   m_Preferences->Put("widget1 first background color", m_WidgetBackgroundColor1[0]);
   m_Preferences->Put("widget2 first background color", m_WidgetBackgroundColor1[1]);
   m_Preferences->Put("widget3 first background color", m_WidgetBackgroundColor1[2]);
   m_Preferences->Put("widget4 first background color", m_WidgetBackgroundColor1[3]);
   m_Preferences->Put("widget1 second background color", m_WidgetBackgroundColor2[0]);
   m_Preferences->Put("widget2 second background color", m_WidgetBackgroundColor2[1]);
   m_Preferences->Put("widget3 second background color", m_WidgetBackgroundColor2[2]);
   m_Preferences->Put("widget4 second background color", m_WidgetBackgroundColor2[3]);
   m_Preferences->PutInt("crosshair gap size", m_Ui->m_CrosshairGapSize->value());
 
   m_Preferences->PutBool("Use constrained zooming and panning"
                          , m_Ui->m_EnableFlexibleZooming->isChecked());
   m_Preferences->PutBool("Show level/window widget", m_Ui->m_ShowLevelWindowWidget->isChecked());
   m_Preferences->PutBool("PACS like mouse interaction", m_Ui->m_PACSLikeMouseMode->isChecked());
   m_Preferences->PutInt("Rendering Mode", m_Ui->m_RenderingMode->currentIndex());
 
   return true;
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::Update()
 {
   //Note: there should be default preferences already defined in the
   //QmitkStdMultiWidgetEditor::InitializePreferences(). Therefore,
   //all default values here are not relevant.
   //gradient background colors
   m_WidgetBackgroundColor1[0] = m_Preferences->Get("widget1 first background color", "#1d1d1c");
   m_WidgetBackgroundColor2[0] = m_Preferences->Get("widget1 second background color", "#1d1d1c");
   m_WidgetBackgroundColor1[1] = m_Preferences->Get("widget2 first background color", "#1d1d1c");
   m_WidgetBackgroundColor2[1] = m_Preferences->Get("widget2 second background color", "#1d1d1c");
   m_WidgetBackgroundColor1[2] = m_Preferences->Get("widget3 first background color", "#1d1d1c");
   m_WidgetBackgroundColor2[2] = m_Preferences->Get("widget3 second background color", "#1d1d1c");
   m_WidgetBackgroundColor1[3] = m_Preferences->Get("widget4 first background color", "#1d1d1c");
   m_WidgetBackgroundColor2[3] = m_Preferences->Get("widget4 second background color", "#adb1b6");
 
   //decoration colors
   m_WidgetDecorationColor[0] = m_Preferences->Get("widget1 decoration color", "#c00000");
   m_WidgetDecorationColor[1] = m_Preferences->Get("widget2 decoration color", "#0fad00");
   m_WidgetDecorationColor[2] = m_Preferences->Get("widget3 decoration color", "#0080ff");
   m_WidgetDecorationColor[3] = m_Preferences->Get("widget4 decoration color", "#fec500");
 
   //annotation text
   m_WidgetAnnotation[0] = m_Preferences->Get("widget1 corner annotation", "Axial");
   m_WidgetAnnotation[1] = m_Preferences->Get("widget2 corner annotation", "Sagittal");
   m_WidgetAnnotation[2] = m_Preferences->Get("widget3 corner annotation", "Coronal");
   m_WidgetAnnotation[3] = m_Preferences->Get("widget4 corner annotation", "3D");
 
 
   //Ui stuff
   int index = m_Ui->m_RenderWindowChooser->currentIndex();
   QColor firstBackgroundColor(m_WidgetBackgroundColor1[index]);
   QColor secondBackgroundColor(m_WidgetBackgroundColor2[index]);
   QColor widgetColor(m_WidgetDecorationColor[index]);
 
   this->SetStyleSheetToColorChooserButton(firstBackgroundColor, m_Ui->m_ColorButton1);
   this->SetStyleSheetToColorChooserButton(secondBackgroundColor, m_Ui->m_ColorButton2);
   this->SetStyleSheetToColorChooserButton(widgetColor, m_Ui->m_RenderWindowDecorationColor);
 
   m_Ui->m_RenderWindowDecorationText->setText(m_WidgetAnnotation[index]);
 
   m_Ui->m_EnableFlexibleZooming->setChecked(m_Preferences->GetBool("Use constrained zooming and panning", true));
   m_Ui->m_ShowLevelWindowWidget->setChecked(m_Preferences->GetBool("Show level/window widget", true));
   m_Ui->m_PACSLikeMouseMode->setChecked(m_Preferences->GetBool("PACS like mouse interaction", false));
   int mode= m_Preferences->GetInt("Rendering Mode",0);
   m_Ui->m_RenderingMode->setCurrentIndex(mode);
   m_Ui->m_CrosshairGapSize->setValue(m_Preferences->GetInt("crosshair gap size", 32));
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::ColorChooserButtonClicked()
 {
   unsigned int widgetIndex = m_Ui->m_RenderWindowChooser->currentIndex();
   if(widgetIndex > 3)
   {
     MITK_ERROR << "Selected index for unknown.";
     return;
   }
   QObject *senderObj = sender(); // This will give Sender button
   //find out last used color and set it
   QColor initialColor;
   if( senderObj->objectName() == m_Ui->m_ColorButton1->objectName())
   {
     initialColor = QColor(m_WidgetBackgroundColor1[widgetIndex]);
   }else if( senderObj->objectName() == m_Ui->m_ColorButton2->objectName())
   {
     initialColor = QColor(m_WidgetBackgroundColor2[widgetIndex]);
   }else if( senderObj->objectName() == m_Ui->m_RenderWindowDecorationColor->objectName())
   {
     initialColor = QColor(m_WidgetDecorationColor[widgetIndex]);
   }
 
   //get the new color
   QColor newcolor = QColorDialog::getColor(initialColor);
   if(!newcolor.isValid())
   {
     newcolor = initialColor;
   }
   this->SetStyleSheetToColorChooserButton(newcolor, static_cast<QPushButton*>(senderObj));
 
   //convert it to std string and apply it
   if( senderObj->objectName() == m_Ui->m_ColorButton1->objectName())
   {
     m_WidgetBackgroundColor1[widgetIndex] = newcolor.name();
   }
   else if( senderObj->objectName() == m_Ui->m_ColorButton2->objectName())
   {
     m_WidgetBackgroundColor2[widgetIndex] = newcolor.name();
   }
   else if( senderObj->objectName() == m_Ui->m_RenderWindowDecorationColor->objectName())
   {
     m_WidgetDecorationColor[widgetIndex] = newcolor.name();
   }
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::SetStyleSheetToColorChooserButton(QColor backgroundcolor,
                                                                                 QPushButton* button)
 {
   button->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
 
   styleSheet.append(QString::number(backgroundcolor.red()));
   styleSheet.append(",");
   styleSheet.append(QString::number(backgroundcolor.green()));
   styleSheet.append(",");
   styleSheet.append(QString::number(backgroundcolor.blue()));
   styleSheet.append(")");
   button->setStyleSheet(styleSheet);
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::AnnotationTextChanged(QString text)
 {
   unsigned int widgetIndex = m_Ui->m_RenderWindowChooser->currentIndex();
   if( widgetIndex > 3)
   {
     MITK_INFO << "Selected index for unknown widget.";
     return;
   }
   m_WidgetAnnotation[widgetIndex] = text;
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::ResetPreferencesAndGUI()
 {
   m_Preferences->Clear();
   this->Update();
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::OnWidgetComboBoxChanged(int i)
 {
   if( i > 3)
   {
     MITK_ERROR << "Selected unknown widget.";
     return;
   }
   QColor widgetColor(m_WidgetDecorationColor[i]);
   QColor gradientBackground1(m_WidgetBackgroundColor1[i]);
   QColor gradientBackground2(m_WidgetBackgroundColor2[i]);
   this->SetStyleSheetToColorChooserButton(widgetColor, m_Ui->m_RenderWindowDecorationColor);
   this->SetStyleSheetToColorChooserButton(gradientBackground1, m_Ui->m_ColorButton1);
   this->SetStyleSheetToColorChooserButton(gradientBackground2, m_Ui->m_ColorButton2);
   m_Ui->m_RenderWindowDecorationText->setText(m_WidgetAnnotation[i]);
 }
 
 void QmitkStdMultiWidgetEditorPreferencePage::ChangeRenderingMode(int i)
 {
   if( i == 0 )
   {
     m_CurrentRenderingMode = "Standard";
   }
   else if( i == 1 )
-  {
-    m_CurrentRenderingMode = "Multisampling";
-  }
-  else if( i == 2 )
   {
     m_CurrentRenderingMode = "DepthPeeling";
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.ui b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.ui
index ba9242e500..437b580c38 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.ui
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.ui
@@ -1,225 +1,220 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkStdMultiWidgetEditorPreferencePage</class>
  <widget class="QWidget" name="QmitkStdMultiWidgetEditorPreferencePage">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>518</width>
     <height>431</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>External Programs</string>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="10" column="1">
     <widget class="QComboBox" name="m_RenderWindowChooser">
      <item>
       <property name="text">
        <string>stdmulti.widget1</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>stdmulti.widget2</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>stdmulti.widget3</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>stdmulti.widget4</string>
       </property>
      </item>
     </widget>
    </item>
    <item row="11" column="0">
     <widget class="QLabel" name="label_2">
      <property name="toolTip">
       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;If two colors are set, a gradient background is generated.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="text">
       <string>Background color</string>
      </property>
     </widget>
    </item>
    <item row="15" column="0">
     <widget class="QPushButton" name="m_ResetButton">
      <property name="text">
       <string>Reset preferences</string>
      </property>
     </widget>
    </item>
    <item row="6" column="1" colspan="2">
     <widget class="QComboBox" name="m_RenderingMode">
      <item>
       <property name="text">
        <string>Standard Rendering</string>
       </property>
      </item>
      <item>
       <property name="text">
-       <string>Enable Multisampling (Antialiasing)</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>Enable Depth Peeling</string>
+       <string>Depth Peeling</string>
       </property>
      </item>
     </widget>
    </item>
    <item row="7" column="0" colspan="3">
     <widget class="QLabel" name="label">
      <property name="text">
       <string>* Changes require restart of MITK.
  Depth Peeling is only supported by Windows.
- For other OS, use Standard Rendering and enable
- the property 'Depth Sorting' in the property list of the surface data node.</string>
+ For other operating systems, use Standard Rendering and enable
+ the property 'Depth Sorting' in the property list of a surface data node.</string>
      </property>
     </widget>
    </item>
    <item row="9" column="1">
     <widget class="QSpinBox" name="m_CrosshairGapSize">
      <property name="value">
       <number>32</number>
      </property>
     </widget>
    </item>
    <item row="8" column="0" colspan="3">
     <widget class="Line" name="line_3">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
     </widget>
    </item>
    <item row="14" column="0">
     <widget class="QLabel" name="label_8">
      <property name="toolTip">
       <string>The small text on the button left of each renderwindow.</string>
      </property>
      <property name="text">
       <string>Corner annotation</string>
      </property>
     </widget>
    </item>
    <item row="9" column="0">
     <widget class="QLabel" name="label_9">
      <property name="toolTip">
       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;The gap in the middle of the crosshair in pixels.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="text">
       <string>Crosshair gap size</string>
      </property>
     </widget>
    </item>
    <item row="13" column="0">
     <widget class="QLabel" name="label_7">
      <property name="toolTip">
       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;The color is used for the following decorations (of each renderwindow):&lt;/p&gt;&lt;p&gt;Rectangle border&lt;/p&gt;&lt;p&gt;Corner annotation&lt;/p&gt;&lt;p&gt;Crosshair&lt;/p&gt;&lt;p&gt;Plane geometry helper objects (3D Planes)&lt;/p&gt;&lt;p&gt;Image navigator borders&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="text">
       <string>Decoration color</string>
      </property>
     </widget>
    </item>
    <item row="13" column="1">
     <widget class="QPushButton" name="m_RenderWindowDecorationColor">
      <property name="text">
       <string/>
      </property>
     </widget>
    </item>
    <item row="10" column="0">
     <widget class="QLabel" name="label_6">
      <property name="toolTip">
       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Choose the renderwindow from the multi widget.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="text">
       <string>Render windows</string>
      </property>
     </widget>
    </item>
    <item row="1" column="0" colspan="3">
     <widget class="QCheckBox" name="m_ShowLevelWindowWidget">
      <property name="layoutDirection">
       <enum>Qt::LeftToRight</enum>
      </property>
      <property name="text">
       <string>Show level/window widget</string>
      </property>
      <property name="checked">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item row="2" column="0" colspan="3">
     <widget class="QCheckBox" name="m_PACSLikeMouseMode">
      <property name="layoutDirection">
       <enum>Qt::LeftToRight</enum>
      </property>
      <property name="text">
       <string>Use PACS like mouse interaction (select left mouse button action)</string>
      </property>
      <property name="tristate">
       <bool>false</bool>
      </property>
     </widget>
    </item>
    <item row="11" column="2">
     <widget class="QPushButton" name="m_ColorButton2">
      <property name="text">
       <string/>
      </property>
     </widget>
    </item>
    <item row="3" column="0" colspan="3">
     <widget class="Line" name="line">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
     </widget>
    </item>
    <item row="6" column="0">
     <widget class="QLabel" name="label_5">
      <property name="text">
       <string>Rendering Mode*</string>
      </property>
     </widget>
    </item>
    <item row="14" column="1" colspan="2">
     <widget class="QLineEdit" name="m_RenderWindowDecorationText"/>
    </item>
    <item row="11" column="1">
     <widget class="QPushButton" name="m_ColorButton1">
      <property name="text">
       <string/>
      </property>
     </widget>
    </item>
    <item row="0" column="0" colspan="3">
     <widget class="QCheckBox" name="m_EnableFlexibleZooming">
      <property name="toolTip">
       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;If activated, zooming and panning is limited to a certain space arround each image.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="layoutDirection">
       <enum>Qt::LeftToRight</enum>
      </property>
      <property name="text">
       <string>Use constraint zooming and panning</string>
      </property>
      <property name="checked">
       <bool>true</bool>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>