diff --git a/Applications/mitkWorkbench/CPackOptions.cmake b/Applications/mitkWorkbench/CPackOptions.cmake
new file mode 100644
index 0000000000..06935ce197
--- /dev/null
+++ b/Applications/mitkWorkbench/CPackOptions.cmake
@@ -0,0 +1,38 @@
+# Set MITK Workbench specific CPack options
+
+# set version
+set(CPACK_PACKAGE_VERSION
+  "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}")
+
+# determine possible system specific extension
+set(extension "unkown-architecture")
+
+if(${CMAKE_SYSTEM_NAME} MATCHES Windows)
+  if(CMAKE_CL_64)
+    set(extension "win64")
+  elseif(MINGW)
+    set(extension "mingw32")
+  elseif(WIN32)
+    set(extension "win32")
+  endif()
+endif(${CMAKE_SYSTEM_NAME} MATCHES Windows)
+
+if(${CMAKE_SYSTEM_NAME} MATCHES Linux)
+  if(${CMAKE_SYSTEM_PROCESSOR} MATCHES i686)
+    set(extension "linux32")
+  elseif(${CMAKE_SYSTEM_PROCESSOR} MATCHES x86_64)
+    if(${CMAKE_CXX_FLAGS} MATCHES " -m32 ")
+      set(extension "linux32")
+    else()
+      set(extension "linux64")
+    endif(${CMAKE_CXX_FLAGS} MATCHES " -m32 ")
+  else()
+    set(extension "linux")
+  endif()
+endif(${CMAKE_SYSTEM_NAME} MATCHES Linux)
+
+if(${CMAKE_SYSTEM_NAME} MATCHES Darwin)
+  set(extension "mac64")
+endif(${CMAKE_SYSTEM_NAME} MATCHES Darwin)
+
+set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${extension}")
diff --git a/Applications/mitkWorkbench/mitkWorkbench.cpp b/Applications/mitkWorkbench/mitkWorkbench.cpp
index 23339c2e05..dc672d38e8 100644
--- a/Applications/mitkWorkbench/mitkWorkbench.cpp
+++ b/Applications/mitkWorkbench/mitkWorkbench.cpp
@@ -1,143 +1,143 @@
 /*===================================================================
 
 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 <application/berryStarter.h>
 #include <Poco/Util/MapConfiguration.h>
 
 #include <QApplication>
 #include <QMessageBox>
 #include <QtSingleApplication>
 
 #include <mitkCommon.h>
 #include <mitkException.h>
 
 class QtSafeApplication : public QtSingleApplication
 {
 
 public:
 
   QtSafeApplication(int& argc, char** argv) : QtSingleApplication(argc, argv)
   {}
 
   /**
    * Reimplement notify to catch unhandled exceptions and open an error message.
    *
    * @param receiver
    * @param event
    * @return
    */
   bool notify(QObject* receiver, QEvent* event)
   {
     QString msg;
     try
     {
       return QApplication::notify(receiver, event);
     }
     catch (mitk::Exception& e)
     {
       msg = QString("MITK Exception:\n\n") 
             + QString("Desciption: ") 
             + QString(e.GetDescription()) + QString("\n\n")
             + QString("Filename: ") + QString(e.GetFile()) + QString("\n\n")
             + QString("Line: ") + QString::number(e.GetLine());
     }
     catch (Poco::Exception& e)
     {
       msg = QString::fromStdString(e.displayText());
     }
     catch (std::exception& e)
     {
       msg = e.what();
     }
     catch (...)
     {
       msg = "Unknown exception";
     }
     MITK_ERROR << "An error occurred: " << msg.toStdString();
 
     QMessageBox msgBox;
     msgBox.setText("An error occurred. You should save all data and quit the program to prevent possible data loss.");
     msgBox.setDetailedText(msg);
     msgBox.setIcon(QMessageBox::Critical);
     msgBox.addButton(trUtf8("Exit immediately"), QMessageBox::YesRole);
     msgBox.addButton(trUtf8("Ignore"), QMessageBox::NoRole);
 
     int ret = msgBox.exec();
     
     switch(ret)
       {
       case 0:
         MITK_ERROR << "The program was closed.";
         this->closeAllWindows();
         break;
       case 1:
         MITK_ERROR << "The error was ignored by the user. The program may be in a corrupt state and don't behave like expected!";
         break;
       }
 
     return false;
   }
 
 };
 
 
 int main(int argc, char** argv)
 {
   // Create a QApplication instance first
   QtSafeApplication qSafeApp(argc, argv);
-  qSafeApp.setApplicationName("mitkWorkbench");
+  qSafeApp.setApplicationName("MITK Workbench");
   qSafeApp.setOrganizationName("DKFZ");
 
   // 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.
   QString storageDir = handleNewAppInstance(&qSafeApp, argc, argv, "BlueBerry.newInstance");
 
   // These paths replace the .ini file and are tailored for installation
   // packages created with CPack. If a .ini file is presented, it will
   // overwrite the settings in MapConfiguration
   Poco::Path basePath(argv[0]);
   basePath.setFileName("");
   
   Poco::Path provFile(basePath);
   provFile.setFileName("mitkWorkbench.provisioning");
 
   Poco::Path extPath(basePath);
   extPath.pushDirectory("ExtBundles");
 
   std::string pluginDirs = extPath.toString();
 
   Poco::Util::MapConfiguration* extConfig(new Poco::Util::MapConfiguration());
   if (!storageDir.isEmpty())
   {
     extConfig->setString(berry::Platform::ARG_STORAGE_DIR, storageDir.toStdString());
   }
   extConfig->setString(berry::Platform::ARG_PLUGIN_DIRS, pluginDirs);
   extConfig->setString(berry::Platform::ARG_PROVISIONING, provFile.toString());
   extConfig->setString(berry::Platform::ARG_APPLICATION, "org.mitk.qt.extapplication");
 
   // Preload the org.mitk.gui.qt.ext plug-in (and hence also QmitkExt) to speed
   // up a clean-cache start. This also works around bugs in older gcc and glibc implementations,
   // which have difficulties with multiple dynamic opening and closing of shared libraries with
   // many global static initializers. It also helps if dependent libraries have weird static
   // initialization methods and/or missing de-initialization code.
-  extConfig->setString(berry::Platform::ARG_PRELOAD_LIBRARY, "liborg_mitk_gui_qt_ext,libCTKDICOMCore");
+  extConfig->setString(berry::Platform::ARG_PRELOAD_LIBRARY, "liborg_mitk_gui_qt_ext,libCTKDICOMCore:0.1");
 
   return berry::Starter::Run(argc, argv, extConfig);
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt.help/src/internal/berryHelpEditor.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt.help/src/internal/berryHelpEditor.cpp
index 0ba5a18a4d..60baf7429e 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt.help/src/internal/berryHelpEditor.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt.help/src/internal/berryHelpEditor.cpp
@@ -1,328 +1,340 @@
 /*===================================================================
 
 BlueBerry Platform
 
 Copyright (c) German Cancer Research Center, 
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without 
 even the implied warranty of MERCHANTABILITY or FITNESS FOR 
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "berryHelpEditor.h"
 
 #include "berryHelpEditorInput.h"
 #include "berryHelpPluginActivator.h"
 #include "berryHelpPerspective.h"
 #include "berryHelpWebView.h"
 #include "berryQHelpEngineWrapper.h"
 #include "berryHelpEditorFindWidget.h"
 #include "berryHelpPluginActivator.h"
 #include "berryQHelpEngineWrapper.h"
 
 #include <berryUIException.h>
 #include <berryPlatformUI.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIWorkbenchPartConstants.h>
 
 #include <QToolBar>
 #include <QHelpEngine>
 #include <QVBoxLayout>
 
 namespace berry {
 
 const std::string HelpEditor::EDITOR_ID = "org.blueberry.editors.help";
 
 HelpEditor::HelpEditor()
   : m_ToolBar(0)
   , m_WebView(0)
 {
 
 }
 
 HelpEditor::~HelpEditor()
 {
   // we need to wrap the RemovePartListener call inside a
   // register/unregister block to prevent infinite recursion
   // due to the destruction of temporary smartpointer to this
   this->Register();
   this->GetSite()->GetPage()->RemovePartListener(IPartListener::Pointer(this));
   this->GetSite()->GetPage()->GetWorkbenchWindow()->RemovePerspectiveListener(IPerspectiveListener::Pointer(this));
   this->UnRegister(false);
 }
 
 void HelpEditor::Init(berry::IEditorSite::Pointer site, berry::IEditorInput::Pointer input)
 {
   if (input.Cast<HelpEditorInput>().IsNull())
      throw PartInitException("Invalid Input: Must be berry::HelpEditorInput");
 
   this->SetSite(site);
   site->GetPage()->AddPartListener(IPartListener::Pointer(this));
   site->GetPage()->GetWorkbenchWindow()->AddPerspectiveListener(IPerspectiveListener::Pointer(this));
 
   m_WebView = new HelpWebView(site, 0);
 
   connect(m_WebView, SIGNAL(loadFinished(bool)), this, SLOT(InitializeTitle()));
 
   this->DoSetInput(input);
 }
 
 void HelpEditor::CreateQtPartControl(QWidget* parent)
 {
   QVBoxLayout* verticalLayout = new QVBoxLayout(parent);
   verticalLayout->setSpacing(0);
   verticalLayout->setContentsMargins(0, 0, 0, 0);
 
   m_ToolBar = new QToolBar(parent);
   m_ToolBar->setMaximumHeight(32);
   verticalLayout->addWidget(m_ToolBar);
 
   m_WebView->setParent(parent);
   m_WebView->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   verticalLayout->addWidget(m_WebView);
 
   m_FindWidget = new HelpEditorFindWidget(parent);
   m_FindWidget->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Maximum);
   verticalLayout->addWidget(m_FindWidget);
   m_FindWidget->hide();
 
   connect(m_FindWidget, SIGNAL(findNext()), this, SLOT(findNext()));
   connect(m_FindWidget, SIGNAL(findPrevious()), this, SLOT(findPrevious()));
   connect(m_FindWidget, SIGNAL(find(QString, bool)), this,
           SLOT(find(QString, bool)));
   connect(m_FindWidget, SIGNAL(escapePressed()), m_WebView, SLOT(setFocus()));
 
   // Fill the editor toolbar
   m_BackAction = m_ToolBar->addAction(QIcon(":/org.blueberry.ui.qt.help/go-previous.png"), "Go back",
                                              m_WebView, SLOT(backward()));
   m_ForwardAction = m_ToolBar->addAction(QIcon(":/org.blueberry.ui.qt.help/go-next.png"), "Go forward",
                                                 m_WebView, SLOT(forward()));
   m_HomeAction = m_ToolBar->addAction(QIcon(":/org.blueberry.ui.qt.help/go-home.png"), "Go home",
                                       m_WebView, SLOT(home()));
 
   m_ToolBar->addSeparator();
 
   m_FindAction = m_ToolBar->addAction(QIcon(":/org.blueberry.ui.qt.help/find.png"), "Find in text",
                                              this, SLOT(ShowTextSearch()));
 
   m_ToolBar->addSeparator();
 
   m_ZoomIn = m_ToolBar->addAction(QIcon(":/org.blueberry.ui.qt.help/zoom-in.png"), "Zoom in", m_WebView, SLOT(scaleUp()));
   m_ZoomOut = m_ToolBar->addAction(QIcon(":/org.blueberry.ui.qt.help/zoom-out.png"), "Zoom out", m_WebView, SLOT(scaleDown()));
 
   m_ToolBar->addSeparator();
 
-  m_OpenHelpMode = m_ToolBar->addAction("Switch to Help mode", this, SLOT(OpenHelpPerspective()));
+  m_OpenHelpMode = m_ToolBar->addAction("Open Help Perspective", this, SLOT(OpenHelpPerspective()));
+  m_CloseHelpMode = m_ToolBar->addAction("Close Help Perspective", this, SLOT(CloseHelpPerspective()));
   IPerspectiveDescriptor::Pointer currPersp = this->GetSite()->GetPage()->GetPerspective();
-  m_OpenHelpMode->setEnabled(!(currPersp.IsNotNull() && currPersp->GetId() == HelpPerspective::ID));
+  m_OpenHelpMode->setVisible(!(currPersp.IsNotNull() && currPersp->GetId() == HelpPerspective::ID));
+  m_CloseHelpMode->setVisible((currPersp.IsNotNull() && currPersp->GetId() == HelpPerspective::ID));
 
   connect(m_WebView, SIGNAL(backwardAvailable(bool)), m_BackAction, SLOT(setEnabled(bool)));
   connect(m_WebView, SIGNAL(forwardAvailable(bool)), m_ForwardAction, SLOT(setEnabled(bool)));
 
   m_BackAction->setEnabled(false);
   m_ForwardAction->setEnabled(false);
   m_HomeAction->setEnabled(!HelpPluginActivator::getInstance()->getQHelpEngine().homePage().isEmpty());
 
   connect(&HelpPluginActivator::getInstance()->getQHelpEngine(), SIGNAL(homePageChanged(QString)),
           this, SLOT(HomePageChanged(QString)));
 }
 
 void HelpEditor::DoSetInput(IEditorInput::Pointer input)
 {
   if (input.IsNull())
   {
     // close editor
     class CloseEditorRunnable : public Poco::Runnable
     {
     private:
       IEditorPart::Pointer editor;
 
     public:
       CloseEditorRunnable(IEditorPart::Pointer editor)
         : editor(editor)
       {}
 
       void run()
       {
         editor->GetSite()->GetPage()->CloseEditor(editor, false);
         delete this;
       }
     };
 
     Display::GetDefault()->AsyncExec(new CloseEditorRunnable(IEditorPart::Pointer(this)));
   }
   else
   {
     // an empty url represents the home page
     HelpEditorInput::Pointer helpInput = input.Cast<HelpEditorInput>();
     QString currHomePage = HelpPluginActivator::getInstance()->getQHelpEngine().homePage();
     if (helpInput->GetUrl().isEmpty() && !currHomePage.isEmpty())
     {
       helpInput = HelpEditorInput::Pointer(new HelpEditorInput(currHomePage));
     }
     QtEditorPart::SetInput(helpInput);
     m_WebView->setSource(helpInput->GetUrl());
   }
 }
 
 void HelpEditor::SetInputWithNotify(IEditorInput::Pointer input)
 {
   DoSetInput(input);
   FirePropertyChange(IWorkbenchPartConstants::PROP_INPUT);
 }
 
 void HelpEditor::SetInput(IEditorInput::Pointer input)
 {
   SetInputWithNotify(input);
 }
 
 void HelpEditor::HomePageChanged(const QString &page)
 {
   if (page.isEmpty())
   {
     m_HomeAction->setEnabled(false);
   }
 
   m_HomeAction->setEnabled(true);
   if (this->GetEditorInput().Cast<HelpEditorInput>()->GetUrl().isEmpty())
   {
     IEditorInput::Pointer newInput(new HelpEditorInput(page));
     DoSetInput(newInput);
   }
 }
 
 void HelpEditor::OpenHelpPerspective()
 {
   PlatformUI::GetWorkbench()->ShowPerspective(HelpPerspective::ID, this->GetSite()->GetPage()->GetWorkbenchWindow());
 }
 
+void HelpEditor::CloseHelpPerspective()
+{
+  berry::IWorkbenchPage::Pointer
+    page =
+    berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
+  page->ClosePerspective(page->GetPerspective(), true, true);
+}
+
 void HelpEditor::InitializeTitle()
 {
   std::string title = m_WebView->title().toStdString();
   this->SetPartName(title);
 }
 
 void HelpEditor::ShowTextSearch()
 {
   m_FindWidget->show();
 }
 
 void HelpEditor::SetFocus()
 {
   m_WebView->setFocus();
 
   enableShortcuts();
 }
 
 QWebPage *HelpEditor::GetQWebPage() const
 {
   return m_WebView->page();
 }
 
 IPartListener::Events::Types HelpEditor::GetPartEventTypes() const
 {
   return IPartListener::Events::DEACTIVATED;
 }
 
 void HelpEditor::PartDeactivated(IWorkbenchPartReference::Pointer partRef)
 {
   if (partRef == GetSite()->GetPage()->GetReference(IWorkbenchPart::Pointer(this)))
     disableShortcuts();
 }
 
 IPerspectiveListener::Events::Types HelpEditor::GetPerspectiveEventTypes() const
 {
   return IPerspectiveListener::Events::ACTIVATED | IPerspectiveListener::Events::DEACTIVATED;
 }
 
 void HelpEditor::PerspectiveActivated(SmartPointer<IWorkbenchPage> page, IPerspectiveDescriptor::Pointer perspective)
 {
   if (perspective->GetId() == HelpPerspective::ID)
   {
-    m_OpenHelpMode->setEnabled(false);
+    m_OpenHelpMode->setVisible(false);
+    m_CloseHelpMode->setVisible(true);
   }
 }
 
 void HelpEditor::PerspectiveDeactivated(SmartPointer<IWorkbenchPage> page, IPerspectiveDescriptor::Pointer perspective)
 {
   if (perspective->GetId() == HelpPerspective::ID)
   {
-    m_OpenHelpMode->setEnabled(true);
+    m_OpenHelpMode->setVisible(true);
+    m_CloseHelpMode->setVisible(false);
   }
 }
 
 void HelpEditor::findNext()
 {
   find(m_FindWidget->text(), true);
 }
 
 void HelpEditor::findPrevious()
 {
   find(m_FindWidget->text(), false);
 }
 
 void HelpEditor::find(const QString &ttf, bool forward)
 {
   bool found = findInWebPage(ttf, forward);
 
   if (!found && ttf.isEmpty())
     found = true;   // the line edit is empty, no need to mark it red...
 
   if (!m_FindWidget->isVisible())
     m_FindWidget->show();
   m_FindWidget->setPalette(found);
 }
 
 bool HelpEditor::findInWebPage(const QString &ttf, bool forward)
 {
   bool found = false;
   QWebPage::FindFlags options;
   if (!ttf.isEmpty())
   {
     if (!forward)
       options |= QWebPage::FindBackward;
 
     if (m_FindWidget->caseSensitive())
       options |= QWebPage::FindCaseSensitively;
 
     found = m_WebView->findText(ttf, options);
 
     if (!found)
     {
       options |= QWebPage::FindWrapsAroundDocument;
       found = m_WebView->findText(ttf, options);
     }
   }
   // force highlighting of all other matches, also when empty (clear)
   options = QWebPage::HighlightAllOccurrences;
   if (m_FindWidget->caseSensitive())
     options |= QWebPage::FindCaseSensitively;
   m_WebView->findText(QLatin1String(""), options);
   m_WebView->findText(ttf, options);
   return found;
 }
 
 void HelpEditor::enableShortcuts()
 {
   m_BackAction->setShortcut(QKeySequence::Back);
   m_ForwardAction->setShortcut(QKeySequence::Forward);
   m_FindAction->setShortcut(QKeySequence::Find);
   m_ZoomIn->setShortcut(QKeySequence::ZoomIn);
   m_ZoomOut->setShortcut(QKeySequence::ZoomOut);
 }
 
 void HelpEditor::disableShortcuts()
 {
   m_BackAction->setShortcut(QKeySequence());
   m_ForwardAction->setShortcut(QKeySequence());
   m_FindAction->setShortcut(QKeySequence());
   m_ZoomIn->setShortcut(QKeySequence());
   m_ZoomOut->setShortcut(QKeySequence());
 }
 
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt.help/src/internal/berryHelpEditor.h b/BlueBerry/Bundles/org.blueberry.ui.qt.help/src/internal/berryHelpEditor.h
index 35ce350be5..29f869254b 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt.help/src/internal/berryHelpEditor.h
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt.help/src/internal/berryHelpEditor.h
@@ -1,109 +1,111 @@
 /*===================================================================
 
 BlueBerry Platform
 
 Copyright (c) German Cancer Research Center, 
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without 
 even the implied warranty of MERCHANTABILITY or FITNESS FOR 
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef BERRYHELPEDITOR_H_
 #define BERRYHELPEDITOR_H_
 
 #include <berryIReusableEditor.h>
 #include <berryIPartListener.h>
 #include <berryIPerspectiveListener.h>
 #include <berryQtEditorPart.h>
 
 class QToolBar;
 class QWebPage;
 
 namespace berry {
 
 class HelpWebView;
 class HelpEditorFindWidget;
 
 class HelpEditor : public QtEditorPart, public IReusableEditor, public IPartListener, public IPerspectiveListener
 {
   Q_OBJECT
 
 public:
   berryObjectMacro(HelpEditor)
 
   static const std::string EDITOR_ID;
 
   HelpEditor();
   ~HelpEditor();
 
   void Init(berry::IEditorSite::Pointer site, berry::IEditorInput::Pointer input);
 
   void SetFocus();
 
   void DoSave() {}
   void DoSaveAs() {}
   bool IsDirty() const { return false; }
   bool IsSaveAsAllowed() const { return false; }
 
   QWebPage* GetQWebPage() const;
 
   IPartListener::Events::Types GetPartEventTypes() const;
   void PartDeactivated(IWorkbenchPartReference::Pointer /*partRef*/);
 
   IPerspectiveListener::Events::Types GetPerspectiveEventTypes() const;
   void PerspectiveActivated(SmartPointer<IWorkbenchPage> page, IPerspectiveDescriptor::Pointer perspective);
   void PerspectiveDeactivated(SmartPointer<IWorkbenchPage> page, IPerspectiveDescriptor::Pointer perspective);
 
 protected:
 
   void CreateQtPartControl(QWidget* parent);
 
   void DoSetInput(IEditorInput::Pointer input);
   void SetInputWithNotify(IEditorInput::Pointer input);
   void SetInput(IEditorInput::Pointer input);
 
 private Q_SLOTS:
 
   void HomePageChanged(const QString& page);
   void OpenHelpPerspective();
+  void CloseHelpPerspective();
 
   void InitializeTitle();
   void ShowTextSearch();
 
   void findNext();
   void findPrevious();
   void find(const QString& ttf, bool forward);
 
 private:
 
   bool findInWebPage(const QString& ttf, bool forward);
 
   void enableShortcuts();
   void disableShortcuts();
 
 private:
 
   Q_DISABLE_COPY(HelpEditor)
 
   QToolBar* m_ToolBar;
   HelpWebView* m_WebView;
   HelpEditorFindWidget* m_FindWidget;
 
   QAction* m_BackAction;
   QAction* m_ForwardAction;
   QAction* m_FindAction;
   QAction* m_ZoomIn;
   QAction* m_ZoomOut;
   QAction* m_OpenHelpMode;
+  QAction* m_CloseHelpMode;
   QAction* m_HomeAction;
 };
 
 } // end namespace berry
 
 #endif /*BERRYHELPEDITOR_H_*/
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt.help/src/internal/berryHelpPluginActivator.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt.help/src/internal/berryHelpPluginActivator.cpp
index 518d869e50..cca4a2e3b2 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt.help/src/internal/berryHelpPluginActivator.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt.help/src/internal/berryHelpPluginActivator.cpp
@@ -1,465 +1,470 @@
 /*===================================================================
 
 BlueBerry Platform
 
 Copyright (c) German Cancer Research Center, 
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without 
 even the implied warranty of MERCHANTABILITY or FITNESS FOR 
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "berryHelpPluginActivator.h"
 
 #include "berryHelpContentView.h"
 #include "berryHelpIndexView.h"
 #include "berryHelpSearchView.h"
 #include "berryHelpEditor.h"
 #include "berryHelpEditorInput.h"
 #include "berryHelpPerspective.h"
 
 #include "berryQHelpEngineConfiguration.h"
 #include "berryQHelpEngineWrapper.h"
 
 #include <berryPlatformUI.h>
 
 #include <service/event/ctkEventConstants.h>
 
 #include <QtPlugin>
 #include <QDir>
 #include <QDateTime>
 
 namespace berry {
 
 class HelpPerspectiveListener : public IPerspectiveListener
 {
 public:
 
   Events::Types GetPerspectiveEventTypes() const;
 
   void PerspectiveOpened(SmartPointer<IWorkbenchPage> page, IPerspectiveDescriptor::Pointer perspective);
   void PerspectiveChanged(SmartPointer<IWorkbenchPage> page, IPerspectiveDescriptor::Pointer perspective, const std::string &changeId);
 };
 
 class HelpWindowListener : public IWindowListener
 {
 public:
 
   HelpWindowListener();
   ~HelpWindowListener();
 
   void WindowClosed(IWorkbenchWindow::Pointer window);
   void WindowOpened(IWorkbenchWindow::Pointer window);
 
 private:
 
   // We use the same perspective listener for every window
   IPerspectiveListener::Pointer perspListener;
 };
 
 
 HelpPluginActivator* HelpPluginActivator::instance = 0;
 
 HelpPluginActivator::HelpPluginActivator()
   : pluginListener(0)
 {
   this->instance = this;
 }
 
 HelpPluginActivator::~HelpPluginActivator()
 {
   instance = 0;
 }
 
 void 
 HelpPluginActivator::start(ctkPluginContext* context)
 {
   BERRY_REGISTER_EXTENSION_CLASS(berry::HelpContentView, context)
   BERRY_REGISTER_EXTENSION_CLASS(berry::HelpIndexView, context)
   BERRY_REGISTER_EXTENSION_CLASS(berry::HelpSearchView, context)
   BERRY_REGISTER_EXTENSION_CLASS(berry::HelpEditor, context)
   BERRY_REGISTER_EXTENSION_CLASS(berry::HelpPerspective, context)
 
   QFileInfo qhcInfo = context->getDataFile("qthelpcollection.qhc");
   helpEngine.reset(new QHelpEngineWrapper(qhcInfo.absoluteFilePath()));
   if (!helpEngine->setupData())
   {
     BERRY_ERROR << "QHelpEngine set-up failed: " << helpEngine->error().toStdString();
     return;
   }
 
   helpEngineConfiguration.reset(new QHelpEngineConfiguration(context, *helpEngine.data()));
 
   delete pluginListener;
   pluginListener = new QCHPluginListener(context, helpEngine.data());
   context->connectPluginListener(pluginListener, SLOT(pluginChanged(ctkPluginEvent)));
 
   // register all QCH files from all the currently installed plugins
   pluginListener->processPlugins();
 
   helpEngine->initialDocSetupDone();
 
   // Register a wnd listener which registers a perspective listener for each
   // new window. The perspective listener opens the help home page in the window
   // if no other help page is opened yet.
   wndListener = IWindowListener::Pointer(new HelpWindowListener());
   PlatformUI::GetWorkbench()->AddWindowListener(wndListener);
 
   // Register an event handler for CONTEXTHELP_REQUESTED events
   helpContextHandler.reset(new HelpContextHandler);
   ctkDictionary helpHandlerProps;
   helpHandlerProps.insert(ctkEventConstants::EVENT_TOPIC, "org/blueberry/ui/help/CONTEXTHELP_REQUESTED");
   context->registerService<ctkEventHandler>(helpContextHandler.data(), helpHandlerProps);
 }
 
 void 
 HelpPluginActivator::stop(ctkPluginContext* /*context*/)
 {
   delete pluginListener;
   pluginListener = 0;
 
   if (PlatformUI::IsWorkbenchRunning())
   {
     PlatformUI::GetWorkbench()->RemoveWindowListener(wndListener);
   }
   wndListener = 0;
 }
 
 HelpPluginActivator *HelpPluginActivator::getInstance()
 {
   return instance;
 }
 
 QHelpEngineWrapper& HelpPluginActivator::getQHelpEngine()
 {
   return *helpEngine;
 }
 
 void HelpPluginActivator::linkActivated(IWorkbenchPage::Pointer page, const QUrl &link)
 {
   IEditorInput::Pointer input(new HelpEditorInput(link));
 
   // see if an editor with the same input is already open
   IEditorPart::Pointer reuseEditor = page->FindEditor(input);
   if (reuseEditor)
   {
     // just activate it
     page->Activate(reuseEditor);
   }
   else
   {
     // reuse the currently active editor, if it is a HelpEditor
     reuseEditor = page->GetActiveEditor();
     if (reuseEditor.IsNotNull() && page->GetReference(reuseEditor)->GetId() == HelpEditor::EDITOR_ID)
     {
       page->ReuseEditor(reuseEditor.Cast<IReusableEditor>(), input);
       page->Activate(reuseEditor);
     }
     else
     {
       // get the last used HelpEditor instance
       std::vector<IEditorReference::Pointer> editors =
           page->FindEditors(IEditorInput::Pointer(0), HelpEditor::EDITOR_ID, IWorkbenchPage::MATCH_ID);
       if (editors.empty())
       {
         // no HelpEditor is currently open, create a new one
         page->OpenEditor(input, HelpEditor::EDITOR_ID);
       }
       else
       {
         // reuse an existing editor
         reuseEditor = editors.front()->GetEditor(false);
         page->ReuseEditor(reuseEditor.Cast<IReusableEditor>(), input);
         page->Activate(reuseEditor);
       }
     }
   }
 }
 
 QCHPluginListener::QCHPluginListener(ctkPluginContext* context, QHelpEngine* helpEngine)
   : delayRegistration(true), context(context), helpEngine(helpEngine)
 {}
 
 void QCHPluginListener::processPlugins()
 {
   QMutexLocker lock(&mutex);
   processPlugins_unlocked();
 }
 
 void QCHPluginListener::pluginChanged(const ctkPluginEvent& event)
 {
   QMutexLocker lock(&mutex);
   if (delayRegistration)
   {
     this->processPlugins_unlocked();
     return;
   }
 
   /* Only should listen for RESOLVED and UNRESOLVED events.
    *
    * When a plugin is updated the Framework will publish an UNRESOLVED and
    * then a RESOLVED event which should cause the plugin to be removed
    * and then added back into the registry.
    *
    * When a plugin is uninstalled the Framework should publish an UNRESOLVED
    * event and then an UNINSTALLED event so the plugin will have been removed
    * by the UNRESOLVED event before the UNINSTALLED event is published.
    */
   QSharedPointer<ctkPlugin> plugin = event.getPlugin();
   switch (event.getType())
   {
     case ctkPluginEvent::RESOLVED :
       addPlugin(plugin);
       break;
     case ctkPluginEvent::UNRESOLVED :
       removePlugin(plugin);
       break;
   }
 }
 
 void QCHPluginListener::processPlugins_unlocked()
 {
   if (!delayRegistration) return;
 
   foreach (QSharedPointer<ctkPlugin> plugin, context->getPlugins())
   {
     if (isPluginResolved(plugin))
       addPlugin(plugin);
     else
       removePlugin(plugin);
   }
 
   delayRegistration = false;
 }
 
 bool QCHPluginListener::isPluginResolved(QSharedPointer<ctkPlugin> plugin)
 {
   return (plugin->getState() & (ctkPlugin::RESOLVED | ctkPlugin::ACTIVE | ctkPlugin::STARTING | ctkPlugin::STOPPING)) != 0;
 }
 
 void QCHPluginListener::removePlugin(QSharedPointer<ctkPlugin> plugin)
 {
   // bail out if system plugin
   if (plugin->getPluginId() == 0) return;
 
   QFileInfo qchDirInfo = context->getDataFile("qch_files/" + QString::number(plugin->getPluginId()));
   if (qchDirInfo.exists())
   {
     QDir qchDir(qchDirInfo.absoluteFilePath());
     QStringList qchEntries = qchDir.entryList(QStringList("*.qch"));
     QStringList qchFiles;
     foreach(QString qchEntry, qchEntries)
     {
       qchFiles << qchDir.absoluteFilePath(qchEntry);
     }
     // unregister the cached qch files
     foreach(QString qchFile, qchFiles)
     {
       QString namespaceName = QHelpEngineCore::namespaceName(qchFile);
       if (namespaceName.isEmpty())
       {
         BERRY_ERROR << "Could not get the namespace for qch file " << qchFile.toStdString();
         continue;
       }
       else
       {
         if (!helpEngine->unregisterDocumentation(namespaceName))
         {
           BERRY_ERROR << "Unregistering qch namespace " << namespaceName.toStdString() << " failed: " << helpEngine->error().toStdString();
         }
       }
     }
     // clean the directory
     foreach(QString qchEntry, qchEntries)
     {
       qchDir.remove(qchEntry);
     }
   }
 }
 
 void QCHPluginListener::addPlugin(QSharedPointer<ctkPlugin> plugin)
 {
   // bail out if system plugin
   if (plugin->getPluginId() == 0) return;
 
   QFileInfo qchDirInfo = context->getDataFile("qch_files/" + QString::number(plugin->getPluginId()));
   QUrl location(plugin->getLocation());
   QFileInfo pluginFileInfo(location.toLocalFile());
 
   if (!qchDirInfo.exists() || qchDirInfo.lastModified() < pluginFileInfo.lastModified())
   {
     removePlugin(plugin);
 
     if (!qchDirInfo.exists())
     {
       QDir().mkpath(qchDirInfo.absoluteFilePath());
     }
 
     QStringList localQCHFiles;
     QStringList resourceList = plugin->findResources("/", "*.qch", true);
     foreach(QString resource, resourceList)
     {
       QByteArray content = plugin->getResource(resource);
       QFile localFile(qchDirInfo.absoluteFilePath() + "/" + resource.section('/', -1));
       localFile.open(QIODevice::WriteOnly);
       localFile.write(content);
       localFile.close();
       if (localFile.error() != QFile::NoError)
       {
         BERRY_WARN << "Error writing " << localFile.fileName().toStdString()
                    << ": " << localFile.errorString().toStdString();
       }
       else
       {
         localQCHFiles << localFile.fileName();
       }
     }
 
     foreach(QString qchFile, localQCHFiles)
     {
       if (!helpEngine->registerDocumentation(qchFile))
       {
         BERRY_ERROR << "Registering qch file " << qchFile.toStdString() << " failed: " << helpEngine->error().toStdString();
       }
     }
   }
 
 }
 
 IPerspectiveListener::Events::Types HelpPerspectiveListener::GetPerspectiveEventTypes() const
 {
   return Events::OPENED | Events::CHANGED;
 }
 
 void HelpPerspectiveListener::PerspectiveOpened(SmartPointer<IWorkbenchPage> page, IPerspectiveDescriptor::Pointer perspective)
 {
   // if no help editor is opened, open one showing the home page
   if (perspective->GetId() == HelpPerspective::ID &&
       page->FindEditors(IEditorInput::Pointer(0), HelpEditor::EDITOR_ID, IWorkbenchPage::MATCH_ID).empty())
   {
     IEditorInput::Pointer input(new HelpEditorInput());
     page->OpenEditor(input, HelpEditor::EDITOR_ID);
   }
 }
 
 void HelpPerspectiveListener::PerspectiveChanged(SmartPointer<IWorkbenchPage> page, IPerspectiveDescriptor::Pointer perspective, const std::string &changeId)
 {
   if (perspective->GetId() == HelpPerspective::ID && changeId == IWorkbenchPage::CHANGE_RESET)
   {
     PerspectiveOpened(page, perspective);
   }
 }
 
 HelpWindowListener::HelpWindowListener()
   : perspListener(new HelpPerspectiveListener())
 {
   // Register perspective listener for already opened windows
   typedef std::vector<IWorkbenchWindow::Pointer> WndVec;
   WndVec windows = PlatformUI::GetWorkbench()->GetWorkbenchWindows();
   for (WndVec::iterator i = windows.begin(); i != windows.end(); ++i)
   {
     (*i)->AddPerspectiveListener(perspListener);
   }
 }
 
 HelpWindowListener::~HelpWindowListener()
 {
   typedef std::vector<IWorkbenchWindow::Pointer> WndVec;
   WndVec windows = PlatformUI::GetWorkbench()->GetWorkbenchWindows();
   for (WndVec::iterator i = windows.begin(); i != windows.end(); ++i)
   {
     (*i)->RemovePerspectiveListener(perspListener);
   }
 }
 
 void HelpWindowListener::WindowClosed(IWorkbenchWindow::Pointer window)
 {
   window->RemovePerspectiveListener(perspListener);
 }
 
 void HelpWindowListener::WindowOpened(IWorkbenchWindow::Pointer window)
 {
   window->AddPerspectiveListener(perspListener);
 }
 
 void HelpContextHandler::handleEvent(const ctkEvent &event)
 {
   struct _runner : public Poco::Runnable
   {
     _runner(const ctkEvent& ev) : ev(ev) {}
 
     void run()
     {
       QUrl helpUrl;
       if (ev.containsProperty("url"))
       {
         helpUrl = QUrl(ev.getProperty("url").toString());
       }
       else
       {
         helpUrl = contextUrl();
       }
 
       HelpPluginActivator::linkActivated(PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage(),
                                          helpUrl);
       delete this;
     }
 
     QUrl contextUrl() const
     {
       berry::IWorkbench* currentWorkbench = berry::PlatformUI::GetWorkbench();
       if (currentWorkbench)
       {
         berry::IWorkbenchWindow::Pointer currentWorkbenchWindow = currentWorkbench->GetActiveWorkbenchWindow();
         if (currentWorkbenchWindow)
         {
           berry::IWorkbenchPage::Pointer currentPage = currentWorkbenchWindow->GetActivePage();
           if (currentPage)
           {
             berry::IWorkbenchPart::Pointer currentPart = currentPage->GetActivePart();
             if (currentPart)
             {
               QString pluginID = QString::fromStdString(currentPart->GetSite()->GetPluginId());
               QString viewID = QString::fromStdString(currentPart->GetSite()->GetId());
               QString loc = "qthelp://" + pluginID + "/bundle/%1.html";
 
               QHelpEngineWrapper& helpEngine = HelpPluginActivator::getInstance()->getQHelpEngine();
+              // Get view help page if available
               QUrl contextUrl(loc.arg(viewID.replace(".", "_")));
               QUrl url = helpEngine.findFile(contextUrl);
               if (url.isValid()) return url;
               else
               {
                 BERRY_INFO << "Context help url invalid: " << contextUrl.toString().toStdString();
               }
+              // If no view help exists get plugin help if available
+              QUrl pluginContextUrl(loc.arg(pluginID.replace(".", "_")));
+              url = helpEngine.findFile(pluginContextUrl);
+              if (url.isValid()) return url;
               // Try to get the index.html file of the plug-in contributing the
               // currently active part.
               QUrl pluginIndexUrl(loc.arg("index"));
               url = helpEngine.findFile(pluginIndexUrl);
               if (url != pluginIndexUrl)
               {
                 // Use the default page instead of another index.html
                 // (merged via the virtual folder property).
                 url = QUrl();
               }
               return url;
             }
           }
         }
       }
       return QUrl();
     }
 
     ctkEvent ev;
   };
   // sync with GUI thread
   Display::GetDefault()->AsyncExec(new _runner(event));
 }
 
 }
 
 Q_EXPORT_PLUGIN2(org_blueberry_ui_qt_help, berry::HelpPluginActivator)
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt.log/manifest_headers.cmake b/BlueBerry/Bundles/org.blueberry.ui.qt.log/manifest_headers.cmake
index 1b65ca4047..2e97a135f4 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt.log/manifest_headers.cmake
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt.log/manifest_headers.cmake
@@ -1,6 +1,7 @@
 set(Plugin-Name "BlueBerry Log Bundle")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "DKFZ, Medical and Biological Informatics")
 set(Plugin-ContactAddress "http://www.mitk.org")
 set(Require-Plugin org.blueberry.ui.qt)
+set(Plugin-ActivationPolicy "eager")
 
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt.log/src/internal/berryQtLogView.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt.log/src/internal/berryQtLogView.cpp
index 1e25b4c2cc..6d92f2a313 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt.log/src/internal/berryQtLogView.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt.log/src/internal/berryQtLogView.cpp
@@ -1,150 +1,163 @@
 /*===================================================================
 
 BlueBerry Platform
 
 Copyright (c) German Cancer Research Center, 
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without 
 even the implied warranty of MERCHANTABILITY or FITNESS FOR 
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifdef __MINGW32__
 // We need to inlclude winbase.h here in order to declare
 // atomic intrinsics like InterlockedIncrement correctly.
 // Otherwhise, they would be declared wrong within qatomic_windows.h .
 #include <windows.h>
 #endif
 
 #include "berryQtLogView.h"
 
 #include "berryQtLogPlugin.h"
 
 #include <berryIPreferencesService.h>
 #include <berryIBerryPreferences.h>
 #include <berryPlatform.h>
 #include <berryPlatformUI.h>
 
 #include <QHeaderView>
 
 #include <QTimer>
 #include <QClipboard>
 
 namespace berry {
 
 QtLogView::QtLogView(QWidget *parent)
     : QWidget(parent)
 {
   berry::IPreferencesService::Pointer prefService
     = berry::Platform::GetServiceRegistry()
     .GetServiceById<berry::IPreferencesService>(berry::IPreferencesService::ID);
   berry::IBerryPreferences::Pointer prefs
       = (prefService->GetSystemPreferences()->Node("org_blueberry_ui_qt_log"))
         .Cast<berry::IBerryPreferences>();
   
   
   prefs->PutBool("ShowAdvancedFields", false);
   prefs->PutBool("ShowCategory", true);
   bool showAdvancedFields = false;
      
 
   ui.setupUi(this);
   
   model = QtLogPlugin::GetInstance()->GetLogModel();
   model->SetShowAdvancedFiels( showAdvancedFields );
   
   filterModel = new QSortFilterProxyModel(this);
   filterModel->setSourceModel(model);
   filterModel->setFilterKeyColumn(-1);
 
   ui.tableView->setModel(filterModel);
-
+ 
   ui.tableView->verticalHeader()->setVisible(false);
   ui.tableView->horizontalHeader()->setStretchLastSection(true);
              
   connect( ui.filterContent, SIGNAL( textChanged( const QString& ) ), this, SLOT( slotFilterChange( const QString& ) ) );
   connect( filterModel, SIGNAL( rowsInserted ( const QModelIndex &, int, int ) ), this, SLOT( slotRowAdded( const QModelIndex &, int , int  ) ) );
-  connect( ui.ShowCategory, SIGNAL( clicked(bool checked)),this, SLOT(on_ShowAdvancedFields_clicked(checked)));
   connect( ui.SaveToClipboard, SIGNAL( clicked()),this, SLOT(on_SaveToClipboard_clicked()));
   
   ui.ShowAdvancedFields->setChecked( showAdvancedFields );
            
 }
 
 QtLogView::~QtLogView()
 {
 }
 
 void QtLogView::slotScrollDown( )
 {
   ui.tableView->scrollToBottom();
 }
 
 void QtLogView::slotFilterChange( const QString& q )
 {
   filterModel->setFilterRegExp(QRegExp(q, Qt::CaseInsensitive, QRegExp::FixedString));
 }
 
+
 void QtLogView::slotRowAdded ( const QModelIndex &  /*parent*/, int start, int end )
 {
-  static int first=false;
+  ui.tableView->resizeRowsToContents();
 
-  if(!first)
-  {
-    first=true;
-    ui.tableView->resizeColumnsToContents();
-    ui.tableView->resizeRowsToContents();
-  }
-  else
-    for(int r=start;r<=end;r++)
+  //only resize columns when first entry is added
+  static bool first = true;
+  if(first)
     {
-      ui.tableView->resizeRowToContents(r);
+    ui.tableView->resizeColumnsToContents();
+    first = false;
     }
 
   QTimer::singleShot(0,this,SLOT( slotScrollDown() ) );
 }
 
+void QtLogView::showEvent( QShowEvent * event )
+{
+  ui.tableView->resizeColumnsToContents();
+  ui.tableView->resizeRowsToContents();  
+}
+
 void QtLogView::on_ShowAdvancedFields_clicked( bool checked )
 {
   QtLogPlugin::GetInstance()->GetLogModel()->SetShowAdvancedFiels( checked );  
   ui.tableView->resizeColumnsToContents();
 
   berry::IPreferencesService::Pointer prefService
     = berry::Platform::GetServiceRegistry()
     .GetServiceById<berry::IPreferencesService>(berry::IPreferencesService::ID);
   berry::IBerryPreferences::Pointer prefs
       = (prefService->GetSystemPreferences()->Node("org_blueberry_ui_qt_log"))
         .Cast<berry::IBerryPreferences>();
   
   prefs->PutBool("ShowAdvancedFields", checked);
   prefs->Flush();
 }
 
 void QtLogView::on_ShowCategory_clicked( bool checked )
 {
   QtLogPlugin::GetInstance()->GetLogModel()->SetShowCategory( checked );  
   ui.tableView->resizeColumnsToContents();
 
   berry::IPreferencesService::Pointer prefService
     = berry::Platform::GetServiceRegistry()
     .GetServiceById<berry::IPreferencesService>(berry::IPreferencesService::ID);
   berry::IBerryPreferences::Pointer prefs
       = (prefService->GetSystemPreferences()->Node("org_blueberry_ui_qt_log"))
         .Cast<berry::IBerryPreferences>();
   
   prefs->PutBool("ShowCategory", checked);
   prefs->Flush();
 }
 
 void QtLogView::on_SaveToClipboard_clicked()
 {
   QClipboard *clipboard = QApplication::clipboard();
-  clipboard->setText(model->GetDataAsString());
+  QString loggingMessagesAsText = QString("");
+  for (int i=0; i<ui.tableView->model()->rowCount(); i++)
+    {
+    for (int j=0; j<ui.tableView->model()->columnCount(); j++)
+      {
+      QModelIndex index = ui.tableView->model()->index(i, j);
+      loggingMessagesAsText += ui.tableView->model()->data(index, Qt::DisplayRole).toString() + " ";
+      }
+    loggingMessagesAsText += "\n";
+    }
+
+  clipboard->setText(loggingMessagesAsText);
 }
 
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt.log/src/internal/berryQtLogView.h b/BlueBerry/Bundles/org.blueberry.ui.qt.log/src/internal/berryQtLogView.h
index 7b259e4bed..5dab3138c4 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt.log/src/internal/berryQtLogView.h
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt.log/src/internal/berryQtLogView.h
@@ -1,54 +1,56 @@
 /*===================================================================
 
 BlueBerry Platform
 
 Copyright (c) German Cancer Research Center, 
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without 
 even the implied warranty of MERCHANTABILITY or FITNESS FOR 
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef BERRYQTLOGVIEW_H
 #define BERRYQTLOGVIEW_H
 
 #include <QtGui/QWidget>           
 #include <QSortFilterProxyModel>
 
 #include "ui_berryQtLogView.h"
 
 #include "berryQtPlatformLogModel.h"
 
 namespace berry {
 
 class QtLogView : public QWidget
 {
     Q_OBJECT
     
 public:
     QtLogView(QWidget *parent = 0);
     ~QtLogView();
     QtPlatformLogModel *model;
     QSortFilterProxyModel *filterModel;
     
 private:
     Ui::QtLogViewClass ui;
+
+    void showEvent ( QShowEvent * event );
     
 protected slots:
     void slotFilterChange( const QString& );
     void slotRowAdded( const QModelIndex & , int , int  );
     void slotScrollDown( );
     void on_ShowAdvancedFields_clicked( bool checked = false );
     void on_ShowCategory_clicked( bool checked = false );
     void on_SaveToClipboard_clicked();
     
 };
 
 }
 
 #endif // BERRYQTLOGVIEW_H
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt.log/src/internal/berryQtPlatformLogModel.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt.log/src/internal/berryQtPlatformLogModel.cpp
index 50d44e3585..189caab746 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt.log/src/internal/berryQtPlatformLogModel.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt.log/src/internal/berryQtPlatformLogModel.cpp
@@ -1,329 +1,329 @@
 /*===================================================================
 
 BlueBerry Platform
 
 Copyright (c) German Cancer Research Center, 
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without 
 even the implied warranty of MERCHANTABILITY or FITNESS FOR 
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifdef __MINGW32__
 // We need to inlclude winbase.h here in order to declare
 // atomic intrinsics like InterlockedIncrement correctly.
 // Otherwhise, they would be declared wrong within qatomic_windows.h .
 #include <windows.h>
 #endif
 
 #include "berryQtPlatformLogModel.h"
 
 #include "berryPlatform.h"
 #include "event/berryPlatformEvents.h"
 
 #include <sstream>
 #include <string>
 #include <iostream>
 #include <iomanip>
 
 #include <Poco/Message.h>
 #include "berryLog.h"
 #include <QTimer>
 #include <QIcon>
 #include <QModelIndex>
 
 namespace berry {
 
 const QString QtPlatformLogModel::Error = QString("Error");
 const QString QtPlatformLogModel::Warn = QString("Warning");
 const QString QtPlatformLogModel::Fatal = QString("Fatal");
 const QString QtPlatformLogModel::Info = QString("Info");
 const QString QtPlatformLogModel::Debug = QString("Debug");
 
 void QtPlatformLogModel::slotFlushLogEntries()
 {
   m_Mutex.lock();
   std::list<ExtendedLogMessage> *tmp=m_Active;
   m_Active=m_Pending; m_Pending=tmp;
   m_Mutex.unlock();
 
   int num = static_cast<int>(m_Pending->size());
   
   if (num > 0)
   {
     int row = static_cast<int>(m_Entries.size());
     this->beginInsertRows(QModelIndex(), row, row+num-1);
     do {
       m_Entries.push_back(m_Pending->front());
       m_Pending->pop_front();
       
 
 
     } while(--num);
     this->endInsertRows();
   }
 }
 
 void QtPlatformLogModel::addLogEntry(const mbilog::LogMessage &msg)
 {
   m_Mutex.lock();
   //mbilog::BackendCout::FormatSmart(msg); FormatSmart is not static any more. So commented out this statement. Todo: fix
   m_Active->push_back(ExtendedLogMessage(msg));
   m_Mutex.unlock();
 
   emit signalFlushLogEntries();
   
 }
 
 void
 QtPlatformLogModel::SetShowAdvancedFiels( bool showAdvancedFiels )
 {
   if( m_ShowAdvancedFiels != showAdvancedFiels )
   {
     m_ShowAdvancedFiels = showAdvancedFiels;
     this->reset();
  
   }
 }
 
 void QtPlatformLogModel::SetShowCategory( bool showCategory )
 {
   if( m_ShowCategory != showCategory )
   {
     m_ShowCategory = showCategory;
     this->reset();
   }
 }
 
 void
 QtPlatformLogModel::addLogEntry(const PlatformEvent& event)
 {
   const Poco::Message& entry = Poco::RefAnyCast<const Poco::Message>(*event.GetData());
   mbilog::LogMessage msg(mbilog::Info,"n/a",-1,"n/a");
   msg.message += entry.getText();
   msg.category = "BlueBerry."+entry.getSource();
   msg.moduleName = "n/a";
   addLogEntry(msg);
 }
 
 QtPlatformLogModel::QtPlatformLogModel(QObject* parent) : QAbstractTableModel(parent), 
 m_ShowAdvancedFiels(false),
 m_ShowCategory(true)
 {
   m_Active=new std::list<ExtendedLogMessage>;
   m_Pending=new std::list<ExtendedLogMessage>;
   connect(this, SIGNAL(signalFlushLogEntries()), this, SLOT( slotFlushLogEntries() ), Qt::QueuedConnection );  
   Platform::GetEvents().logged += PlatformEventDelegate(this, &QtPlatformLogModel::addLogEntry);
   myBackend = new QtLogBackend(this);
 }
 
 QtPlatformLogModel::~QtPlatformLogModel()
 {
   disconnect(this, SIGNAL(signalFlushLogEntries()), this, SLOT( slotFlushLogEntries() ));
   
   // dont delete and unregister backend, only deactivate it to avoid thread syncronization issues cause mbilog::UnregisterBackend is not threadsafe 
   // will be fixed.
   //  delete myBackend;
   //  delete m_Active;
   //  delete m_Pending;
   m_Mutex.lock();
   myBackend->Deactivate();
   m_Mutex.unlock();
 }
 
 // QT Binding
 
 int
 QtPlatformLogModel::rowCount(const QModelIndex&) const
 {
   return static_cast<int>(m_Entries.size());
 }
 
 int
 QtPlatformLogModel::columnCount(const QModelIndex&) const
 {
   int returnValue = 2;
   if( m_ShowAdvancedFiels ) returnValue += 7;
   if( m_ShowCategory ) returnValue += 1;
   return returnValue;
 }
           /*
   struct LogEntry {
     LogEntry(const std::string& msg, const std::string& src, std::time_t t)
     : message(msg.c_str()), moduleName(src.c_str()),time(std::clock())
     { 
     }
 
     QString message;
     clock_t time;
 
     QString level;
     QString filePath;
     QString lineNumber;
     QString moduleName;
     QString category;
     QString function;
     
     LogEntry(const mbilog::LogMessage &msg)
     {
       message = msg.message.c_str();
       
                                                            
       filePath = msg.filePath;
             
       std::stringstream out;
       out << msg.lineNumber;
       lineNumber = out.str().c_str();
       
       moduleName = msg.moduleName;
       category = msg.category.c_str();
       function = msg.functionName;
       
       time=std::clock(); 
     }
   };        */
 
 
 QVariant QtPlatformLogModel::data(const QModelIndex& index, int role) const
 {
   const ExtendedLogMessage *msg = &m_Entries[index.row()];
   
   if (role == Qt::DisplayRole)
     {
     switch (index.column()) 
       {
       case 0:
         if (m_ShowAdvancedFiels) return msg->getTime();
         else return msg->getLevel();
       case 1: 
         if (m_ShowAdvancedFiels) return msg->getLevel();
         else return msg->getMessage();
       case 2: 
         if (m_ShowAdvancedFiels) return msg->getMessage();
         else return msg->getCategory();    
       case 3: 
         if (m_ShowAdvancedFiels && m_ShowCategory) return msg->getCategory();
         else if (m_ShowAdvancedFiels && !m_ShowCategory) return msg->getModuleName();
         else break;
       case 4:
         if (m_ShowAdvancedFiels && m_ShowCategory) return msg->getModuleName();
         else if (m_ShowAdvancedFiels && !m_ShowCategory) return msg->getFunctionName();
         else break;
       case 5: 
         if (m_ShowAdvancedFiels && m_ShowCategory) return msg->getFunctionName();
         else if (m_ShowAdvancedFiels && !m_ShowCategory) return msg->getPath();
         else break;
       case 6: 
         if (m_ShowAdvancedFiels && m_ShowCategory) return msg->getPath();
         else if (m_ShowAdvancedFiels && !m_ShowCategory) return msg->getLine();
         else break;
       case 7: 
         if (m_ShowAdvancedFiels && m_ShowCategory) return msg->getLine();
         else break;
       }
     }
    
   else if(  role == Qt::DecorationRole )
   {
     if ( (m_ShowAdvancedFiels && index.column()==1)
       || (!m_ShowAdvancedFiels && index.column()==0) )
     {
       QString file ( ":/org_blueberry_ui_qt_log/information.png" );
 
       if( msg->message.level == mbilog::Error )
         file = ":/org_blueberry_ui_qt_log/error.png";
       else if( msg->message.level == mbilog::Warn )
         file = ":/org_blueberry_ui_qt_log/warning.png";
       else if( msg->message.level == mbilog::Debug )
         file = ":/org_blueberry_ui_qt_log/debug.png";
       else if( msg->message.level == mbilog::Fatal )
         file = ":/org_blueberry_ui_qt_log/fatal.png";
 
       QIcon icon(file);
       return QVariant(icon);
 
     }
   }
 
 
   return QVariant();
 }
 
 QVariant
 QtPlatformLogModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if (role == Qt::DisplayRole && orientation == Qt::Horizontal)
   {
     if( m_ShowAdvancedFiels && m_ShowCategory )
     {
       switch (section) 
       {
         case 0: return QVariant("Time");
         case 1: return QVariant("Level");
         case 2: return QVariant("Message");
         case 3: return QVariant("Category");
         case 4: return QVariant("Module");
         case 5: return QVariant("Function");
         case 6: return QVariant("File");
         case 7: return QVariant("Line");
       }
     }
     else if (m_ShowAdvancedFiels && !m_ShowCategory)
     {
       switch (section) 
       {
         case 0: return QVariant("Time");
         case 1: return QVariant("Level");
         case 2: return QVariant("Message");
         case 3: return QVariant("Module");
         case 4: return QVariant("Function");
         case 5: return QVariant("File");
         case 6: return QVariant("Line");
       }
     }
     else //!m_ShowAdvancedFiels, m_ShowCategory is not handled seperately because it only activates case 2
     {
       switch (section) 
       {
-        case 0: return QVariant("Severtiy");
+        case 0: return QVariant("Level");
         case 1: return QVariant("Message");
         case 2: return QVariant("Category");
       }
     }
   }
 
   return QVariant();
 }
 
 QVariant QtPlatformLogModel::ExtendedLogMessage::getTime() const
     {
     std::stringstream ss;
     std::locale C("C");
     ss.imbue(C);
     ss << std::setw(7) << std::setprecision(3) << std::fixed << ((double)this->time)/CLOCKS_PER_SEC;
     return QVariant(QString(ss.str().c_str()));
     }
 
 QString QtPlatformLogModel::GetDataAsString()
     {
     QString returnValue("");
 
     for (int message=0; message<this->rowCount(QModelIndex()); message++)
       {
       for (int column=0; column<this->columnCount(QModelIndex()); column++)
         {
         returnValue += " " + this->data(this->index(message,column),Qt::DisplayRole).toString();
         }
       returnValue += "\n";
       }
     
     return returnValue;
     }
 
 
 }
diff --git a/CMake/mitkFunctionGetVersionDescription.cmake b/CMake/mitkFunctionGetVersionDescription.cmake
new file mode 100644
index 0000000000..816fd5e79a
--- /dev/null
+++ b/CMake/mitkFunctionGetVersionDescription.cmake
@@ -0,0 +1,60 @@
+#! \brief Extract the version description from a local working copy
+#!
+#! If the given repository is a git repository, the functions runs the
+#! git rev-parse --exact-match HEAD command 
+#!
+#! Information provided is stored in  ${prefix}_REVISION_DESC an is
+#! \ul
+#!  \li The exact tag if the HEAD of the source-tree has a tag
+#!  \li the 'git describe' output, which is <latest-reachable-tag>-<#Commits>-g<SHORT-HASH>
+#! \lu
+#! In case the working copy contains local changes, the ${prefix}_REVISION_DESC strings will contain
+#! a suffix [local changes]
+#!
+#! \param source_dir The directory containing a working copy
+#! \param prefix A prefix to prepent to the variables containing
+#!               the extracted information
+#!
+function(mitkFunctionGetVersionDescription source_dir prefix)
+
+  if(NOT prefix)
+    message(FATAL_ERROR "prefix argument not specified")
+  endif()
+
+  # initialize variable
+  set(_wc_description "NO TAG FOUND")
+  set(_dirty_repo_str " [local changes]")
+
+  find_package(Git)
+  if(GIT_FOUND)
+  
+    GIT_IS_REPO(${source_dir} _is_git_repo)
+    if(_is_git_repo)
+      execute_process(COMMAND git describe --exact-match --dirty=${_dirty_repo_str}
+                      WORKING_DIRECTORY ${source_dir} 
+                      OUTPUT_VARIABLE _project_git_tagname
+                      RESULT_VARIABLE _proper_version
+                      ERROR_VARIABLE _description_error )
+
+      if(_proper_version EQUAL 0 )
+        set(_wc_description ${_project_git_tagname})
+  
+      else(_proper_version EQUAL 0)
+        # the execution failed, i.e. the HEAD has no tag, 
+        # for fallback string: execute again but without the --exact-match
+        execute_process(COMMAND git describe --dirty=${_dirty_repo_str}
+                    WORKING_DIRECTORY ${source_dir} 
+                    OUTPUT_VARIABLE _wc_description
+                    RESULT_VARIABLE _proper_version
+                    ERROR_VARIABLE _description_error)
+      endif()
+
+      # remove newline at and of the string
+      string(STRIP "${_wc_description}" _wc_description)
+
+    endif()
+  endif()
+
+  set(${prefix}_REVISION_DESC ${_wc_description} PARENT_SCOPE )
+
+endfunction()
diff --git a/CMake/mitkSetupVariables.cmake b/CMake/mitkSetupVariables.cmake
index 8c46264c49..9651c54e44 100644
--- a/CMake/mitkSetupVariables.cmake
+++ b/CMake/mitkSetupVariables.cmake
@@ -1,166 +1,166 @@
 if(MITK_BUILD_ALL_PLUGINS)
   set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL")
 endif()
 
 set(LIBPOSTFIX "")
 
 # MITK_VERSION
 set(MITK_VERSION_MAJOR "2012")
-set(MITK_VERSION_MINOR "06")
-set(MITK_VERSION_PATCH "99")
+set(MITK_VERSION_MINOR "09")
+set(MITK_VERSION_PATCH "00")
 set(MITK_VERSION_STRING "${MITK_VERSION_MAJOR}.${MITK_VERSION_MINOR}.${MITK_VERSION_PATCH}")
 if(MITK_VERSION_PATCH STREQUAL "99")
   set(MITK_VERSION_STRING "${MITK_VERSION_STRING}-${MITK_REVISION_SHORTID}")
 endif()
 
 #-----------------------------------
 # Configuration of module system
 #-----------------------------------
 set(MODULES_CONF_DIRNAME modulesConf)
 set(MODULES_CONF_DIRS ${MITK_BINARY_DIR}/${MODULES_CONF_DIRNAME})
 
 if(NOT UNIX AND NOT MINGW)
   set(MITK_WIN32_FORCE_STATIC "STATIC" CACHE INTERNAL "Use this variable to always build static libraries on non-unix platforms")
 endif()
 
 # build the MITK_INCLUDE_DIRS variable
 set(MITK_INCLUDE_DIRS
     ${ITK_INCLUDE_DIRS}
     ${VTK_INCLUDE_DIRS}
     ${PROJECT_BINARY_DIR} # contains mitkConfig.h and similar files
     ${MODULES_CONF_DIRS} # contains module *Exports.h files
    )
 set(CORE_DIRECTORIES Common DataManagement Algorithms IO Rendering Interactions Controllers Service)
 foreach(d ${CORE_DIRECTORIES})
   list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/Core/Code/${d})
 endforeach()
 #list(APPEND MITK_INCLUDE_DIRS  
      #${ITK_INCLUDE_DIRS}
      #${VTK_INCLUDE_DIRS}
 #    )
      
 foreach(d Utilities Utilities/ipPic Utilities/pic2vtk Utilities/tinyxml Utilities/mbilog)
   list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/${d})
 endforeach()
 list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}/Utilities/mbilog)
 
 if(WIN32)
   list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipPic/win32)
 endif()
 
 # additional include dirs variables
 set(ANN_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ann/include)
 set(IPSEGMENTATION_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipSegmentation)
 
 # variables containing librariy names
 set(MITK_CORE_LIBRARIES Mitk)
 set(VTK_FOR_MITK_LIBRARIES
     vtkGraphics
     vtkCommon
     vtkFiltering
     vtkftgl
     vtkGraphics
     vtkHybrid
     vtkImaging
     vtkIO
     vtkParallel
     vtkRendering
     vtkVolumeRendering
     vtkWidgets
     ${VTK_JPEG_LIBRARIES}
     ${VTK_PNG_LIBRARIES}
     ${VTK_ZLIB_LIBRARIES}
     ${VTK_EXPAT_LIBRARIES}
     ${VTK_FREETYPE_LIBRARIES}
    )
 # TODO: maybe solve this with lib depends mechanism of CMake
 set(UTIL_FOR_MITK_LIBRARIES mitkIpPic mitkIpFunc mbilog)
 set(LIBRARIES_FOR_MITK_CORE
     ${UTIL_FOR_MITK_LIBRARIES}
     ${VTK_FOR_MITK_LIBRARIES}
     ${ITK_LIBRARIES}
    )
 set(MITK_LIBRARIES
     ${MITK_CORE_LIBRARIES}
     ${LIBRARIES_FOR_MITK_CORE}
     pic2vtk
     ipSegmentation
     ann 
    )
    
 # variables used in CMake macros which are called from external projects
 set(MITK_VTK_LIBRARY_DIRS ${VTK_LIBRARY_DIRS})
 set(MITK_ITK_LIBRARY_DIRS ${ITK_LIBRARY_DIRS})
 
 # variables containing link directories
 set(MITK_LIBRARY_DIRS ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})                                                                                                              
 set(MITK_LINK_DIRECTORIES
     ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
     ${ITK_LIBRARY_DIRS}
     ${VTK_LIBRARY_DIRS}
     ${GDCM_LIBRARY_DIRS})
 
 # Qt support
 if(MITK_USE_QT)
   find_package(Qt4 REQUIRED)
 
   set(QMITK_INCLUDE_DIRS 
       ${MITK_INCLUDE_DIRS}
       ${CMAKE_CURRENT_SOURCE_DIR}/Modules/Qmitk
       ${PROJECT_BINARY_DIR}/Modules/Qmitk
      )
   
   set(QMITK_LIBRARIES Qmitk ${MITK_LIBRARIES})
   set(QMITK_LINK_DIRECTORIES ${MITK_LINK_DIRECTORIES})
 endif()
 
 if(MITK_BUILD_ALL_PLUGINS)
   set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL")
 endif()
 
 # create a list of types for template instantiations of itk image access functions
 function(_create_type_seq TYPES seq_var seqdim_var)
   set(_seq )
   set(_seq_dim )
   string(REPLACE "," ";" _pixeltypes "${TYPES}")
   foreach(_pixeltype ${_pixeltypes})
     set(_seq "${_seq}(${_pixeltype})")
     set(_seq_dim "${_seq_dim}((${_pixeltype},dim))")
   endforeach()
   set(${seq_var} "${_seq}" PARENT_SCOPE)
   set(${seqdim_var} "${_seq_dim}" PARENT_SCOPE)
 endfunction()
 
 set(MITK_ACCESSBYITK_PIXEL_TYPES )
 set(MITK_ACCESSBYITK_PIXEL_TYPES_SEQ )
 set(MITK_ACCESSBYITK_TYPES_DIMN_SEQ )
 # concatenate only the simple pixel types to the MITK_ACCESSBYITK_PIXEL_TYPE_SEQ list
 # see Bug 12682 for detailed information
 foreach(_type INTEGRAL FLOATING)
   set(_typelist "${MITK_ACCESSBYITK_${_type}_PIXEL_TYPES}")
   if(_typelist)
     if(MITK_ACCESSBYITK_PIXEL_TYPES)
       set(MITK_ACCESSBYITK_PIXEL_TYPES "${MITK_ACCESSBYITK_PIXEL_TYPES},${_typelist}")
     else()
       set(MITK_ACCESSBYITK_PIXEL_TYPES "${_typelist}")
     endif()
   endif()
 
   _create_type_seq("${_typelist}"
                    MITK_ACCESSBYITK_${_type}_PIXEL_TYPES_SEQ
                    MITK_ACCESSBYITK_${_type}_TYPES_DIMN_SEQ)
   set(MITK_ACCESSBYITK_PIXEL_TYPES_SEQ "${MITK_ACCESSBYITK_PIXEL_TYPES_SEQ}${MITK_ACCESSBYITK_${_type}_PIXEL_TYPES_SEQ}")
   set(MITK_ACCESSBYITK_TYPES_DIMN_SEQ "${MITK_ACCESSBYITK_TYPES_DIMN_SEQ}${MITK_ACCESSBYITK_${_type}_TYPES_DIMN_SEQ}")
 endforeach()
 
 # separate processing of the COMPOSITE list to avoid its concatenation to to global list
 _create_type_seq(${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES}
                  MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES_SEQ
                  MITK_ACCESSBYITK_COMPOSITE_TYPES_DIMN_SEQ)
 
 set(MITK_ACCESSBYITK_DIMENSIONS_SEQ )
 string(REPLACE "," ";" _dimensions "${MITK_ACCESSBYITK_DIMENSIONS}")
 foreach(_dimension ${_dimensions})
   set(MITK_ACCESSBYITK_DIMENSIONS_SEQ "${MITK_ACCESSBYITK_DIMENSIONS_SEQ}(${_dimension})")
 endforeach()
 
diff --git a/CMakeExternals/CTK.cmake b/CMakeExternals/CTK.cmake
index 98bffb7e2b..442538a0a3 100644
--- a/CMakeExternals/CTK.cmake
+++ b/CMakeExternals/CTK.cmake
@@ -1,81 +1,81 @@
 #-----------------------------------------------------------------------------
 # CTK
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_CTK)
 
   # Sanity checks
   if(DEFINED CTK_DIR AND NOT EXISTS ${CTK_DIR})
     message(FATAL_ERROR "CTK_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj CTK)
   set(proj_DEPENDENCIES )
   set(CTK_DEPENDS ${proj})
 
   if(NOT DEFINED CTK_DIR)
     
-    set(revision_tag ee445fea)
+    set(revision_tag f25f19e5)
     #IF(${proj}_REVISION_TAG)
     #  SET(revision_tag ${${proj}_REVISION_TAG})
     #ENDIF()
     
     set(ctk_optional_cache_args )
     if(MITK_USE_Python)
       list(APPEND ctk_optional_cache_args
            -DCTK_LIB_Scripting/Python/Widgets:BOOL=ON
       )
     endif()
 
     if(MITK_USE_DCMTK)
       list(APPEND ctk_optional_cache_args
            -DDCMTK_DIR:PATH=${DCMTK_DIR}
           )
       list(APPEND proj_DEPENDENCIES DCMTK)
     else()
       list(APPEND ctk_optional_cache_args
            -DDCMTK_URL:STRING=${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_DCMTK_085525e6.tar.gz
           )
     endif()
 
     FOREACH(type RUNTIME ARCHIVE LIBRARY)
       IF(DEFINED CTK_PLUGIN_${type}_OUTPUT_DIRECTORY)
         LIST(APPEND mitk_optional_cache_args -DCTK_PLUGIN_${type}_OUTPUT_DIRECTORY:PATH=${CTK_PLUGIN_${type}_OUTPUT_DIRECTORY})
       ENDIF()
     ENDFOREACH()
 
     ExternalProject_Add(${proj}
       SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
       BINARY_DIR ${proj}-build
       PREFIX ${proj}-cmake
       URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_${revision_tag}.tar.gz
-      URL_MD5 9c41a78e2e2f9c4823c05a82c6d813ae
+      URL_MD5 70fadbc62ec5c7d83a6e672fd5be36b1
       UPDATE_COMMAND ""
       INSTALL_COMMAND ""
       CMAKE_GENERATOR ${gen}
       CMAKE_ARGS
         ${ep_common_args}
         ${ctk_optional_cache_args}
         -DDESIRED_QT_VERSION:STRING=4
         -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
         -DGit_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE}
         -DGIT_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE}
         -DCTK_LIB_CommandLineModules/Backend/LocalProcess:BOOL=ON
         -DCTK_LIB_CommandLineModules/Frontend/QtGui:BOOL=ON
         -DCTK_LIB_PluginFramework:BOOL=ON
         -DCTK_LIB_DICOM/Widgets:BOOL=ON
         -DCTK_PLUGIN_org.commontk.eventadmin:BOOL=ON
         -DCTK_PLUGIN_org.commontk.configadmin:BOOL=ON
         -DCTK_USE_GIT_PROTOCOL:BOOL=OFF
         -DDCMTK_URL:STRING=${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_DCMTK_085525e6.tar.gz
       DEPENDS ${proj_DEPENDENCIES}
      )
   set(CTK_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
   
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
     
   endif()
   
 endif()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 75a1ae56f3..57a82616b2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,916 +1,918 @@
 if(APPLE)
   # With XCode 4.3, the SDK location changed. Older CMake
   # versions are not able to find it.
   cmake_minimum_required(VERSION 2.8.8)
 else()
   cmake_minimum_required(VERSION 2.8.4)
 endif()
 
 #-----------------------------------------------------------------------------
 # Set a default build type if none was specified
 #-----------------------------------------------------------------------------
 
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   message(STATUS "Setting build type to 'Debug' as none was specified.")
   set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
 
   # Set the possible values of build type for cmake-gui
   set_property(CACHE CMAKE_BUILD_TYPE PROPERTY 
                STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
 endif()
 
 #-----------------------------------------------------------------------------
 # Superbuild Option - Enabled by default
 #-----------------------------------------------------------------------------
 
 option(MITK_USE_SUPERBUILD "Build MITK and the projects it depends on via SuperBuild.cmake." ON)
 
 if(MITK_USE_SUPERBUILD)
   project(MITK-superbuild)
   set(MITK_SOURCE_DIR ${PROJECT_SOURCE_DIR})
   set(MITK_BINARY_DIR ${PROJECT_BINARY_DIR})
 else()
   project(MITK)
 endif()
 
 #-----------------------------------------------------------------------------
 # Warn if source or build path is too long
 #-----------------------------------------------------------------------------
 
 if(WIN32)
   set(_src_dir_length_max 50)
   set(_bin_dir_length_max 50)
   if(MITK_USE_SUPERBUILD)
     set(_src_dir_length_max 43) # _src_dir_length_max - strlen(ITK-src)
     set(_bin_dir_length_max 40) # _bin_dir_length_max - strlen(MITK-build)
   endif()
   
   string(LENGTH "${MITK_SOURCE_DIR}" _src_n)
   string(LENGTH "${MITK_BINARY_DIR}" _bin_n)
   
   # The warnings should be converted to errors
   if(_src_n GREATER _src_dir_length_max)
     message(WARNING "MITK source code directory path length is too long (${_src_n} > ${_src_dir_length_max})."
                     "Please move the MITK source code directory to a directory with a shorter path." )
   endif()
   if(_bin_n GREATER _bin_dir_length_max)
     message(WARNING "MITK build directory path length is too long (${_bin_n} > ${_bin_dir_length_max})."
                     "Please move the MITK build directory to a directory with a shorter path." )
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # See http://cmake.org/cmake/help/cmake-2-8-docs.html#section_Policies for details
 #-----------------------------------------------------------------------------
 
 set(project_policies
   CMP0001 # NEW: CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.
   CMP0002 # NEW: Logical target names must be globally unique.
   CMP0003 # NEW: Libraries linked via full path no longer produce linker search paths.
   CMP0004 # NEW: Libraries linked may NOT have leading or trailing whitespace.
   CMP0005 # NEW: Preprocessor definition values are now escaped automatically.
   CMP0006 # NEW: Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.
   CMP0007 # NEW: List command no longer ignores empty elements.
   CMP0008 # NEW: Libraries linked by full-path must have a valid library file name.
   CMP0009 # NEW: FILE GLOB_RECURSE calls should not follow symlinks by default.
   CMP0010 # NEW: Bad variable reference syntax is an error.
   CMP0011 # NEW: Included scripts do automatic cmake_policy PUSH and POP.
   CMP0012 # NEW: if() recognizes numbers and boolean constants.
   CMP0013 # NEW: Duplicate binary directories are not allowed.
   CMP0014 # NEW: Input directories must have CMakeLists.txt
   )
 foreach(policy ${project_policies})
   if(POLICY ${policy})
     cmake_policy(SET ${policy} NEW)
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Update CMake module path
 #------------------------------------------------------------------------------
 
 set(CMAKE_MODULE_PATH
   ${MITK_SOURCE_DIR}/CMake
   ${CMAKE_MODULE_PATH}
   )
 
 #-----------------------------------------------------------------------------
 # CMake function(s) and macro(s)
 #-----------------------------------------------------------------------------
 
 include(mitkMacroEmptyExternalProject)
 include(mitkFunctionGenerateProjectXml)
 include(mitkFunctionSuppressWarnings)
 
 SUPPRESS_VC_DEPRECATED_WARNINGS()
 
 #-----------------------------------------------------------------------------
 # Output directories.
 #-----------------------------------------------------------------------------
 
 foreach(type LIBRARY RUNTIME ARCHIVE)
   # Make sure the directory exists
   if(DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY
      AND NOT EXISTS ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
     message("Creating directory MITK_CMAKE_${type}_OUTPUT_DIRECTORY: ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}")
     file(MAKE_DIRECTORY "${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}")
   endif()
 
   if(MITK_USE_SUPERBUILD)
     set(output_dir ${MITK_BINARY_DIR}/bin)
     if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
       set(MITK_CMAKE_${type}_OUTPUT_DIRECTORY ${MITK_BINARY_DIR}/MITK-build/bin)
     endif()
   else()
     if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
       set(output_dir ${MITK_BINARY_DIR}/bin)
     else()
       set(output_dir ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
     endif()
   endif()
   set(CMAKE_${type}_OUTPUT_DIRECTORY ${output_dir} CACHE INTERNAL "Single output directory for building all libraries.")
   mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY)
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Additional MITK Options (also shown during superbuild)
 #-----------------------------------------------------------------------------
 
 option(BUILD_SHARED_LIBS "Build MITK with shared libraries" ON)
 option(WITH_COVERAGE "Enable/Disable coverage" OFF)
 option(BUILD_TESTING "Test the project" ON)
 
 option(MITK_BUILD_ALL_APPS "Build all MITK applications" OFF)
 set(MITK_BUILD_TUTORIAL OFF CACHE INTERNAL "Deprecated! Use MITK_BUILD_EXAMPLES instead!")
 option(MITK_BUILD_EXAMPLES "Build the MITK Examples" ${MITK_BUILD_TUTORIAL})
 option(MITK_USE_Boost "Use the Boost C++ library" OFF)
 option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON)
 option(MITK_USE_CTK "Use CTK in MITK" ${MITK_USE_BLUEBERRY})
 option(MITK_USE_QT "Use Nokia's Qt library" ${MITK_USE_CTK})
 option(MITK_USE_DCMTK "EXPERIMENTAL, superbuild only: Use DCMTK in MITK" ${MITK_USE_CTK})
 option(MITK_DCMTK_BUILD_SHARED_LIBS "EXPERIMENTAL, superbuild only: build DCMTK as shared libs" OFF)
 option(MITK_USE_OpenCV "Use Intel's OpenCV library" OFF)
 option(MITK_USE_Python "Use Python wrapping in MITK" OFF)
 set(MITK_USE_CableSwig ${MITK_USE_Python})
 
 mark_as_advanced(MITK_BUILD_ALL_APPS
                  MITK_USE_CTK
                  MITK_USE_DCMTK
                 )
 
 
 if(MITK_USE_Boost)
   option(MITK_USE_SYSTEM_Boost "Use the system Boost" OFF)
   set(MITK_USE_Boost_LIBRARIES "" CACHE STRING "A semi-colon separated list of required Boost libraries")
 endif()
 
 if(MITK_USE_BLUEBERRY)
   option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF)
   mark_as_advanced(MITK_BUILD_ALL_PLUGINS)
   
   if(NOT MITK_USE_CTK)
     message("Forcing MITK_USE_CTK to ON because of MITK_USE_BLUEBERRY")
     set(MITK_USE_CTK ON CACHE BOOL "Use CTK in MITK" FORCE)
   endif()
 endif()
   
 if(MITK_USE_CTK)
   if(NOT MITK_USE_QT)
     message("Forcing MITK_USE_QT to ON because of MITK_USE_CTK")
     set(MITK_USE_QT ON CACHE BOOL "Use Nokia's Qt library in MITK" FORCE)
   endif()
   if(NOT MITK_USE_DCMTK)
     message("Setting MITK_USE_DCMTK to ON because DCMTK needs to be build for CTK")
     set(MITK_USE_DCMTK ON CACHE BOOL "Use DCMTK in MITK" FORCE)
   endif()
 endif()
 
 if(MITK_USE_QT)
   # find the package at the very beginning, so that QT4_FOUND is available
   find_package(Qt4 4.6.2 REQUIRED)
 endif()
 
 
 # Customize the default pixel types for multiplex macros
 
 set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
     "int, unsigned int, short, unsigned short, char, unsigned char"
     CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
 set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
     "double, float"
     CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
 set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
     "itk::RGBPixel<unsigned char>, itk::RGBAPixel<unsigned char>"
     CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
 set(MITK_ACCESSBYITK_DIMENSIONS
     "2,3"
     CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros")
 
 mark_as_advanced(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
                  MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
                  MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
                  MITK_ACCESSBYITK_DIMENSIONS
                 )
 
 # consistency checks
 
 if(NOT MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
       "int, unsigned int, short, unsigned short, char, unsigned char"
       CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
       "double, float"
       CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
     "itk::RGBPixel<unsigned char>, itk::RGBAPixel<unsigned char>"
     CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_DIMENSIONS)
   set(MITK_ACCESSBYITK_DIMENSIONS
       "2,3"
       CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros")
 endif()
 
 #-----------------------------------------------------------------------------
 # Additional CXX/C Flags
 #-----------------------------------------------------------------------------
 
 set(ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags")
 mark_as_advanced(ADDITIONAL_C_FLAGS)
 set(ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags")
 mark_as_advanced(ADDITIONAL_CXX_FLAGS)
 
 #-----------------------------------------------------------------------------
 # Project.xml
 #-----------------------------------------------------------------------------
 
 # A list of topologically ordered targets
 set(CTEST_PROJECT_SUBPROJECTS)
 if(MITK_USE_BLUEBERRY)
   list(APPEND CTEST_PROJECT_SUBPROJECTS BlueBerry)
 endif()
 
 list(APPEND CTEST_PROJECT_SUBPROJECTS
   MITK-Core
   MITK-CoreUI
   MITK-IGT
   MITK-ToF
   MITK-DTI
   MITK-Registration
   MITK-Modules # all modules not contained in a specific subproject
   MITK-Plugins # all plugins not contained in a specific subproject
   MITK-Examples
   Unlabeled # special "subproject" catching all unlabeled targets and tests
   )
 
 # Configure CTestConfigSubProject.cmake that could be used by CTest scripts
 configure_file(${MITK_SOURCE_DIR}/CTestConfigSubProject.cmake.in
                ${MITK_BINARY_DIR}/CTestConfigSubProject.cmake)
                
 if(CTEST_PROJECT_ADDITIONAL_TARGETS)
   # those targets will be executed at the end of the ctest driver script
   # and they also get their own subproject label
   set(subproject_list "${CTEST_PROJECT_SUBPROJECTS};${CTEST_PROJECT_ADDITIONAL_TARGETS}")
 else()
   set(subproject_list "${CTEST_PROJECT_SUBPROJECTS}")
 endif()
 
 # Generate Project.xml file expected by the CTest driver script
 mitkFunctionGenerateProjectXml(${MITK_BINARY_DIR} MITK "${subproject_list}" ${MITK_USE_SUPERBUILD})
 
 #-----------------------------------------------------------------------------
 # Superbuild script
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_SUPERBUILD)
   include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake")
   return()
 endif()
 
 #*****************************************************************************
 #****************************  END OF SUPERBUILD  ****************************
 #*****************************************************************************
 
 #-----------------------------------------------------------------------------
 # CMake function(s) and macro(s)
 #-----------------------------------------------------------------------------
 
 include(CheckCXXSourceCompiles)
 include(mitkFunctionCheckCompilerFlags)
 include(mitkFunctionGetGccVersion)
 include(MacroParseArguments)
 include(mitkFunctionSuppressWarnings) # includes several functions
 include(mitkFunctionOrganizeSources)
 include(mitkFunctionGetVersion)
+include(mitkFunctionGetVersionDescription)
 include(mitkFunctionCreateWindowsBatchScript)
 include(mitkFunctionInstallProvisioningFiles)
 include(mitkFunctionCompileSnippets)
 include(mitkMacroCreateModuleConf)
 include(mitkMacroCreateModule)
 include(mitkMacroCheckModule)
 include(mitkMacroCreateModuleTests)
 include(mitkFunctionAddCustomModuleTest)
 include(mitkMacroUseModule)
 include(mitkMacroMultiplexPicType)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroGenerateToolsLibrary)
 include(mitkMacroGetLinuxDistribution)
 
 #-----------------------------------------------------------------------------
 # Prerequesites
 #-----------------------------------------------------------------------------
 
 find_package(ITK REQUIRED)
 find_package(VTK REQUIRED)
 
 if(ITK_USE_SYSTEM_GDCM)
   find_package(GDCM PATHS ${ITK_GDCM_DIR} REQUIRED)
 endif()
 
 #-----------------------------------------------------------------------------
 # Set MITK specific options and variables (NOT available during superbuild)
 #-----------------------------------------------------------------------------
 
 # ASK THE USER TO SHOW THE CONSOLE WINDOW FOR CoreApp and mitkWorkbench
 option(MITK_SHOW_CONSOLE_WINDOW "Use this to enable or disable the console window when starting MITK GUI Applications" ON)
 mark_as_advanced(MITK_SHOW_CONSOLE_WINDOW)
 
 # TODO: check if necessary
 option(USE_ITKZLIB "Use the ITK zlib for pic compression." ON)
 mark_as_advanced(USE_ITKZLIB)
 
 if(NOT MITK_FAST_TESTING)
   if(DEFINED MITK_CTEST_SCRIPT_MODE 
       AND (MITK_CTEST_SCRIPT_MODE STREQUAL "continuous" OR MITK_CTEST_SCRIPT_MODE STREQUAL "experimental") )
     set(MITK_FAST_TESTING 1)
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # Get MITK version info
 #-----------------------------------------------------------------------------
 
 mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK)
+mitkFunctionGetVersionDescription(${MITK_SOURCE_DIR} MITK)
 
 #-----------------------------------------------------------------------------
 # Installation preparation
 #
 # These should be set before any MITK install macros are used
 #-----------------------------------------------------------------------------
 
 # on Mac OSX all BlueBerry plugins get copied into every
 # application bundle (.app directory) specified here
 if(MITK_USE_BLUEBERRY AND APPLE)
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
 
   foreach(mitk_app ${MITK_APPS})
     # extract option_name
     string(REPLACE "^^" "\\;" target_info ${mitk_app})
     set(target_info_list ${target_info})
     list(GET target_info_list 1 option_name)
     list(GET target_info_list 0 app_name)
     # check if the application is enabled
     if(${option_name} OR MITK_BUILD_ALL_APPS)
       set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} ${app_name})
     endif()
   endforeach()
 
 endif()
 
 #-----------------------------------------------------------------------------
 # Set symbol visibility Flags
 #-----------------------------------------------------------------------------
 
 # MinGW does not export all symbols automatically, so no need to set flags
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT MINGW)
   set(VISIBILITY_CXX_FLAGS ) #"-fvisibility=hidden -fvisibility-inlines-hidden")
 endif()
 
 #-----------------------------------------------------------------------------
 # Set coverage Flags
 #-----------------------------------------------------------------------------
 
 if(WITH_COVERAGE)
   if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     set(coverage_flags "-g -fprofile-arcs -ftest-coverage -O0 -DNDEBUG")
     set(COVERAGE_CXX_FLAGS ${coverage_flags})
     set(COVERAGE_C_FLAGS ${coverage_flags})
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK C/CXX Flags
 #-----------------------------------------------------------------------------
 
 set(MITK_C_FLAGS "${COVERAGE_C_FLAGS} ${ADDITIONAL_C_FLAGS}")
 set(MITK_CXX_FLAGS "${VISIBILITY_CXX_FLAGS} ${COVERAGE_CXX_FLAGS} ${ADDITIONAL_CXX_FLAGS}")
 
 include(mitkSetupC++0xVariables)
 
 set(cflags )
 if(WIN32)
   set(cflags "${cflags} -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN")
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   set(cflags "${cflags} -Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align -Wwrite-strings")
 
   mitkFunctionCheckCompilerFlags("-fdiagnostics-show-option" cflags)
   mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" cflags)
   mitkFunctionCheckCompilerFlags("-Wl,--as-needed" cflags)
 
   if(MITK_USE_C++0x)
     mitkFunctionCheckCompilerFlags("-std=c++0x" MITK_CXX_FLAGS)
   endif()
 
   mitkFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
   # With older version of gcc supporting the flag -fstack-protector-all, an extra dependency to libssp.so
   # is introduced. If gcc is smaller than 4.4.0 and the build type is Release let's not include the flag.
   # Doing so should allow to build package made for distribution using older linux distro.
   if(${GCC_VERSION} VERSION_GREATER "4.4.0" OR (CMAKE_BUILD_TYPE STREQUAL "Debug" AND ${GCC_VERSION} VERSION_LESS "4.4.0"))
     mitkFunctionCheckCompilerFlags("-fstack-protector-all" cflags)
   endif()
   if(MINGW)
     # suppress warnings about auto imported symbols
     set(MITK_CXX_FLAGS "-Wl,--enable-auto-import ${MITK_CXX_FLAGS}")
     # we need to define a Windows version
     set(MITK_CXX_FLAGS "-D_WIN32_WINNT=0x0500 ${MITK_CXX_FLAGS}")
   endif()
 
   #set(MITK_CXX_FLAGS "-Woverloaded-virtual -Wold-style-cast -Wstrict-null-sentinel -Wsign-promo ${MITK_CXX_FLAGS}")
   set(MITK_CXX_FLAGS "-Woverloaded-virtual -Wstrict-null-sentinel ${MITK_CXX_FLAGS}")
   set(MITK_CXX_FLAGS_RELEASE "-D_FORTIFY_SOURCE=2 ${MITK_CXX_FLAGS_RELEASE}")
 
 endif()
 
 set(MITK_C_FLAGS "${cflags} ${MITK_C_FLAGS}")
 set(MITK_CXX_FLAGS "${cflags} ${MITK_CXX_FLAGS}")
 
 #-----------------------------------------------------------------------------
 # MITK Packages
 #-----------------------------------------------------------------------------
 
 set(MITK_MODULES_PACKAGE_DEPENDS_DIR ${MITK_SOURCE_DIR}/CMake/PackageDepends)
 set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
 
 #-----------------------------------------------------------------------------
 # Testing
 #-----------------------------------------------------------------------------
 
 if(BUILD_TESTING)
   enable_testing()
   include(CTest)
   mark_as_advanced(TCL_TCLSH DART_ROOT)
 
   option(MITK_ENABLE_GUI_TESTING OFF "Enable the MITK GUI tests")
 
   # Setup file for setting custom ctest vars
   configure_file(
     CMake/CTestCustom.cmake.in
     ${MITK_BINARY_DIR}/CTestCustom.cmake
     @ONLY
     )
 
   # Configuration for the CMake-generated test driver
   set(CMAKE_TESTDRIVER_EXTRA_INCLUDES "#include <stdexcept>")
   set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "
     try
       {")
   set(CMAKE_TESTDRIVER_AFTER_TESTMAIN "    }
       catch( std::exception & excp )
         {
         fprintf(stderr,\"%s\\n\",excp.what());
         return EXIT_FAILURE;
         }
       catch( ... )
         {
         printf(\"Exception caught in the test driver\\n\");
         return EXIT_FAILURE;
         }
       ")
 
   set(MITK_TEST_OUTPUT_DIR "${MITK_BINARY_DIR}/test_output")
   if(NOT EXISTS ${MITK_TEST_OUTPUT_DIR})
     file(MAKE_DIRECTORY ${MITK_TEST_OUTPUT_DIR})
   endif()
 
   # Test the external project template
   if(MITK_USE_BLUEBERRY)
     include(mitkTestProjectTemplate)
   endif()
 
   # Test the package target
   include(mitkPackageTest)
 endif()
 
 configure_file(mitkTestingConfig.h.in ${MITK_BINARY_DIR}/mitkTestingConfig.h)
 
 #-----------------------------------------------------------------------------
 # MITK_SUPERBUILD_BINARY_DIR
 #-----------------------------------------------------------------------------
 
 # If MITK_SUPERBUILD_BINARY_DIR isn't defined, it means MITK is *NOT* build using Superbuild.
 # In that specific case, MITK_SUPERBUILD_BINARY_DIR should default to MITK_BINARY_DIR
 if(NOT DEFINED MITK_SUPERBUILD_BINARY_DIR)
   set(MITK_SUPERBUILD_BINARY_DIR ${MITK_BINARY_DIR})
 endif()
 
 #-----------------------------------------------------------------------------
 # Compile Utilities and set-up MITK variables
 #-----------------------------------------------------------------------------
 
 include(mitkSetupVariables)
 
   #-----------------------------------------------------------------------------
   # Cleanup
   #-----------------------------------------------------------------------------
 
   file(GLOB _MODULES_CONF_FILES ${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME}/*.cmake)
   if(_MODULES_CONF_FILES)
     file(REMOVE ${_MODULES_CONF_FILES})
   endif()
 
 add_subdirectory(Utilities)
 
 if(MITK_USE_BLUEBERRY)
 
   # We need to hack a little bit because MITK applications may need
   # to enable certain BlueBerry plug-ins. However, these plug-ins
   # are validated separately from the MITK plug-ins and know nothing
   # about potential MITK plug-in dependencies of the applications. Hence
   # we cannot pass the MITK application list to the BlueBerry
   # ctkMacroSetupPlugins call but need to extract the BlueBerry dependencies
   # from the applications and set them explicitly.
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
 
   foreach(mitk_app ${MITK_APPS})
     # extract target_dir and option_name
     string(REPLACE "^^" "\\;" target_info ${mitk_app})
     set(target_info_list ${target_info})
     list(GET target_info_list 0 target_dir)
     list(GET target_info_list 1 option_name)
     # check if the application is enabled and if target_libraries.cmake exists
     if((${option_name} OR MITK_BUILD_ALL_APPS) AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/target_libraries.cmake")
       include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/target_libraries.cmake")
       foreach(_target_dep ${target_libraries})
         if(_target_dep MATCHES org_blueberry_)
           string(REPLACE _ . _app_bb_dep ${_target_dep})
           # explicitly set the build option for the BlueBerry plug-in
           set(BLUEBERRY_BUILD_${_app_bb_dep} ON CACHE BOOL "Build the ${_app_bb_dep} plug-in")
         endif()
       endforeach()
     endif()
   endforeach()
 
   set(mbilog_DIR "${mbilog_BINARY_DIR}")
 
   if(MITK_BUILD_ALL_PLUGINS)
     set(BLUEBERRY_BUILD_ALL_PLUGINS ON)
   endif()
 
   add_subdirectory(BlueBerry)
 
   set(BlueBerry_DIR ${CMAKE_CURRENT_BINARY_DIR}/BlueBerry
       CACHE PATH "The directory containing a CMake configuration file for BlueBerry" FORCE)
 
   include(mitkMacroCreateCTKPlugin)
 
 endif()
 
 #-----------------------------------------------------------------------------
 # Set C/CXX Flags for MITK code
 #-----------------------------------------------------------------------------
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MITK_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${MITK_CXX_FLAGS_RELEASE}")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MITK_C_FLAGS}")
 
 if(MITK_USE_QT)
   add_definitions(-DQWT_DLL)
 endif()
 
 #-----------------------------------------------------------------------------
 # Add custom targets representing CDash subprojects
 #-----------------------------------------------------------------------------
 
 foreach(subproject ${CTEST_PROJECT_SUBPROJECTS})
   if(NOT TARGET ${subproject} AND NOT subproject MATCHES "Unlabeled")
     add_custom_target(${subproject})
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Add subdirectories
 #-----------------------------------------------------------------------------
 
 link_directories(${MITK_LINK_DIRECTORIES})
 
 add_subdirectory(Core)
 add_subdirectory(Modules)
 
 if(MITK_USE_BLUEBERRY)
 
   find_package(BlueBerry REQUIRED)
 
   set(MITK_DEFAULT_SUBPROJECTS MITK-Plugins)
 
   # Plug-in testing (needs some work to be enabled again)
   if(BUILD_TESTING)
     include(berryTestingHelpers)
 
     set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp")
     get_target_property(_is_macosx_bundle CoreApp MACOSX_BUNDLE)
     if(APPLE AND _is_macosx_bundle)
       set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.app/Contents/MacOS/CoreApp")
     endif()
 
     set(BLUEBERRY_TEST_APP_ID "org.mitk.qt.coreapplication")
   endif()
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Plugins/PluginList.cmake")
   set(mitk_plugins_fullpath )
   foreach(mitk_plugin ${MITK_EXT_PLUGINS})
     list(APPEND mitk_plugins_fullpath Plugins/${mitk_plugin})
   endforeach()
 
   if(EXISTS ${MITK_PRIVATE_MODULES}/PluginList.cmake)
     include(${MITK_PRIVATE_MODULES}/PluginList.cmake)
 
     foreach(mitk_plugin ${MITK_PRIVATE_PLUGINS})
       list(APPEND mitk_plugins_fullpath ${MITK_PRIVATE_MODULES}/${mitk_plugin})
     endforeach()
   endif() 
 
   # Specify which plug-ins belong to this project
   macro(GetMyTargetLibraries all_target_libraries varname)
     set(re_ctkplugin_mitk "^org_mitk_[a-zA-Z0-9_]+$")
     set(re_ctkplugin_bb "^org_blueberry_[a-zA-Z0-9_]+$")
     set(_tmp_list)
     list(APPEND _tmp_list ${all_target_libraries})
     ctkMacroListFilter(_tmp_list re_ctkplugin_mitk re_ctkplugin_bb OUTPUT_VARIABLE ${varname})
   endmacro()
 
   # Get infos about application directories and build options
   include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
   set(mitk_apps_fullpath )
   foreach(mitk_app ${MITK_APPS})
     list(APPEND mitk_apps_fullpath "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${mitk_app}")
   endforeach()
 
   ctkMacroSetupPlugins(${mitk_plugins_fullpath}
                        BUILD_OPTION_PREFIX MITK_BUILD_
                        APPS ${mitk_apps_fullpath}
                        BUILD_ALL ${MITK_BUILD_ALL_PLUGINS}
                        COMPACT_OPTIONS)
 
   set(MITK_PLUGIN_USE_FILE "${MITK_BINARY_DIR}/MitkPluginUseFile.cmake")
   if(${PROJECT_NAME}_PLUGIN_LIBRARIES)
     ctkFunctionGeneratePluginUseFile(${MITK_PLUGIN_USE_FILE})
   else()
     file(REMOVE ${MITK_PLUGIN_USE_FILE})
     set(MITK_PLUGIN_USE_FILE )
   endif()
 
 endif()
 
 # Construct a list of paths containing runtime directories
 # for MITK applications on Windows
 set(MITK_RUNTIME_PATH 
     "${VTK_LIBRARY_DIRS}/%VS_BUILD_TYPE%;${ITK_LIBRARY_DIRS}/%VS_BUILD_TYPE%;${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/%VS_BUILD_TYPE%"
     )
 
 if(QT4_FOUND)
   set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${QT_LIBRARY_DIR}/../bin")
 endif()
 
 if(MITK_USE_BLUEBERRY)
   set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CTK_RUNTIME_LIBRARY_DIRS}/%VS_BUILD_TYPE%")
   if(DEFINED CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY)
     if(IS_ABSOLUTE "${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}")
       set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}/%VS_BUILD_TYPE%")
     else()
       set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}/%VS_BUILD_TYPE%")
     endif()
   else()
     set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins/%VS_BUILD_TYPE%")
   endif()
 endif()
 
 if(GDCM_DIR)
   set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${GDCM_DIR}/bin/%VS_BUILD_TYPE%")
 endif()
 
 if(OpenCV_DIR)
   set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${OpenCV_DIR}/bin/%VS_BUILD_TYPE%")
 endif()
 
 # DCMTK is statically build
 #if(DCMTK_DIR)
 #  set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${DCMTK_DIR}/bin/%VS_BUILD_TYPE%")
 #endif()
 
 if(MITK_USE_Boost AND MITK_USE_Boost_LIBRARIES AND NOT MITK_USE_SYSTEM_Boost)
   set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${Boost_LIBRARY_DIRS}")
 endif()
 
 #-----------------------------------------------------------------------------
 # Python Wrapping
 #-----------------------------------------------------------------------------
 
 set(MITK_WRAPPING_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Wrapping)
 set(MITK_WRAPPING_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/Wrapping)
 option(MITK_USE_Python "Build cswig Python wrapper support (requires CableSwig)." OFF)
 if(MITK_USE_Python)
   add_subdirectory(Wrapping)
 endif()
 
 #-----------------------------------------------------------------------------
 # Documentation
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Documentation)
 
 #-----------------------------------------------------------------------------
 # Installation
 #-----------------------------------------------------------------------------
 
 
 # set MITK cpack variables
 # These are the default variables, which can be overwritten ( see below )
 include(mitkSetupCPack)
 
 set(use_default_config ON)
 
 # MITK_APPS is set in Applications/AppList.cmake (included somewhere above
 # if MITK_USE_BLUEBERRY is set to ON).
 if(MITK_APPS)
 
   set(activated_apps_no 0)
   list(LENGTH MITK_APPS app_count)
 
   # Check how many apps have been enabled
   # If more than one app has been activated, the we use the 
   # default CPack configuration. Otherwise that apps configuration
   # will be used, if present.
   foreach(mitk_app ${MITK_APPS})
     # extract option_name
     string(REPLACE "^^" "\\;" target_info ${mitk_app})
     set(target_info_list ${target_info})
     list(GET target_info_list 1 option_name)
     # check if the application is enabled
     if(${option_name} OR MITK_BUILD_ALL_APPS)
       MATH(EXPR activated_apps_no "${activated_apps_no} + 1")
     endif()
   endforeach()
 
   if(app_count EQUAL 1 AND (activated_apps_no EQUAL 1 OR MITK_BUILD_ALL_APPS))
     # Corner case if there is only one app in total
     set(use_project_cpack ON)
   elseif(activated_apps_no EQUAL 1 AND NOT MITK_BUILD_ALL_APPS)
     # Only one app is enabled (no "build all" flag set)
     set(use_project_cpack ON)
   else()
     # Less or more then one app is enabled
     set(use_project_cpack OFF)
   endif()
 
   foreach(mitk_app ${MITK_APPS})
     # extract target_dir and option_name
     string(REPLACE "^^" "\\;" target_info ${mitk_app})
     set(target_info_list ${target_info})
     list(GET target_info_list 0 target_dir)
     list(GET target_info_list 1 option_name)
     # check if the application is enabled
     if(${option_name} OR MITK_BUILD_ALL_APPS)
       # check whether application specific configuration files will be used
       if(use_project_cpack)
         # use files if they exist
         if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake")
           include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake")
         endif()
 
         if(EXISTS "${PROJECT_SOURCE_DIR}/Applications/${target_dir}/CPackConfig.cmake.in")
           set(CPACK_PROJECT_CONFIG_FILE "${PROJECT_BINARY_DIR}/Applications/${target_dir}/CPackConfig.cmake")
           configure_file(${PROJECT_SOURCE_DIR}/Applications/${target_dir}/CPackConfig.cmake.in
                          ${CPACK_PROJECT_CONFIG_FILE} @ONLY)
           set(use_default_config OFF)
         endif()
       endif()
     # add link to the list
     list(APPEND CPACK_CREATE_DESKTOP_LINKS "${target_dir}")
     endif()
   endforeach()
 
 endif()
 
 # if no application specific configuration file was used, use default
 if(use_default_config)
   configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in
                  ${MITK_BINARY_DIR}/MITKCPackOptions.cmake @ONLY)
   set(CPACK_PROJECT_CONFIG_FILE "${MITK_BINARY_DIR}/MITKCPackOptions.cmake")
 endif()
 
 # include CPack model once all variables are set
 include(CPack)
 
 # Additional installation rules
 include(mitkInstallRules)
 
 #-----------------------------------------------------------------------------
 # Last configuration steps
 #-----------------------------------------------------------------------------
 
 set(MITK_EXPORTS_FILE "${MITK_BINARY_DIR}/MitkExports.cmake")
 file(REMOVE ${MITK_EXPORTS_FILE})
 
 if(MITK_USE_BLUEBERRY)
   # This is for installation support of external projects depending on
   # MITK plugins. The export file should not be used for linking to MITK
   # libraries without using LINK_DIRECTORIES, since the exports are incomplete
   # yet(depending libraries are not exported).
   if(MITK_PLUGIN_LIBRARIES)
     export(TARGETS ${MITK_PLUGIN_LIBRARIES}
            APPEND
            FILE ${MITK_EXPORTS_FILE})
   endif()
 endif()
 
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactory.cpp.in
                ${MITK_BINARY_DIR}/ToolExtensionITKFactory.cpp.in COPYONLY)
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactoryLoader.cpp.in
                ${MITK_BINARY_DIR}/ToolExtensionITKFactoryLoader.cpp.in COPYONLY)
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolGUIExtensionITKFactory.cpp.in
                ${MITK_BINARY_DIR}/ToolGUIExtensionITKFactory.cpp.in COPYONLY)
 
 set(VISIBILITY_AVAILABLE 0)
 set(visibility_test_flag "")
 mitkFunctionCheckCompilerFlags("-fvisibility=hidden" visibility_test_flag)
 if(visibility_test_flag)
   # The compiler understands -fvisiblity=hidden (probably gcc >= 4 or Clang)
   set(VISIBILITY_AVAILABLE 1)
 endif()
 configure_file(mitkExportMacros.h.in ${MITK_BINARY_DIR}/mitkExportMacros.h)
 
 configure_file(mitkVersion.h.in ${MITK_BINARY_DIR}/mitkVersion.h)
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 
 set(VECMATH_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/vecmath)
 set(IPFUNC_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipFunc)
 set(UTILITIES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities)
 
 file(GLOB _MODULES_CONF_FILES RELATIVE ${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME} ${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME}/*.cmake)
 set(MITK_MODULE_NAMES)
 foreach(_module ${_MODULES_CONF_FILES})
   string(REPLACE Config.cmake "" _module_name ${_module})
   list(APPEND MITK_MODULE_NAMES ${_module_name})
 endforeach() 
 
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 configure_file(MITKConfig.cmake.in ${MITK_BINARY_DIR}/MITKConfig.cmake @ONLY)
 
 # If we are under Windows, create two batch files which correctly
 # set up the environment for the application and for Visual Studio
 if(WIN32)
   include(mitkFunctionCreateWindowsBatchScript)
   
   set(VS_SOLUTION_FILE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}.sln")
   foreach(VS_BUILD_TYPE debug release)
     mitkFunctionCreateWindowsBatchScript("${MITK_SOURCE_DIR}/CMake/StartVS.bat.in"
       ${PROJECT_BINARY_DIR}/StartVS_${VS_BUILD_TYPE}.bat
       ${VS_BUILD_TYPE})
   endforeach()
 endif(WIN32)
 
 
 #-----------------------------------------------------------------------------
 # MITK Applications
 #-----------------------------------------------------------------------------
 
 # This must come after MITKConfig.h was generated, since applications
 # might do a find_package(MITK REQUIRED).
 add_subdirectory(Applications)
 
 #-----------------------------------------------------------------------------
 # MITK Examples
 #-----------------------------------------------------------------------------
 
 if(MITK_BUILD_EXAMPLES)
   # This must come after MITKConfig.h was generated, since applications
   # might do a find_package(MITK REQUIRED).
   add_subdirectory(Examples)
 endif()
 
diff --git a/Core/Code/Common/mitkCommon.h b/Core/Code/Common/mitkCommon.h
index 42bbcc65d5..3c4dadbc64 100644
--- a/Core/Code/Common/mitkCommon.h
+++ b/Core/Code/Common/mitkCommon.h
@@ -1,122 +1,122 @@
 /*===================================================================
 
 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 MITK_COMMON_H_DEFINED
 #define MITK_COMMON_H_DEFINED
 
 #ifdef _MSC_VER
 // This warns about truncation to 255 characters in debug/browse info
 #pragma warning (disable : 4786)
 #pragma warning (disable : 4068 ) /* disable unknown pragma warnings */
 #endif
 
 //add only those headers here that are really necessary for all classes!
 #include "itkObject.h"
 #include "mitkConfig.h"
 #include "mitkLogMacros.h"
 #include "mitkExportMacros.h"
 #include "mitkExceptionMacro.h"
 
 #ifndef MITK_UNMANGLE_IPPIC
 #define mitkIpPicDescriptor mitkIpPicDescriptor
 #endif
 
 typedef unsigned int MapperSlotId;
 
 #define mitkClassMacro(className,SuperClassName) \
   typedef className        Self; \
   typedef SuperClassName      Superclass; \
   typedef itk::SmartPointer<Self> Pointer; \
   typedef itk::SmartPointer<const Self>  ConstPointer; \
     itkTypeMacro(className,SuperClassName)
 /**
 * Macro for Constructors with one parameter for classes derived from itk::Lightobject
 **/
 #define mitkNewMacro1Param(classname,type) \
 static Pointer New(type _arg) \
 { \
   Pointer smartPtr = new classname ( _arg ); \
   smartPtr->UnRegister(); \
   return smartPtr; \
 } \
 
 /**
 * Macro for Constructors with two parameters for classes derived from itk::Lightobject
 **/
 #define mitkNewMacro2Param(classname,typea,typeb) \
 static Pointer New(typea _arga, typeb _argb) \
 { \
   Pointer smartPtr = new classname ( _arga, _argb ); \
   smartPtr->UnRegister(); \
   return smartPtr; \
 } \
 
 /**
 * Macro for Constructors with three parameters for classes derived from itk::Lightobject
 **/
 #define mitkNewMacro3Param(classname,typea,typeb,typec) \
 static Pointer New(typea _arga, typeb _argb, typec _argc) \
 { \
   Pointer smartPtr = new classname ( _arga, _argb, _argc ); \
   smartPtr->UnRegister(); \
   return smartPtr; \
 } \
 
 /**
 * Macro for Constructors with three parameters for classes derived from itk::Lightobject
 **/
 #define mitkNewMacro4Param(classname,typea,typeb,typec,typed) \
 static Pointer New(typea _arga, typeb _argb, typec _argc, typed _argd) \
 { \
   Pointer smartPtr = new classname ( _arga, _argb, _argc, _argd ); \
   smartPtr->UnRegister(); \
   return smartPtr; \
 } \
 
 
 /** Get a smart const pointer to an object.  Creates the member
  * Get"name"() (e.g., GetPoints()). */
 #define mitkGetObjectMacroConst(name,type) \
   virtual type * Get##name () const \
   { \
     itkDebugMacro("returning " #name " address " << this->m_##name ); \
     return this->m_##name.GetPointer(); \
   }
 
 /** Creates a Clone() method for "Classname". Returns a smartPtr of a clone of the
 calling object*/
 #define mitkCloneMacro(classname) \
   virtual Pointer Clone() const \
 { \
   Pointer smartPtr = new classname(*this); \
   smartPtr->UnRegister(); \
   return smartPtr;  \
 }
 
 /** cross-platform deprecation macro
 
   \todo maybe there is something in external toolkits (ITK, VTK,...) that we could reulse -- would be much preferable
 */
 #ifdef __GNUC__
-  #define DEPRECATED(func) func __attribute__ ((deprecated))
+  #define DEPRECATED(...) __VA_ARGS__ __attribute__ ((deprecated))
 #elif defined(_MSC_VER)
-  #define DEPRECATED(func) __declspec(deprecated) func
+  #define DEPRECATED(...) __declspec(deprecated) ##__VA_ARGS__
 #else
   #pragma message("WARNING: You need to implement DEPRECATED for your compiler!")
   #define DEPRECATED(func) func
 #endif
 
 #endif // MITK_COMMON_H_DEFINED
diff --git a/Core/Code/Common/mitkException.h b/Core/Code/Common/mitkException.h
index 206eecdcdc..d2eca21bdf 100644
--- a/Core/Code/Common/mitkException.h
+++ b/Core/Code/Common/mitkException.h
@@ -1,113 +1,113 @@
 /*===================================================================
 
 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 MITKEXCEPTION_H_INCLUDED
 #define MITKEXCEPTION_H_INCLUDED
 
 #include <MitkExports.h>
 #include <itkExceptionObject.h>
 #include <vector>
 
 namespace mitk {
   /**Documentation
   * \brief   An object of this class represents an exception of MITK.
   *          Please don't instantiate exceptions manually, but use the
   *          exception macros (file mitkExceptionMacro.h) instead.
   *          Simple use in your code is:
   *
   *                  mitkThrow() << "optional exception message";
   *
   *          You can also define specialized exceptions which must inherit
   *          from this class. Please always use the mitkExceptionClassMacro
   *          when implementing specialized exceptions. A simple implementation
   *          can look like:
   *
   *          class MyException : public mitk::Exception
   *             {
   *             public:
   *             mitkExceptionClassMacro(MyException,mitk::Exception);
   *             };
   *
   *          You can then throw your specialized exceptions by using the macro
   *
   *                 mitkThrowException(MyException) << "optional exception message";
   */  
   class MITK_CORE_EXPORT Exception : public itk::ExceptionObject 
   {
   
   public:
     Exception(const char *file, unsigned int lineNumber=0,
                   const char *desc="None", const char *loc="Unknown") :
     itk::ExceptionObject(file,lineNumber,desc,loc){}
     
     virtual ~Exception() throw() {}
 
     itkTypeMacro(ClassName, SuperClassName);
     
     /** \brief Adds rethrow data to this exception. */
     void AddRethrowData(const char *file, unsigned int lineNumber, const char *message);
     
     /** \return Returns how often the exception was rethrown. */
     int GetNumberOfRethrows();
     
     /** @return Returns the rethrow data of the specified rethrow number. Returns empty data, if the rethrowNumber doesn't exist. 
       * @param rethrowNumber The internal number of the rethrow.
       * @param file (returnvalue) This varaiable will be filled with the file of the specified rethrow.
       * @param file (returnvalue) This varaiable will be filled with the line of the specified rethrow.
       * @param file (returnvalue) This varaiable will be filled with the message of the specified rethrow.
       */ 
     void GetRethrowData(int rethrowNumber, std::string &file, int &line, std::string &message);
     
     /** \brief Definition of the bit shift operator for this class.*/
     template <class T> inline Exception& operator<<(const T& data)
     {
       std::stringstream ss;
       ss << this->GetDescription() << data;
       this->SetDescription(ss.str());
       return *this;
     }
 
     /** \brief Definition of the bit shift operator for this class (for non const data).*/
     template <class T> inline Exception& operator<<(T& data)
     {
       std::stringstream ss;
       ss << this->GetDescription() << data;
       this->SetDescription(ss.str());
       return *this;
     }
 
     /** \brief Definition of the bit shift operator for this class (for functions).*/
     inline Exception& operator<<(std::ostream& (*func)(std::ostream&))
     {
       std::stringstream ss;
       ss << this->GetDescription() << func;
       this->SetDescription(ss.str());
       return *this;
     }
   protected:
   
   struct ReThrowData
     {
     std::string RethrowClassname;
-    int RethrowLine;
+    unsigned int RethrowLine;
     std::string RethrowMessage;
     };
    
    std::vector<ReThrowData> m_RethrowData;
    
   };
 } // namespace mitk
 #endif
diff --git a/Core/Code/CppMicroServices/src/module/usModuleContext.cpp b/Core/Code/CppMicroServices/src/module/usModuleContext.cpp
index 463b314f64..2164370632 100644
--- a/Core/Code/CppMicroServices/src/module/usModuleContext.cpp
+++ b/Core/Code/CppMicroServices/src/module/usModuleContext.cpp
@@ -1,136 +1,157 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 #include <usConfig.h>
 
 #include "usModuleContext.h"
 
 #include "usModuleRegistry.h"
 #include "usModulePrivate.h"
 #include "usCoreModuleContext_p.h"
 #include "usServiceRegistry_p.h"
 #include "usServiceReferencePrivate.h"
 
 US_BEGIN_NAMESPACE
 
 class ModuleContextPrivate {
 
 public:
 
   ModuleContextPrivate(ModulePrivate* module)
   : module(module)
   {}
 
   ModulePrivate* module;
 };
 
 
 ModuleContext::ModuleContext(ModulePrivate* module)
   : d(new ModuleContextPrivate(module))
 {}
 
 ModuleContext::~ModuleContext()
 {
   delete d;
 }
 
 Module* ModuleContext::GetModule() const
 {
   return d->module->q;
 }
 
 Module* ModuleContext::GetModule(long id) const
 {
   return ModuleRegistry::GetModule(id);
 }
 
 void ModuleContext::GetModules(std::vector<Module*>& modules) const
 {
   ModuleRegistry::GetModules(modules);
 }
 
 ServiceRegistration ModuleContext::RegisterService(const std::list<std::string>& clazzes,
                                                    US_BASECLASS_NAME* service,
                                                    const ServiceProperties& properties)
 {
   return d->module->coreCtx->services.RegisterService(d->module, clazzes, service, properties);
 }
 
 ServiceRegistration ModuleContext::RegisterService(const char* clazz, US_BASECLASS_NAME* service,
                                                    const ServiceProperties& properties)
 {
   std::list<std::string> clazzes;
   clazzes.push_back(clazz);
   return d->module->coreCtx->services.RegisterService(d->module, clazzes, service, properties);
 }
 
 std::list<ServiceReference> ModuleContext::GetServiceReferences(const std::string& clazz,
                                                                 const std::string& filter)
 {
   std::list<ServiceReference> result;
   d->module->coreCtx->services.Get(clazz, filter, 0, result);
   return result;
 }
 
 ServiceReference ModuleContext::GetServiceReference(const std::string& clazz)
 {
   return d->module->coreCtx->services.Get(d->module, clazz);
 }
 
 US_BASECLASS_NAME* ModuleContext::GetService(const ServiceReference& reference)
 {
   if (!reference)
   {
     throw std::invalid_argument("Default constructed ServiceReference is not a valid input to getService()");
   }
   ServiceReference internalRef(reference);
   return internalRef.d->GetService(d->module->q);
 }
 
 bool ModuleContext::UngetService(const ServiceReference& reference)
 {
   ServiceReference ref = reference;
   return ref.d->UngetService(d->module->q, true);
 }
 
 void ModuleContext::AddServiceListener(const ServiceListener& delegate,
                                        const std::string& filter)
 {
-  d->module->coreCtx->listeners.AddServiceListener(this, delegate, filter);
+  d->module->coreCtx->listeners.AddServiceListener(this, delegate, NULL, filter);
 }
 
 void ModuleContext::RemoveServiceListener(const ServiceListener& delegate)
 {
-  d->module->coreCtx->listeners.RemoveServiceListener(this, delegate);
+  d->module->coreCtx->listeners.RemoveServiceListener(this, delegate, NULL);
 }
 
 void ModuleContext::AddModuleListener(const ModuleListener& delegate)
 {
-  d->module->coreCtx->listeners.AddModuleListener(this, delegate);
+  d->module->coreCtx->listeners.AddModuleListener(this, delegate, NULL);
 }
 
 void ModuleContext::RemoveModuleListener(const ModuleListener& delegate)
 {
-  d->module->coreCtx->listeners.RemoveModuleListener(this, delegate);
+  d->module->coreCtx->listeners.RemoveModuleListener(this, delegate, NULL);
+}
+
+void ModuleContext::AddServiceListener(const ServiceListener& delegate, void* data,
+                                       const std::string &filter)
+{
+  d->module->coreCtx->listeners.AddServiceListener(this, delegate, data, filter);
+}
+
+void ModuleContext::RemoveServiceListener(const ServiceListener& delegate, void* data)
+{
+  d->module->coreCtx->listeners.RemoveServiceListener(this, delegate, data);
+}
+
+void ModuleContext::AddModuleListener(const ModuleListener& delegate, void* data)
+{
+  d->module->coreCtx->listeners.AddModuleListener(this, delegate, data);
+}
+
+void ModuleContext::RemoveModuleListener(const ModuleListener& delegate, void* data)
+{
+  d->module->coreCtx->listeners.RemoveModuleListener(this, delegate, data);
 }
 
 US_END_NAMESPACE
 
diff --git a/Core/Code/CppMicroServices/src/module/usModuleContext.h b/Core/Code/CppMicroServices/src/module/usModuleContext.h
index 63b00ced85..bfd07de872 100644
--- a/Core/Code/CppMicroServices/src/module/usModuleContext.h
+++ b/Core/Code/CppMicroServices/src/module/usModuleContext.h
@@ -1,638 +1,649 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 #ifndef USMODULECONTEXT_H_
 #define USMODULECONTEXT_H_
 
 #include "usUtils_p.h"
 #include "usServiceInterface.h"
 #include "usServiceEvent.h"
 #include "usServiceRegistration.h"
 #include "usServiceException.h"
 #include "usModuleEvent.h"
 
 US_BEGIN_NAMESPACE
 
 typedef US_SERVICE_LISTENER_FUNCTOR ServiceListener;
 typedef US_MODULE_LISTENER_FUNCTOR ModuleListener;
 
 class ModuleContextPrivate;
 
 /**
  * \ingroup MicroServices
  *
  * A module's execution context within the framework. The context is used to
  * grant access to other methods so that this module can interact with the
  * Micro Services Framework.
  *
  * <p>
  * <code>ModuleContext</code> methods allow a module to:
  * <ul>
  * <li>Subscribe to events published by the framework.
  * <li>Register service objects with the framework service registry.
  * <li>Retrieve <code>ServiceReference</code>s from the framework service
  * registry.
  * <li>Get and release service objects for a referenced service.
  * <li>Get the list of modules loaded in the framework.
  * <li>Get the {@link Module} object for a module.
  * </ul>
  *
  * <p>
  * A <code>ModuleContext</code> object will be created and provided to the
  * module associated with this context when it is loaded using the
  * {@link ModuleActivator::Load} method. The same <code>ModuleContext</code>
  * object will be passed to the module associated with this context when it is
  * unloaded using the {@link ModuleActivator::Unload} method. A
  * <code>ModuleContext</code> object is generally for the private use of its
  * associated module and is not meant to be shared with other modules in the
  * module environment.
  *
  * <p>
  * The <code>Module</code> object associated with a <code>ModuleContext</code>
  * object is called the <em>context module</em>.
  *
  * <p>
  * The <code>ModuleContext</code> object is only valid during the execution of
  * its context module; that is, during the period when the context module
  * is loaded. If the <code>ModuleContext</code>
  * object is used subsequently, a <code>std::logic_error</code> is
  * thrown. The <code>ModuleContext</code> object is never reused after
  * its context module is unloaded.
  *
  * <p>
  * The framework is the only entity that can create <code>ModuleContext</code>
  * objects.
  *
  * @remarks This class is thread safe.
  */
 class US_EXPORT ModuleContext
 {
 
 public:
 
   ~ModuleContext();
 
   /**
    * Returns the <code>Module</code> object associated with this
    * <code>ModuleContext</code>. This module is called the context module.
    *
    * @return The <code>Module</code> object associated with this
    *         <code>ModuleContext</code>.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    */
   Module* GetModule() const;
 
   /**
    * Returns the module with the specified identifier.
    *
    * @param id The identifier of the module to retrieve.
    * @return A <code>Module</code> object or <code>0</code> if the
    *         identifier does not match any previously loaded module.
    */
   Module* GetModule(long id) const;
 
 
   /**
    * Returns a list of all known modules.
    * <p>
    * This method returns a list of all modules loaded in the module
    * environment at the time of the call to this method. This list will
    * also contain modules which might already have been unloaded.
    *
    * @param modules A std::vector of <code>Module</code> objects which
    *                will hold one object per known module.
    */
   void GetModules(std::vector<Module*>& modules) const;
 
   /**
    * Registers the specified service object with the specified properties
    * under the specified class names into the framework. A
    * <code>ServiceRegistration</code> object is returned. The
    * <code>ServiceRegistration</code> object is for the private use of the
    * module registering the service and should not be shared with other
    * modules. The registering module is defined to be the context module.
    * Other modules can locate the service by using either the
    * {@link #GetServiceReferences} or {@link #GetServiceReference} method.
    *
    * <p>
    * A module can register a service object that implements the
    * {@link ServiceFactory} interface to have more flexibility in providing
    * service objects to other modules.
    *
    * <p>
    * The following steps are taken when registering a service:
    * <ol>
    * <li>The framework adds the following service properties to the service
    * properties from the specified <code>ServiceProperties</code> (which may be
    * omitted): <br/>
    * A property named ServiceConstants#SERVICE_ID() identifying the
    * registration number of the service <br/>
    * A property named ServiceConstants#OBJECTCLASS() containing all the
    * specified classes. <br/>
    * Properties with these names in the specified <code>ServiceProperties</code> will
    * be ignored.
    * <li>The service is added to the framework service registry and may now be
    * used by other modules.
    * <li>A service event of type {@link ServiceEvent#REGISTERED} is fired.
    * <li>A <code>ServiceRegistration</code> object for this registration is
    * returned.
    * </ol>
    *
    * @param clazzes The class names under which the service can be located.
    *        The class names will be stored in the service's
    *        properties under the key ServiceConstants#OBJECTCLASS().
    * @param service The service object or a <code>ServiceFactory</code>
    *        object.
    * @param properties The properties for this service. The keys in the
    *        properties object must all be <code>std::string</code> objects. See
    *        {@link ServiceConstants} for a list of standard service property keys.
    *        Changes should not be made to this object after calling this
    *        method. To update the service's properties the
    *        {@link ServiceRegistration::SetProperties} method must be called.
    *        The set of properties may be omitted if the service has
    *        no properties.
    * @return A <code>ServiceRegistration</code> object for use by the module
    *         registering the service to update the service's properties or to
    *         unregister the service.
    * @throws std::invalid_argument If one of the following is true:
    *         <ul>
    *         <li><code>service</code> is <code>0</code>.
    *         <li><code>properties</code> contains case variants of the same key name.
    *         </ul>
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @see ServiceRegistration
    * @see ServiceFactory
    */
   ServiceRegistration RegisterService(const std::list<std::string>& clazzes,
                                       US_BASECLASS_NAME* service,
                                       const ServiceProperties& properties = ServiceProperties());
 
   /**
    * Registers the specified service object with the specified properties
    * under the specified class name with the framework.
    *
    * <p>
    * This method is otherwise identical to
    * RegisterService(const std:list&lt;std::string&gt;&, us::Base*, const ServiceProperties&)
    * and is provided as a convenience when <code>service</code> will only be registered under a single
    * class name. Note that even in this case the value of the service's
    * ServiceConstants::OBJECTCLASS property will be a std::list<std::string>, rather
    * than just a single string.
    *
    * @param clazz The class name under which the service can be located.
    * @param service The service object or a ServiceFactory object.
    * @param properties The properties for this service.
    * @return A ServiceRegistration object for use by the module
    *         registering the service to update the service's properties or to
    *         unregister the service.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @see RegisterService(const std:list&lt;std::string&gt;&, us::Base*, const ServiceProperties&)
    */
   ServiceRegistration RegisterService(const char* clazz, US_BASECLASS_NAME* service,
                                       const ServiceProperties& properties = ServiceProperties());
 
   /**
    * Registers the specified service object with the specified properties
    * using the specified template argument with the framework.
    *
    * <p>
    * This method is provided as a convenience when <code>service</code> will only be registered under
    * a single class name whose type is available to the caller. It is otherwise identical to
    * RegisterService(const char*, US_BASECLASS_NAME*, const ServiceProperties&) but should be preferred
    * since it avoids errors in the string literal identifying the class name or interface identifier.
    *
    * @tparam S The type under which the service can be located.
    * @param service The service object or a ServiceFactory object.
    * @param properties The properties for this service.
    * @return A ServiceRegistration object for use by the module
    *         registering the service to update the service's properties or to
    *         unregister the service.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @see RegisterService(const char*, us::Base*, const ServiceProperties&)
    */
   template<class S>
   ServiceRegistration RegisterService(US_BASECLASS_NAME* service, const ServiceProperties& properties = ServiceProperties())
   {
     const char* clazz = us_service_interface_iid<S*>();
     if (clazz == 0)
     {
       throw ServiceException(std::string("The interface class you are registering your service ") +
                              us_service_impl_name(service) + " against has no US_DECLARE_SERVICE_INTERFACE macro");
     }
     return RegisterService(clazz, service, properties);
   }
 
   /**
    * Returns a list of <code>ServiceReference</code> objects. The returned
    * list contains services that
    * were registered under the specified class and match the specified filter
    * expression.
    *
    * <p>
    * The list is valid at the time of the call to this method. However since
    * the Micro Services framework is a very dynamic environment, services can be modified or
    * unregistered at any time.
    *
    * <p>
    * The specified <code>filter</code> expression is used to select the
    * registered services whose service properties contain keys and values
    * which satisfy the filter expression. See LDAPFilter for a description
    * of the filter syntax. If the specified <code>filter</code> is
    * empty, all registered services are considered to match the
    * filter. If the specified <code>filter</code> expression cannot be parsed,
    * an <code>std::invalid_argument</code> will be thrown with a human readable
    * message where the filter became unparsable.
    *
    * <p>
    * The result is a list of <code>ServiceReference</code> objects for all
    * services that meet all of the following conditions:
    * <ul>
    * <li>If the specified class name, <code>clazz</code>, is not
    * empty, the service must have been registered with the
    * specified class name. The complete list of class names with which a
    * service was registered is available from the service's
    * {@link ServiceConstants#OBJECTCLASS() objectClass} property.
    * <li>If the specified <code>filter</code> is not empty, the
    * filter expression must match the service.
    * </ul>
    *
    * @param clazz The class name with which the service was registered or
    *        an empty string for all services.
    * @param filter The filter expression or empty for all
    *        services.
    * @return A list of <code>ServiceReference</code> objects or
    *         an empty list if no services are registered which satisfy the
    *         search.
    * @throws std::invalid_argument If the specified <code>filter</code>
    *         contains an invalid filter expression that cannot be parsed.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    */
   std::list<ServiceReference> GetServiceReferences(const std::string& clazz,
                                                    const std::string& filter = std::string());
 
   /**
    * Returns a list of <code>ServiceReference</code> objects. The returned
    * list contains services that
    * were registered under the interface id of the template argument <code>S</code>
    * and match the specified filter expression.
    *
    * <p>
    * This method is identical to GetServiceReferences(const std::string&, const std::string&) except that
    * the class name for the service object is automatically deduced from the template argument.
    *
    * @tparam S The type under which the requested service objects must have been registered.
    * @param filter The filter expression or empty for all
    *        services.
    * @return A list of <code>ServiceReference</code> objects or
    *         an empty list if no services are registered which satisfy the
    *         search.
    * @throws std::invalid_argument If the specified <code>filter</code>
    *         contains an invalid filter expression that cannot be parsed.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @see GetServiceReferences(const std::string&, const std::string&)
    */
   template<class S>
   std::list<ServiceReference> GetServiceReferences(const std::string& filter = std::string())
   {
     const char* clazz = us_service_interface_iid<S*>();
     if (clazz == 0) throw ServiceException("The service interface class has no US_DECLARE_SERVICE_INTERFACE macro");
     return GetServiceReferences(std::string(clazz), filter);
   }
 
   /**
    * Returns a <code>ServiceReference</code> object for a service that
    * implements and was registered under the specified class.
    *
    * <p>
    * The returned <code>ServiceReference</code> object is valid at the time of
    * the call to this method. However as the Micro Services framework is a very dynamic
    * environment, services can be modified or unregistered at any time.
    *
    * <p>
    * This method is the same as calling
    * {@link ModuleContext::GetServiceReferences(const std::string&, const std::string&)} with an
    * empty filter expression. It is provided as a convenience for
    * when the caller is interested in any service that implements the
    * specified class.
    * <p>
    * If multiple such services exist, the service with the highest ranking (as
    * specified in its ServiceConstants::SERVICE_RANKING() property) is returned.
    * <p>
    * If there is a tie in ranking, the service with the lowest service ID (as
    * specified in its ServiceConstants::SERVICE_ID() property); that is, the
    * service that was registered first is returned.
    *
    * @param clazz The class name with which the service was registered.
    * @return A <code>ServiceReference</code> object, or an invalid <code>ServiceReference</code> if
    *         no services are registered which implement the named class.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @throws ServiceException If no service was registered under the given class name.
    * @see #GetServiceReferences(const std::string&, const std::string&)
    */
   ServiceReference GetServiceReference(const std::string& clazz);
 
   /**
    * Returns a <code>ServiceReference</code> object for a service that
    * implements and was registered under the specified template class argument.
    *
    * <p>
    * This method is identical to GetServiceReference(const std::string&) except that
    * the class name for the service object is automatically deduced from the template argument.
    *
    * @tparam S The type under which the requested service must have been registered.
    * @return A <code>ServiceReference</code> object, or an invalid <code>ServiceReference</code> if
    *         no services are registered which implement the type <code>S</code>.
    * @throws std::logic_error If this ModuleContext is no longer valid.
    * @throws ServiceException It no service was registered under the given class name.
    * @see #GetServiceReference(const std::string&)
    * @see #GetServiceReferences(const std::string&)
    */
   template<class S>
   ServiceReference GetServiceReference()
   {
     const char* clazz = us_service_interface_iid<S*>();
     if (clazz == 0) throw ServiceException("The service interface class has no US_DECLARE_SERVICE_INTERFACE macro");
     return GetServiceReference(std::string(clazz));
   }
 
   /**
    * Returns the service object referenced by the specified
    * <code>ServiceReference</code> object.
    * <p>
    * A module's use of a service is tracked by the module's use count of that
    * service. Each time a service's service object is returned by
    * {@link #GetService(const ServiceReference&)} the context module's use count for
    * that service is incremented by one. Each time the service is released by
    * {@link #UngetService(const ServiceReference&)} the context module's use count
    * for that service is decremented by one.
    * <p>
    * When a module's use count for a service drops to zero, the module should
    * no longer use that service.
    *
    * <p>
    * This method will always return <code>0</code> when the service
    * associated with this <code>reference</code> has been unregistered.
    *
    * <p>
    * The following steps are taken to get the service object:
    * <ol>
    * <li>If the service has been unregistered, <code>0</code> is returned.
    * <li>The context module's use count for this service is incremented by
    * one.
    * <li>If the context module's use count for the service is currently one
    * and the service was registered with an object implementing the
    * <code>ServiceFactory</code> interface, the
    * {@link ServiceFactory::GetService} method is
    * called to create a service object for the context module. This service
    * object is cached by the framework. While the context module's use count
    * for the service is greater than zero, subsequent calls to get the
    * services's service object for the context module will return the cached
    * service object. <br>
    * If the <code>ServiceFactory</code> object throws an
    * exception, <code>0</code> is returned and a warning is logged.
    * <li>The service object for the service is returned.
    * </ol>
    *
    * @param reference A reference to the service.
    * @return A service object for the service associated with
    *         <code>reference</code> or <code>0</code> if the service is not
    *         registered or the <code>ServiceFactory</code> threw
    *         an exception.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @throws std::invalid_argument If the specified
    *         <code>ServiceReference</code> is invalid (default constructed).
    * @see #UngetService(const ServiceReference&)
    * @see ServiceFactory
    */
   US_BASECLASS_NAME* GetService(const ServiceReference& reference);
 
   /**
    * Returns the service object referenced by the specified
    * <code>ServiceReference</code> object.
    * <p>
    * This is a convenience method which is identical to US_BASECLASS_NAME* GetService(const ServiceReference&)
    * except that it casts the service object to the supplied template argument type
    *
    * @tparam S The type the service object will be cast to.
    * @return A service object for the service associated with
    *         <code>reference</code> or <code>0</code> if the service is not
    *         registered, the <code>ServiceFactory</code> threw
    *         an exception or the service could not be casted to the desired type.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @throws std::invalid_argument If the specified
    *         <code>ServiceReference</code> is invalid (default constructed).
    * @see #GetService(const ServiceReference&)
    * @see #UngetService(const ServiceReference&)
    * @see ServiceFactory
    */
   template<class S>
   S* GetService(const ServiceReference& reference)
   {
     return dynamic_cast<S*>(GetService(reference));
   }
 
   /**
    * Releases the service object referenced by the specified
    * <code>ServiceReference</code> object. If the context module's use count
    * for the service is zero, this method returns <code>false</code>.
    * Otherwise, the context modules's use count for the service is decremented
    * by one.
    *
    * <p>
    * The service's service object should no longer be used and all references
    * to it should be destroyed when a module's use count for the service drops
    * to zero.
    *
    * <p>
    * The following steps are taken to unget the service object:
    * <ol>
    * <li>If the context module's use count for the service is zero or the
    * service has been unregistered, <code>false</code> is returned.
    * <li>The context module's use count for this service is decremented by
    * one.
    * <li>If the context module's use count for the service is currently zero
    * and the service was registered with a <code>ServiceFactory</code> object,
    * the ServiceFactory#UngetService
    * method is called to release the service object for the context module.
    * <li><code>true</code> is returned.
    * </ol>
    *
    * @param reference A reference to the service to be released.
    * @return <code>false</code> if the context module's use count for the
    *         service is zero or if the service has been unregistered;
    *         <code>true</code> otherwise.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @see #GetService
    * @see ServiceFactory
    */
   bool UngetService(const ServiceReference& reference);
 
   void AddServiceListener(const ServiceListener& delegate,
                           const std::string& filter = std::string());
   void RemoveServiceListener(const ServiceListener& delegate);
 
   void AddModuleListener(const ModuleListener& delegate);
   void RemoveModuleListener(const ModuleListener& delegate);
 
   /**
    * Adds the specified <code>callback</code> with the
    * specified <code>filter</code> to the context modules's list of listeners.
    * See LDAPFilter for a description of the filter syntax. Listeners
    * are notified when a service has a lifecycle state change.
    *
    * <p>
    * You must take care to remove registered listeners befor the <code>receiver</code>
    * object is destroyed. However, the Micro Services framework takes care
    * of removing all listeners registered by this context module's classes
    * after the module is unloaded.
    *
    * <p>
    * If the context module's list of listeners already contains a pair <code>(r,c)</code>
    * of <code>receiver</code> and <code>callback</code> such that
    * <code>(r == receiver && c == callback)</code>, then this
    * method replaces that callback's filter (which may be empty)
    * with the specified one (which may be empty).
    *
    * <p>
    * The callback is called if the filter criteria is met. To filter based
    * upon the class of the service, the filter should reference the
    * ServiceConstants#OBJECTCLASS() property. If <code>filter</code> is
    * empty, all services are considered to match the filter.
    *
    * <p>
    * When using a <code>filter</code>, it is possible that the
    * <code>ServiceEvent</code>s for the complete lifecycle of a service
    * will not be delivered to the callback. For example, if the
    * <code>filter</code> only matches when the property <code>x</code> has
    * the value <code>1</code>, the callback will not be called if the
    * service is registered with the property <code>x</code> not set to the
    * value <code>1</code>. Subsequently, when the service is modified
    * setting property <code>x</code> to the value <code>1</code>, the
    * filter will match and the callback will be called with a
    * <code>ServiceEvent</code> of type <code>MODIFIED</code>. Thus, the
    * callback will not be called with a <code>ServiceEvent</code> of type
    * <code>REGISTERED</code>.
    *
    * @tparam The type of the receiver (containing the member function to be called)
    * @param receiver The object to connect to.
    * @param callback The member function pointer to call.
    * @param filter The filter criteria.
    * @throws std::invalid_argument If <code>filter</code> contains an
    *         invalid filter string that cannot be parsed.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @see ServiceEvent
    * @see RemoveServiceListener()
    */
   template<class R>
   void AddServiceListener(R* receiver, void(R::*callback)(const ServiceEvent),
                           const std::string& filter = std::string())
   {
-    AddServiceListener(ServiceListenerMemberFunctor(receiver, callback), filter);
+    AddServiceListener(ServiceListenerMemberFunctor(receiver, callback),
+                       static_cast<void*>(receiver), filter);
   }
 
   /**
    * Removes the specified <code>callback</code> from the context module's
    * list of listeners.
    *
    * <p>
    * If the <code>(receiver,callback)</code> pair is not contained in this
    * context module's list of listeners, this method does nothing.
    *
    * @tparam The type of the receiver (containing the member function to be removed)
    * @param receiver The object from which to disconnect.
    * @param callback The member function pointer to remove.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @see AddServiceListener()
    */
   template<class R>
   void RemoveServiceListener(R* receiver, void(R::*callback)(const ServiceEvent))
   {
-    RemoveServiceListener(ServiceListenerMemberFunctor(receiver, callback));
+    RemoveServiceListener(ServiceListenerMemberFunctor(receiver, callback),
+                          static_cast<void*>(receiver));
   }
 
   /**
    * Adds the specified <code>callback</code> to the context modules's list
    * of listeners. Listeners are notified when a module has a lifecycle
    * state change.
    *
    * <p>
    * If the context module's list of listeners already contains a pair <code>(r,c)</code>
    * of <code>receiver</code> and <code>callback</code> such that
    * <code>(r == receiver && c == callback)</code>, then this method does nothing.
    *
    * @tparam The type of the receiver (containing the member function to be called)
    * @param receiver The object to connect to.
    * @param callback The member function pointer to call.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @see ModuleEvent
    */
   template<class R>
   void AddModuleListener(R* receiver, void(R::*callback)(const ModuleEvent))
   {
-    AddModuleListener(ModuleListenerMemberFunctor(receiver, callback));
+    AddModuleListener(ModuleListenerMemberFunctor(receiver, callback),
+                      static_cast<void*>(receiver));
   }
 
   /**
    * Removes the specified <code>callback</code> from the context module's
    * list of listeners.
    *
    * <p>
    * If the <code>(receiver,callback)</code> pair is not contained in this
    * context module's list of listeners, this method does nothing.
    *
    * @tparam The type of the receiver (containing the member function to be removed)
    * @param receiver The object from which to disconnect.
    * @param callback The member function pointer to remove.
    * @throws std::logic_error If this ModuleContext is no
    *         longer valid.
    * @see AddModuleListener()
    */
   template<class R>
   void RemoveModuleListener(R* receiver, void(R::*callback)(const ModuleEvent))
   {
-    RemoveModuleListener(ModuleListenerMemberFunctor(receiver, callback));
+    RemoveModuleListener(ModuleListenerMemberFunctor(receiver, callback),
+                         static_cast<void*>(receiver));
   }
 
 
 private:
 
   friend class Module;
   friend class ModulePrivate;
 
   ModuleContext(ModulePrivate* module);
 
   // purposely not implemented
   ModuleContext(const ModuleContext&);
   ModuleContext& operator=(const ModuleContext&);
 
+  void AddServiceListener(const ServiceListener& delegate, void* data,
+                          const std::string& filter);
+  void RemoveServiceListener(const ServiceListener& delegate, void* data);
+
+  void AddModuleListener(const ModuleListener& delegate, void* data);
+  void RemoveModuleListener(const ModuleListener& delegate, void* data);
+
   ModuleContextPrivate * const d;
 };
 
 US_END_NAMESPACE
 
 #endif /* USMODULECONTEXT_H_ */
diff --git a/Core/Code/CppMicroServices/src/service/usServiceInterface.h b/Core/Code/CppMicroServices/src/service/usServiceInterface.h
index de734d2b95..34bc674a8c 100644
--- a/Core/Code/CppMicroServices/src/service/usServiceInterface.h
+++ b/Core/Code/CppMicroServices/src/service/usServiceInterface.h
@@ -1,55 +1,55 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 
 #ifndef USSERVICEINTERFACE_H
 #define USSERVICEINTERFACE_H
 
 #include <usConfig.h>
 
 template<class T> inline const char* us_service_interface_iid()
 { return 0; }
 
-#if defined(QT_DEBUG) || defined(QT_NODEBUG)
+#if defined(QT_DEBUG) || defined(QT_NO_DEBUG)
 #include <qobject.h>
 
 #define US_DECLARE_SERVICE_INTERFACE(IFace, IId)                                 \
   template<> inline const char* qobject_interface_iid<IFace *>()                 \
   { return IId; }                                                                \
   template<> inline const char* us_service_interface_iid<IFace *>()              \
   { return IId; }                                                                \
   template<> inline IFace *qobject_cast<IFace *>(QObject *object)                \
   { return dynamic_cast<IFace*>(reinterpret_cast<US_BASECLASS_NAME *>((object ? object->qt_metacast(IId) : 0))); } \
   template<> inline IFace *qobject_cast<IFace *>(const QObject *object)          \
   { return dynamic_cast<IFace*>(reinterpret_cast<US_BASECLASS_NAME *>((object ? const_cast<QObject *>(object)->qt_metacast(IId) : 0))); }
 
 #else
 
 #define US_DECLARE_SERVICE_INTERFACE(IFace, IId)                                 \
   template<> inline const char* us_service_interface_iid<IFace *>()              \
   { return IId; }                                                                \
 
 #endif
 
 template<class T> inline const char* us_service_impl_name(T* /*impl*/)
 { return "(unknown implementation)"; }
 
 #endif // USSERVICEINTERFACE_H
diff --git a/Core/Code/CppMicroServices/src/service/usServiceListenerEntry.cpp b/Core/Code/CppMicroServices/src/service/usServiceListenerEntry.cpp
index 681c5d5c02..f7b7262e3e 100644
--- a/Core/Code/CppMicroServices/src/service/usServiceListenerEntry.cpp
+++ b/Core/Code/CppMicroServices/src/service/usServiceListenerEntry.cpp
@@ -1,147 +1,150 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 
 #include "usServiceListenerEntry_p.h"
 
 US_BEGIN_NAMESPACE
 
 class ServiceListenerEntryData : public SharedData
 {
 public:
 
-  ServiceListenerEntryData(Module* mc, const ServiceListenerEntry::ServiceListener& l, const std::string& filter)
-    : mc(mc), listener(l), bRemoved(false), ldap()
+  ServiceListenerEntryData(Module* mc, const ServiceListenerEntry::ServiceListener& l,
+                           void* data, const std::string& filter)
+    : mc(mc), listener(l), data(data), bRemoved(false), ldap()
   {
     if (!filter.empty())
     {
       ldap = LDAPExpr(filter);
     }
   }
 
   ~ServiceListenerEntryData()
   {
 
   }
 
   Module* const mc;
   ServiceListenerEntry::ServiceListener listener;
+  void* data;
   bool bRemoved;
   LDAPExpr ldap;
 
   /**
    * The elements of "simple" filters are cached, for easy lookup.
    *
    * The grammar for simple filters is as follows:
    *
    * <pre>
    * Simple = '(' attr '=' value ')'
    *        | '(' '|' Simple+ ')'
    * </pre>
    * where <code>attr</code> is one of {@link Constants#OBJECTCLASS},
    * {@link Constants#SERVICE_ID} or {@link Constants#SERVICE_PID}, and
    * <code>value</code> must not contain a wildcard character.
    * <p>
    * The index of the vector determines which key the cache is for
    * (see {@link ServiceListenerState#hashedKeys}). For each key, there is
    * a vector pointing out the values which are accepted by this
    * ServiceListenerEntry's filter. This cache is maintained to make
    * it easy to remove this service listener.
    */
   LDAPExpr::LocalCache local_cache;
 
 private:
 
   // purposely not implemented
   ServiceListenerEntryData(const ServiceListenerEntryData&);
   ServiceListenerEntryData& operator=(const ServiceListenerEntryData&);
 };
 
 ServiceListenerEntry::ServiceListenerEntry(const ServiceListenerEntry& other)
   : d(other.d)
 {
 
 }
 
 ServiceListenerEntry::~ServiceListenerEntry()
 {
 
 }
 
 ServiceListenerEntry& ServiceListenerEntry::operator=(const ServiceListenerEntry& other)
 {
   d = other.d;
   return *this;
 }
 
 bool ServiceListenerEntry::operator==(const ServiceListenerEntry& other) const
 {
   return ((d->mc == 0 || other.d->mc == 0) || d->mc == other.d->mc) &&
-      ServiceListenerCompare()(d->listener, other.d->listener);
+      (d->data == other.d->data) && ServiceListenerCompare()(d->listener, other.d->listener);
 }
 
 bool ServiceListenerEntry::operator<(const ServiceListenerEntry& other) const
 {
-  return d->mc < other.d->mc;
+  return (d->mc == other.d->mc) ? (d->data < other.d->data) : (d->mc < other.d->mc);
 }
 
 void ServiceListenerEntry::SetRemoved(bool removed) const
 {
   d->bRemoved = removed;
 }
 
 bool ServiceListenerEntry::IsRemoved() const
 {
   return d->bRemoved;
 }
 
-ServiceListenerEntry::ServiceListenerEntry(Module* mc, const ServiceListener& l, const std::string& filter)
-  : d(new ServiceListenerEntryData(mc, l, filter))
+ServiceListenerEntry::ServiceListenerEntry(Module* mc, const ServiceListener& l,
+                                           void* data, const std::string& filter)
+  : d(new ServiceListenerEntryData(mc, l, data, filter))
 {
 
 }
 
 Module* ServiceListenerEntry::GetModule() const
 {
   return d->mc;
 }
 
 std::string ServiceListenerEntry::GetFilter() const
 {
   return d->ldap.IsNull() ? std::string() : d->ldap.ToString();
 }
 
 LDAPExpr ServiceListenerEntry::GetLDAPExpr() const
 {
   return d->ldap;
 }
 
 LDAPExpr::LocalCache& ServiceListenerEntry::GetLocalCache() const
 {
   return d->local_cache;
 }
 
 void ServiceListenerEntry::CallDelegate(const ServiceEvent& event) const
 {
   d->listener(event);
 }
 
 US_END_NAMESPACE
diff --git a/Core/Code/CppMicroServices/src/service/usServiceListenerEntry_p.h b/Core/Code/CppMicroServices/src/service/usServiceListenerEntry_p.h
index c51f6217fd..fa5618589b 100644
--- a/Core/Code/CppMicroServices/src/service/usServiceListenerEntry_p.h
+++ b/Core/Code/CppMicroServices/src/service/usServiceListenerEntry_p.h
@@ -1,97 +1,97 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 
 #ifndef USSERVICELISTENERENTRY_H
 #define USSERVICELISTENERENTRY_H
 
 #include <usUtils_p.h>
 #include <usModuleContext.h>
 
 #include "usLDAPExpr_p.h"
 
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable:4396)
 #endif
 
 US_BEGIN_NAMESPACE
 
 class Module;
 class ServiceListenerEntryData;
 
 /**
  * Data structure for saving service listener info. Contains
  * the optional service listener filter, in addition to the info
  * in ListenerEntry.
  */
 class ServiceListenerEntry
 {
 
 public:
 
   typedef US_SERVICE_LISTENER_FUNCTOR ServiceListener;
 
   ServiceListenerEntry(const ServiceListenerEntry& other);
   ~ServiceListenerEntry();
   ServiceListenerEntry& operator=(const ServiceListenerEntry& other);
 
   bool operator==(const ServiceListenerEntry& other) const;
 
   bool operator<(const ServiceListenerEntry& other) const;
 
   void SetRemoved(bool removed) const;
   bool IsRemoved() const;
 
-  ServiceListenerEntry(Module* mc, const ServiceListener& l, const std::string& filter = "");
+  ServiceListenerEntry(Module* mc, const ServiceListener& l, void* data, const std::string& filter = "");
 
   Module* GetModule() const;
 
   std::string GetFilter() const;
 
   LDAPExpr GetLDAPExpr() const;
 
   LDAPExpr::LocalCache& GetLocalCache() const;
 
   void CallDelegate(const ServiceEvent& event) const;
 
 private:
 
   US_HASH_FUNCTION_FRIEND(ServiceListenerEntry);
   
   ExplicitlySharedDataPointer<ServiceListenerEntryData> d;
 };
 
 US_END_NAMESPACE
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
 US_HASH_FUNCTION_NAMESPACE_BEGIN
 US_HASH_FUNCTION_BEGIN(US_PREPEND_NAMESPACE(ServiceListenerEntry))
 
 return US_HASH_FUNCTION(const US_PREPEND_NAMESPACE(ServiceListenerEntryData)*, arg.d.ConstData());
 
 US_HASH_FUNCTION_END
 US_HASH_FUNCTION_NAMESPACE_END
 
 #endif // USSERVICELISTENERENTRY_H
diff --git a/Core/Code/CppMicroServices/src/service/usServiceListeners.cpp b/Core/Code/CppMicroServices/src/service/usServiceListeners.cpp
index 76fc5c663f..c9036c83db 100644
--- a/Core/Code/CppMicroServices/src/service/usServiceListeners.cpp
+++ b/Core/Code/CppMicroServices/src/service/usServiceListeners.cpp
@@ -1,289 +1,290 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 #include "usUtils_p.h"
 
 #include "usServiceListeners_p.h"
 #include "usServiceReferencePrivate.h"
 
 #include "usModule.h"
 
 //#include <usLogMacros.h>
 
 US_BEGIN_NAMESPACE
 
 const int ServiceListeners::OBJECTCLASS_IX = 0;
 const int ServiceListeners::SERVICE_ID_IX = 1;
 
 ServiceListeners::ServiceListeners()
 {
   hashedServiceKeys.push_back(ServiceConstants::OBJECTCLASS());
   hashedServiceKeys.push_back(ServiceConstants::SERVICE_ID());
 }
 
 void ServiceListeners::AddServiceListener(ModuleContext* mc, const ServiceListenerEntry::ServiceListener& listener,
-                        const std::string& filter)
+                                          void* data, const std::string& filter)
 {
   MutexLocker lock(mutex);
 
-  ServiceListenerEntry sle(mc->GetModule(), listener, filter);
+  ServiceListenerEntry sle(mc->GetModule(), listener, data, filter);
   if (serviceSet.find(sle) != serviceSet.end())
   {
     RemoveServiceListener_unlocked(sle);
   }
   serviceSet.insert(sle);
   CheckSimple(sle);
 }
 
-void ServiceListeners::RemoveServiceListener(ModuleContext* mc, const ServiceListenerEntry::ServiceListener& listener)
+void ServiceListeners::RemoveServiceListener(ModuleContext* mc, const ServiceListenerEntry::ServiceListener& listener,
+                                             void* data)
 {
-  ServiceListenerEntry entryToRemove(mc->GetModule(), listener);
+  ServiceListenerEntry entryToRemove(mc->GetModule(), listener, data);
 
   MutexLocker lock(mutex);
   RemoveServiceListener_unlocked(entryToRemove);
 }
 
 void ServiceListeners::RemoveServiceListener_unlocked(const ServiceListenerEntry& entryToRemove)
 {
   for (ServiceListenerEntries::iterator it = serviceSet.begin();
        it != serviceSet.end(); ++it)
   {
     if (it->operator ==(entryToRemove))
     {
       it->SetRemoved(true);
       RemoveFromCache(*it);
       serviceSet.erase(it);
       break;
     }
   }
 }
 
-void ServiceListeners::AddModuleListener(ModuleContext* mc, const ModuleListener& listener)
+void ServiceListeners::AddModuleListener(ModuleContext* mc, const ModuleListener& listener, void* data)
 {
   MutexLocker lock(moduleListenerMapMutex);
-  std::list<ModuleListener>& listeners = moduleListenerMap[mc];
-  if (std::find_if(listeners.begin(), listeners.end(), std::bind1st(ModuleListenerCompare(), listener)) == listeners.end())
+  ModuleListenerMap::value_type::second_type& listeners = moduleListenerMap[mc];
+  if (std::find_if(listeners.begin(), listeners.end(), std::bind1st(ModuleListenerCompare(), std::make_pair(listener, data))) == listeners.end())
   {
-    listeners.push_back(listener);
+    listeners.push_back(std::make_pair(listener, data));
   }
 }
 
-void ServiceListeners::RemoveModuleListener(ModuleContext* mc, const ModuleListener& listener)
+void ServiceListeners::RemoveModuleListener(ModuleContext* mc, const ModuleListener& listener, void* data)
 {
   MutexLocker lock(moduleListenerMapMutex);
-  moduleListenerMap[mc].remove_if(std::bind1st(ModuleListenerCompare(), listener));
+  moduleListenerMap[mc].remove_if(std::bind1st(ModuleListenerCompare(), std::make_pair(listener, data)));
 }
 
 void ServiceListeners::ModuleChanged(const ModuleEvent& evt)
 {
   MutexLocker lock(moduleListenerMapMutex);
   for(ModuleListenerMap::iterator i = moduleListenerMap.begin();
       i != moduleListenerMap.end(); ++i)
   {
-    for(std::list<ModuleListener>::iterator j = i->second.begin();
+    for(std::list<std::pair<ModuleListener, void*> >::iterator j = i->second.begin();
         j != i->second.end(); ++j)
     {
-      (*j)(evt);
+      (j->first)(evt);
     }
   }
 }
 
 void ServiceListeners::RemoveAllListeners(ModuleContext* mc)
 {
   {
     MutexLocker lock(mutex);
     for (ServiceListenerEntries::iterator it = serviceSet.begin();
          it != serviceSet.end(); )
     {
 
       if (it->GetModule() == mc->GetModule())
       {
         RemoveFromCache(*it);
         serviceSet.erase(it++);
       }
       else
       {
         ++it;
       }
     }
   }
 
   {
     MutexLocker lock(moduleListenerMapMutex);
     moduleListenerMap.erase(mc);
   }
 }
 
 void ServiceListeners::ServiceChanged(const ServiceListenerEntries& receivers,
                                       const ServiceEvent& evt)
 {
   ServiceListenerEntries matchBefore;
   ServiceChanged(receivers, evt, matchBefore);
 }
 
 void ServiceListeners::ServiceChanged(const ServiceListenerEntries& receivers,
                                       const ServiceEvent& evt,
                                       ServiceListenerEntries& matchBefore)
 {
   ServiceReference sr = evt.GetServiceReference();
   int n = 0;
 
   for (ServiceListenerEntries::const_iterator l = receivers.begin();
        l != receivers.end(); ++l)
   {
     if (!matchBefore.empty())
     {
       matchBefore.erase(*l);
     }
 
     if (!l->IsRemoved())
     {
       try
       {
         ++n;
         l->CallDelegate(evt);
       }
       catch (...)
       {
         US_WARN << "Service listener"
             #ifdef US_MODULE_SUPPORT_ENABLED
                 << " in " << l->GetModule()->GetName()
             #endif
                 << " threw an exception!";
       }
     }
   }
 
   //US_DEBUG << "Notified " << n << " listeners";
 }
 
 void ServiceListeners::GetMatchingServiceListeners(const ServiceReference& sr, ServiceListenerEntries& set,
                                                    bool lockProps)
 {
   MutexLocker lock(mutex);
 
   // Check complicated or empty listener filters
   int n = 0;
   for (std::list<ServiceListenerEntry>::const_iterator sse = complicatedListeners.begin();
        sse != complicatedListeners.end(); ++sse)
   {
     ++n;
     if (sse->GetLDAPExpr().IsNull() ||
         sse->GetLDAPExpr().Evaluate(sr.d->GetProperties(), false))
     {
       set.insert(*sse);
     }
   }
 
   //US_DEBUG << "Added " << set.size() << " out of " << n
   //         << " listeners with complicated filters";
 
   // Check the cache
   const std::list<std::string> c(any_cast<std::list<std::string> >
                                  (sr.d->GetProperty(ServiceConstants::OBJECTCLASS(), lockProps)));
   for (std::list<std::string>::const_iterator objClass = c.begin();
        objClass != c.end(); ++objClass)
   {
     AddToSet(set, OBJECTCLASS_IX, *objClass);
   }
 
   long service_id = any_cast<long>(sr.d->GetProperty(ServiceConstants::SERVICE_ID(), lockProps));
   std::stringstream ss;
   ss << service_id;
   AddToSet(set, SERVICE_ID_IX, ss.str());
 }
 
 void ServiceListeners::RemoveFromCache(const ServiceListenerEntry& sle)
 {
   if (!sle.GetLocalCache().empty())
   {
     for (std::size_t i = 0; i < hashedServiceKeys.size(); ++i)
     {
       CacheType& keymap = cache[i];
       std::vector<std::string>& l = sle.GetLocalCache()[i];
       for (std::vector<std::string>::const_iterator it = l.begin();
            it != l.end(); ++it)
       {
         std::list<ServiceListenerEntry>& sles = keymap[*it];
         sles.remove(sle);
         if (sles.empty())
         {
           keymap.erase(*it);
         }
       }
     }
   }
   else
   {
     complicatedListeners.remove(sle);
   }
 }
 
  void ServiceListeners::CheckSimple(const ServiceListenerEntry& sle) {
    if (sle.GetLDAPExpr().IsNull())
    {
      complicatedListeners.push_back(sle);
    }
    else
    {
      LDAPExpr::LocalCache local_cache;
      if (sle.GetLDAPExpr().IsSimple(hashedServiceKeys, local_cache, false))
      {
        sle.GetLocalCache() = local_cache;
        for (std::size_t i = 0; i < hashedServiceKeys.size(); ++i)
        {
          for (std::vector<std::string>::const_iterator it = local_cache[i].begin();
               it != local_cache[i].end(); ++it)
          {
            std::list<ServiceListenerEntry>& sles = cache[i][*it];
            sles.push_back(sle);
          }
        }
      }
      else
      {
        //US_DEBUG << "Too complicated filter: " << sle.GetFilter();
        complicatedListeners.push_back(sle);
      }
    }
  }
 
 void ServiceListeners::AddToSet(ServiceListenerEntries& set,
                                 int cache_ix, const std::string& val)
 {
   std::list<ServiceListenerEntry>& l = cache[cache_ix][val];
   if (!l.empty())
   {
     //US_DEBUG << hashedServiceKeys[cache_ix] << " matches " << l.size();
 
     for (std::list<ServiceListenerEntry>::const_iterator entry = l.begin();
          entry != l.end(); ++entry)
     {
       set.insert(*entry);
     }
   }
   else
   {
     //US_DEBUG << hashedServiceKeys[cache_ix] << " matches none";
   }
 }
 
 US_END_NAMESPACE
diff --git a/Core/Code/CppMicroServices/src/service/usServiceListeners_p.h b/Core/Code/CppMicroServices/src/service/usServiceListeners_p.h
index 7c7dbbc5c6..771f45bc0c 100644
--- a/Core/Code/CppMicroServices/src/service/usServiceListeners_p.h
+++ b/Core/Code/CppMicroServices/src/service/usServiceListeners_p.h
@@ -1,174 +1,176 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 
 #ifndef USSERVICELISTENERS_H
 #define USSERVICELISTENERS_H
 
 #include <list>
 #include <string>
 #include <set>
 
 #include <usConfig.h>
 
 #include "usServiceListenerEntry_p.h"
 
 US_BEGIN_NAMESPACE
 
 class CoreModuleContext;
 class ModuleContext;
 
 /**
  * Here we handle all listeners that modules have registered.
  *
  */
 class ServiceListeners {
 
 private:
 
   typedef Mutex MutexType;
   typedef MutexLock<MutexType> MutexLocker;
 
 public:
 
   typedef US_MODULE_LISTENER_FUNCTOR ModuleListener;
-  typedef US_UNORDERED_MAP_TYPE<ModuleContext*, std::list<ModuleListener> > ModuleListenerMap;
+  typedef US_UNORDERED_MAP_TYPE<ModuleContext*, std::list<std::pair<ModuleListener,void*> > > ModuleListenerMap;
   ModuleListenerMap moduleListenerMap;
   MutexType moduleListenerMapMutex;
 
   typedef US_UNORDERED_MAP_TYPE<std::string, std::list<ServiceListenerEntry> > CacheType;
   typedef US_UNORDERED_SET_TYPE<ServiceListenerEntry> ServiceListenerEntries;
 
 private:
 
   std::vector<std::string> hashedServiceKeys;
   static const int OBJECTCLASS_IX; // = 0;
   static const int SERVICE_ID_IX; // = 1;
 
   /* Service listeners with complicated or empty filters */
   std::list<ServiceListenerEntry> complicatedListeners;
 
   /* Service listeners with "simple" filters are cached. */
   CacheType cache[2];
 
   ServiceListenerEntries serviceSet;
 
   MutexType mutex;
 
 public:
 
   ServiceListeners();
 
   /**
    * Add a new service listener. If an old one exists, and it has the
    * same owning module, the old listener is removed first.
    *
    * @param mc The module context adding this listener.
    * @param listener The service listener to add.
+   * @param data Additional data to distinguish ServiceListener objects.
    * @param filter An LDAP filter string to check when a service is modified.
    * @exception org.osgi.framework.InvalidSyntaxException
    * If the filter is not a correct LDAP expression.
    */
   void AddServiceListener(ModuleContext* mc, const ServiceListenerEntry::ServiceListener& listener,
-                          const std::string& filter);
+                          void* data, const std::string& filter);
 
   /**
    * Remove service listener from current framework. Silently ignore
    * if listener doesn't exist. If listener is registered more than
    * once remove all instances.
    *
    * @param mc The module context who wants to remove listener.
    * @param listener Object to remove.
+   * @param data Additional data to distinguish ServiceListener objects.
    */
-  void RemoveServiceListener(ModuleContext* mc, const ServiceListenerEntry::ServiceListener& listener);
+  void RemoveServiceListener(ModuleContext* mc, const ServiceListenerEntry::ServiceListener& listener,
+                             void* data);
 
   /**
-   * Add a new service listener.
+   * Add a new module listener.
    *
    * @param mc The module context adding this listener.
-   * @param listener The service listener to add.
-   * @param filter An LDAP filter string to check when a service is modified.
-   * @exception org.osgi.framework.InvalidSyntaxException
-   * If the filter is not a correct LDAP expression.
+   * @param listener The module listener to add.
+   * @param data Additional data to distinguish ModuleListener objects.
    */
-  void AddModuleListener(ModuleContext* mc, const ModuleListener& listener);
+  void AddModuleListener(ModuleContext* mc, const ModuleListener& listener, void* data);
 
   /**
-   * Remove service listener from current framework. Silently ignore
+   * Remove module listener from current framework. Silently ignore
    * if listener doesn't exist.
    *
    * @param mc The module context who wants to remove listener.
    * @param listener Object to remove.
+   * @param data Additional data to distinguish ModuleListener objects.
    */
-  void RemoveModuleListener(ModuleContext* mc, const ModuleListener& listener);
+  void RemoveModuleListener(ModuleContext* mc, const ModuleListener& listener, void* data);
 
   void ModuleChanged(const ModuleEvent& evt);
 
   /**
    * Remove all listener registered by a module in the current framework.
    *
    * @param mc Module context which listeners we want to remove.
    */
   void RemoveAllListeners(ModuleContext* mc);
 
   /**
    * Receive notification that a service has had a change occur in its lifecycle.
    *
    * @see org.osgi.framework.ServiceListener#serviceChanged
    */
   void ServiceChanged(const ServiceListenerEntries& receivers,
                       const ServiceEvent& evt,
                       ServiceListenerEntries& matchBefore);
 
   void ServiceChanged(const ServiceListenerEntries& receivers,
                       const ServiceEvent& evt);
 
   /**
    *
    *
    */
   void GetMatchingServiceListeners(const ServiceReference& sr, ServiceListenerEntries& listeners,
                                    bool lockProps = true);
 
 
 private:
 
   void RemoveServiceListener_unlocked(const ServiceListenerEntry& entryToRemove);
 
   /**
    * Remove all references to a service listener from the service listener
    * cache.
    */
   void RemoveFromCache(const ServiceListenerEntry& sle);
 
   /**
    * Checks if the specified service listener's filter is simple enough
    * to cache.
    */
   void CheckSimple(const ServiceListenerEntry& sle);
 
   void AddToSet(ServiceListenerEntries& set, int cache_ix, const std::string& val);
 
 };
 
 US_END_NAMESPACE
 
 #endif // USSERVICELISTENERS_H
diff --git a/Core/Code/CppMicroServices/src/util/usUtils_p.h b/Core/Code/CppMicroServices/src/util/usUtils_p.h
index 25a4a2d0e4..8a7c93d094 100644
--- a/Core/Code/CppMicroServices/src/util/usUtils_p.h
+++ b/Core/Code/CppMicroServices/src/util/usUtils_p.h
@@ -1,210 +1,213 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 
 #ifndef USUTILS_H
 #define USUTILS_H
 
 #include <usConfig.h>
 
 #include <iostream>
 #include <sstream>
 #include <algorithm>
 
 
 //-------------------------------------------------------------------
 // Logging
 //-------------------------------------------------------------------
 
 US_BEGIN_NAMESPACE
 
 US_EXPORT void message_output(MsgType, const char* buf);
 
 struct LogMsg {
 
   LogMsg(int t, const char* file, int ln, const char* func)
     : type(static_cast<MsgType>(t)), enabled(true), buffer()
   { buffer << "In " << func << " at " << file << ":" << ln << " : "; }
 
   ~LogMsg() { if(enabled) message_output(type, buffer.str().c_str()); }
 
   template<typename T>
   LogMsg& operator<<(T t)
   {
     if (enabled) buffer << t;
     return *this;
   }
 
   LogMsg& operator()(bool flag)
   {
     this->enabled = flag;
     return *this;
   }
 
 private:
 
   MsgType type;
   bool enabled;
   std::stringstream buffer;
 };
 
 struct NoLogMsg {
 
   template<typename T>
   NoLogMsg& operator<<(T)
   {
     return *this;
   }
 
   NoLogMsg& operator()(bool)
   {
     return *this;
   }
 
 };
 
 US_END_NAMESPACE
 
 #if !defined(US_NO_DEBUG_OUTPUT)
   #define US_DEBUG US_PREPEND_NAMESPACE(LogMsg)(0, __FILE__, __LINE__, __FUNCTION__)
 #else
   #define US_DEBUG true ? US_PREPEND_NAMESPACE(NoLogMsg)() : US_PREPEND_NAMESPACE(NoLogMsg)()
 #endif
 
 #if !defined(US_NO_INFO_OUTPUT)
   #define US_INFO US_PREPEND_NAMESPACE(LogMsg)(1, __FILE__, __LINE__, __FUNCTION__)
 #else
   #define US_INFO  true ? US_PREPEND_NAMESPACE(NoLogMsg)() : US_PREPEND_NAMESPACE(NoLogMsg)()
 #endif
 
 #if !defined(US_NO_WARNING_OUTPUT)
   #define US_WARN US_PREPEND_NAMESPACE(LogMsg)(2, __FILE__, __LINE__, __FUNCTION__)
 #else
   #define US_WARN true ? US_PREPEND_NAMESPACE(LogMsg)() : US_PREPEND_NAMESPACE(LogMsg)()
 #endif
 
 #define US_ERROR US_PREPEND_NAMESPACE(LogMsg)(3, __FILE__, __LINE__, __FUNCTION__)
 
 //-------------------------------------------------------------------
 // Error handling
 //-------------------------------------------------------------------
 
 US_BEGIN_NAMESPACE
 
 US_EXPORT std::string GetLastErrorStr();
 
 US_END_NAMESPACE
 
 
 //-------------------------------------------------------------------
 // Functors
 //-------------------------------------------------------------------
 
 #include <usServiceEvent.h>
 #include <usModuleEvent.h>
 
 #if defined(US_USE_CXX11) || defined(__GNUC__)
 
   #ifdef US_USE_CXX11
     #include <functional>
     #define US_MODULE_LISTENER_FUNCTOR std::function<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>
     #define US_SERVICE_LISTENER_FUNCTOR std::function<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>
   #else
     #include <tr1/functional>
     #define US_MODULE_LISTENER_FUNCTOR std::tr1::function<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>
     #define US_SERVICE_LISTENER_FUNCTOR std::tr1::function<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>
   #endif
 
   US_BEGIN_NAMESPACE
     template<class X>
     US_MODULE_LISTENER_FUNCTOR ModuleListenerMemberFunctor(X* x, void (X::*memFn)(const US_PREPEND_NAMESPACE(ModuleEvent)))
     { return std::bind1st(std::mem_fun(memFn), x); }
   US_END_NAMESPACE
 
   US_BEGIN_NAMESPACE
-    struct ModuleListenerCompare : std::binary_function<US_MODULE_LISTENER_FUNCTOR, US_MODULE_LISTENER_FUNCTOR, bool>
+    struct ModuleListenerCompare : std::binary_function<std::pair<US_MODULE_LISTENER_FUNCTOR, void*>,
+                                                        std::pair<US_MODULE_LISTENER_FUNCTOR, void*>, bool>
     {
-      bool operator()(const US_MODULE_LISTENER_FUNCTOR& f1,
-                      const US_MODULE_LISTENER_FUNCTOR& f2) const
+      bool operator()(const std::pair<US_MODULE_LISTENER_FUNCTOR, void*>& p1,
+                      const std::pair<US_MODULE_LISTENER_FUNCTOR, void*>& p2) const
       {
-        return f1.target<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>() == f2.target<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>();
+        return p1.second == p2.second &&
+            p1.first.target<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>() == p2.first.target<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>();
       }
     };
   US_END_NAMESPACE
 
   US_BEGIN_NAMESPACE
     template<class X>
     US_SERVICE_LISTENER_FUNCTOR ServiceListenerMemberFunctor(X* x, void (X::*memFn)(const US_PREPEND_NAMESPACE(ServiceEvent)))
     { return std::bind1st(std::mem_fun(memFn), x); }
   US_END_NAMESPACE
 
   US_BEGIN_NAMESPACE
     struct ServiceListenerCompare : std::binary_function<US_SERVICE_LISTENER_FUNCTOR, US_SERVICE_LISTENER_FUNCTOR, bool>
     {
       bool operator()(const US_SERVICE_LISTENER_FUNCTOR& f1,
                       const US_SERVICE_LISTENER_FUNCTOR& f2) const
       {
         return f1.target<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>() == f2.target<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>();
       }
     };
   US_END_NAMESPACE
 
 #else
 
   #include <usFunctor_p.h>
 
   #define US_MODULE_LISTENER_FUNCTOR US_PREPEND_NAMESPACE(Functor)<const US_PREPEND_NAMESPACE(ModuleEvent)&>
 
   US_BEGIN_NAMESPACE
     template<class X, typename MemFn>
     US_MODULE_LISTENER_FUNCTOR ModuleListenerMemberFunctor(X* x, MemFn memFn)
     { return Functor<const ModuleEvent&>(x, memFn); }
   US_END_NAMESPACE
 
   US_BEGIN_NAMESPACE
-    struct ModuleListenerCompare : std::binary_function<US_MODULE_LISTENER_FUNCTOR, US_MODULE_LISTENER_FUNCTOR, bool>
+    struct ModuleListenerCompare : std::binary_function<std::pair<US_MODULE_LISTENER_FUNCTOR, void*>,
+                                                        std::pair<US_MODULE_LISTENER_FUNCTOR, void*>, bool>
     {
-      bool operator()(const US_MODULE_LISTENER_FUNCTOR& f1,
-                      const US_MODULE_LISTENER_FUNCTOR& f2) const
-      { return f1 == f2; }
+      bool operator()(const std::pair<US_MODULE_LISTENER_FUNCTOR, void*>& p1,
+                      const std::pair<US_MODULE_LISTENER_FUNCTOR, void*>& p2) const
+      { return p1.second == p2.second && p1.first == p2.first; }
     };
   US_END_NAMESPACE
 
   #define US_SERVICE_LISTENER_FUNCTOR US_PREPEND_NAMESPACE(Functor)<const US_PREPEND_NAMESPACE(ServiceEvent)&>
 
   US_BEGIN_NAMESPACE
     template<class X, typename MemFn>
     US_SERVICE_LISTENER_FUNCTOR ServiceListenerMemberFunctor(X* x, MemFn memFn)
     { return Functor<const ServiceEvent&>(x, memFn); }
   US_END_NAMESPACE
 
   US_BEGIN_NAMESPACE
     struct ServiceListenerCompare : std::binary_function<US_SERVICE_LISTENER_FUNCTOR, US_SERVICE_LISTENER_FUNCTOR, bool>
     {
       bool operator()(const US_SERVICE_LISTENER_FUNCTOR& f1,
                       const US_SERVICE_LISTENER_FUNCTOR& f2) const
       { return f1 == f2; }
     };
   US_END_NAMESPACE
 
 #endif
 
 #endif // USUTILS_H
diff --git a/Core/Code/CppMicroServices/test/usModuleTest.cpp b/Core/Code/CppMicroServices/test/usModuleTest.cpp
index e448a4d5f4..93a0438a90 100644
--- a/Core/Code/CppMicroServices/test/usModuleTest.cpp
+++ b/Core/Code/CppMicroServices/test/usModuleTest.cpp
@@ -1,382 +1,441 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 #include <usModule.h>
 #include <usModuleEvent.h>
 #include <usServiceEvent.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usModuleRegistry.h>
 #include <usModuleActivator.h>
 
 #include US_BASECLASS_HEADER
 
 #include "usTestUtilSharedLibrary.cpp"
 #include "usTestingMacros.h"
 
 US_USE_NAMESPACE
 
 extern ModuleActivator* _us_module_activator_instance_TestModuleA();
 
 class TestModuleListener {
 
 public:
 
   TestModuleListener(ModuleContext* mc) : mc(mc), serviceEvents(), moduleEvents()
   {}
 
   void ModuleChanged(const ModuleEvent event)
   {
     moduleEvents.push_back(event);
     US_DEBUG << "ModuleEvent:" << event;
   }
 
   void ServiceChanged(const ServiceEvent event)
   {
     serviceEvents.push_back(event);
     US_DEBUG << "ServiceEvent:" << event;
   }
 
   ModuleEvent GetModuleEvent() const
   {
     if (moduleEvents.empty())
     {
       return ModuleEvent();
     }
     return moduleEvents.back();
   }
 
   ServiceEvent GetServiceEvent() const
   {
     if (serviceEvents.empty())
     {
       return ServiceEvent();
     }
     return serviceEvents.back();
   }
 
   bool CheckListenerEvents(
       bool pexp, ModuleEvent::Type ptype,
       bool sexp, ServiceEvent::Type stype,
       Module* moduleX, ServiceReference* servX)
   {
     std::vector<ModuleEvent> pEvts;
     std::vector<ServiceEvent> seEvts;
 
     if (pexp) pEvts.push_back(ModuleEvent(ptype, moduleX));
     if (sexp) seEvts.push_back(ServiceEvent(stype, *servX));
 
     return CheckListenerEvents(pEvts, seEvts);
   }
 
   bool CheckListenerEvents(
       const std::vector<ModuleEvent>& pEvts,
       const std::vector<ServiceEvent>& seEvts)
   {
     bool listenState = true; // assume everything will work
 
     if (pEvts.size() != moduleEvents.size())
     {
       listenState = false;
       US_DEBUG << "*** Module event mismatch: expected "
           << pEvts.size() << " event(s), found "
           << moduleEvents.size() << " event(s).";
 
       const std::size_t max = pEvts.size() > moduleEvents.size() ? pEvts.size() : moduleEvents.size();
       for (std::size_t i = 0; i < max; ++i)
       {
         const ModuleEvent& pE = i < pEvts.size() ? pEvts[i] : ModuleEvent();
         const ModuleEvent& pR = i < moduleEvents.size() ? moduleEvents[i] : ModuleEvent();
         US_DEBUG << "    " << pE << " - " << pR;
       }
     }
     else
     {
       for (std::size_t i = 0; i < pEvts.size(); ++i)
       {
         const ModuleEvent& pE = pEvts[i];
         const ModuleEvent& pR = moduleEvents[i];
         if (pE.GetType() != pR.GetType()
           || pE.GetModule() != pR.GetModule())
         {
           listenState = false;
           US_DEBUG << "*** Wrong module event: " << pR << " expected " << pE;
         }
       }
     }
 
     if (seEvts.size() != serviceEvents.size())
     {
       listenState = false;
       US_DEBUG << "*** Service event mismatch: expected "
           << seEvts.size() << " event(s), found "
           << serviceEvents.size() << " event(s).";
 
       const std::size_t max = seEvts.size() > serviceEvents.size()
                       ? seEvts.size() : serviceEvents.size();
       for (std::size_t i = 0; i < max; ++i)
       {
         const ServiceEvent& seE = i < seEvts.size() ? seEvts[i] : ServiceEvent();
         const ServiceEvent& seR = i < serviceEvents.size() ? serviceEvents[i] : ServiceEvent();
         US_DEBUG << "    " << seE << " - " << seR;
       }
     }
     else
     {
       for (std::size_t i = 0; i < seEvts.size(); ++i)
       {
         const ServiceEvent& seE = seEvts[i];
         const ServiceEvent& seR = serviceEvents[i];
         if (seE.GetType() != seR.GetType()
           || (!(seE.GetServiceReference() == seR.GetServiceReference())))
         {
           listenState = false;
           US_DEBUG << "*** Wrong service event: " << seR << " expected " << seE;
         }
       }
     }
 
     moduleEvents.clear();
     serviceEvents.clear();
     return listenState;
   }
 
 private:
 
   ModuleContext* const mc;
 
   std::vector<ServiceEvent> serviceEvents;
   std::vector<ModuleEvent> moduleEvents;
 };
 
+// Verify that the same member function pointers registered as listeners
+// with different receivers works.
+void frame02a()
+{
+  ModuleContext* mc = GetModuleContext();
+
+  TestModuleListener listener1(mc);
+  TestModuleListener listener2(mc);
+
+  try
+  {
+    mc->RemoveModuleListener(&listener1, &TestModuleListener::ModuleChanged);
+    mc->AddModuleListener(&listener1, &TestModuleListener::ModuleChanged);
+    mc->RemoveModuleListener(&listener2, &TestModuleListener::ModuleChanged);
+    mc->AddModuleListener(&listener2, &TestModuleListener::ModuleChanged);
+  }
+  catch (const std::logic_error& ise)
+  {
+    US_TEST_FAILED_MSG( << "module listener registration failed " << ise.what()
+                        << " : frameSL02a:FAIL" );
+  }
+
+  SharedLibraryHandle target("TestModuleA");
+
+  // Start the test target
+  try
+  {
+    target.Load();
+  }
+  catch (const std::exception& e)
+  {
+    US_TEST_FAILED_MSG( << "Failed to load module, got exception: "
+                        << e.what() << " + in frameSL02a:FAIL" );
+  }
+
+#ifdef US_BUILD_SHARED_LIBS
+  Module* moduleA = ModuleRegistry::GetModule("TestModuleA Module");
+  US_TEST_CONDITION_REQUIRED(moduleA != 0, "Test for existing module TestModuleA")
+#endif
+
+  std::vector<ModuleEvent> pEvts;
+#ifdef US_BUILD_SHARED_LIBS
+  pEvts.push_back(ModuleEvent(ModuleEvent::LOADING, moduleA));
+  pEvts.push_back(ModuleEvent(ModuleEvent::LOADED, moduleA));
+#endif
+
+  std::vector<ServiceEvent> seEvts;
+
+  US_TEST_CONDITION(listener1.CheckListenerEvents(pEvts, seEvts), "Check first module listener")
+  US_TEST_CONDITION(listener2.CheckListenerEvents(pEvts, seEvts), "Check second module listener")
+
+  mc->RemoveModuleListener(&listener1, &TestModuleListener::ModuleChanged);
+  mc->RemoveModuleListener(&listener2, &TestModuleListener::ModuleChanged);
+
+  target.Unload();
+}
+
 // Verify information from the ModuleInfo struct
 void frame005a(ModuleContext* mc)
 {
   Module* m = mc->GetModule();
 
   // check expected headers
 
   US_TEST_CONDITION("CppMicroServicesTestDriver" == m->GetName(), "Test module name");
 //  US_DEBUG << "Version: " << m->GetVersion();
   US_TEST_CONDITION(ModuleVersion(0,1,0) == m->GetVersion(), "Test module version")
 }
 
 // Get context id, location and status of the module
 void frame010a(ModuleContext* mc)
 {
   Module* m = mc->GetModule();
 
   long int contextid = m->GetModuleId();
   US_DEBUG << "CONTEXT ID:" << contextid;
 
   std::string location = m->GetLocation();
   US_DEBUG << "LOCATION:" << location;
   US_TEST_CONDITION(!location.empty(), "Test for non-empty module location")
 
   US_TEST_CONDITION(m->IsLoaded(), "Test for loaded flag")
 }
 
 //----------------------------------------------------------------------------
 //Test result of GetService(ServiceReference()). Should throw std::invalid_argument
 void frame018a(ModuleContext* mc)
 {
   try
   {
     US_BASECLASS_NAME* obj = mc->GetService(ServiceReference());
     US_DEBUG << "Got service object = " << us_service_impl_name(obj) << ", expected std::invalid_argument exception";
     US_TEST_FAILED_MSG(<< "Got service object, excpected std::invalid_argument exception")
   }
   catch (const std::invalid_argument& )
   {}
   catch (...)
   {
     US_TEST_FAILED_MSG(<< "Got wrong exception, expected std::invalid_argument")
   }
 }
 
 // Load libA and check that it exists and that the service it registers exists,
 // also check that the expected events occur
 void frame020a(ModuleContext* mc, TestModuleListener& listener, SharedLibraryHandle& libA)
 {
   try
   {
     libA.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
 
 #ifdef US_BUILD_SHARED_LIBS
   Module* moduleA = ModuleRegistry::GetModule("TestModuleA Module");
   US_TEST_CONDITION_REQUIRED(moduleA != 0, "Test for existing module TestModuleA")
 
   US_TEST_CONDITION(moduleA->GetName() == "TestModuleA Module", "Test module name")
 #endif
 
   // Check if libA registered the expected service
   try
   {
     ServiceReference sr1 = mc->GetServiceReference("org.cppmicroservices.TestModuleAService");
     US_BASECLASS_NAME* o1 = mc->GetService(sr1);
     US_TEST_CONDITION(o1 != 0, "Test if service object found");
 
     try
     {
       US_TEST_CONDITION(mc->UngetService(sr1), "Test if Service UnGet returns true");
     }
     catch (const std::logic_error le)
     {
       US_TEST_FAILED_MSG(<< "UnGetService exception: " << le.what())
     }
 
     // check the listeners for events
     std::vector<ModuleEvent> pEvts;
 #ifdef US_BUILD_SHARED_LIBS
     pEvts.push_back(ModuleEvent(ModuleEvent::LOADING, moduleA));
     pEvts.push_back(ModuleEvent(ModuleEvent::LOADED, moduleA));
 #endif
 
     std::vector<ServiceEvent> seEvts;
     seEvts.push_back(ServiceEvent(ServiceEvent::REGISTERED, sr1));
 
     US_TEST_CONDITION(listener.CheckListenerEvents(pEvts, seEvts), "Test for unexpected events");
 
   }
   catch (const ServiceException& /*se*/)
   {
     US_TEST_FAILED_MSG(<< "test module, expected service not found");
   }
 
 #ifdef US_BUILD_SHARED_LIBS
   US_TEST_CONDITION(moduleA->IsLoaded() == true, "Test if loaded correctly");
 #endif
 }
 
 
 // Unload libA and check for correct events
 void frame030b(ModuleContext* mc, TestModuleListener& listener, SharedLibraryHandle& libA)
 {
 #ifdef US_BUILD_SHARED_LIBS
   Module* moduleA = ModuleRegistry::GetModule("TestModuleA Module");
   US_TEST_CONDITION_REQUIRED(moduleA != 0, "Test for non-null module")
 #endif
 
   ServiceReference sr1
       = mc->GetServiceReference("org.cppmicroservices.TestModuleAService");
   US_TEST_CONDITION(sr1, "Test for valid service reference")
 
   try
   {
     libA.Unload();
 #ifdef US_BUILD_SHARED_LIBS
     US_TEST_CONDITION(moduleA->IsLoaded() == false, "Test for unloaded state")
 #endif
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "UnLoad module exception: " << e.what())
   }
 
   std::vector<ModuleEvent> pEvts;
 #ifdef US_BUILD_SHARED_LIBS
   pEvts.push_back(ModuleEvent(ModuleEvent::UNLOADING, moduleA));
   pEvts.push_back(ModuleEvent(ModuleEvent::UNLOADED, moduleA));
 #endif
 
   std::vector<ServiceEvent> seEvts;
   seEvts.push_back(ServiceEvent(ServiceEvent::UNREGISTERING, sr1));
 
   US_TEST_CONDITION(listener.CheckListenerEvents(pEvts, seEvts), "Test for unexpected events");
 }
 
 
 struct LocalListener {
   void ServiceChanged(const ServiceEvent) {}
 };
 
 // Add a service listener with a broken LDAP filter to Get an exception
 void frame045a(ModuleContext* mc)
 {
   LocalListener sListen1;
   std::string brokenFilter = "A broken LDAP filter";
 
   try
   {
     mc->AddServiceListener(&sListen1, &LocalListener::ServiceChanged, brokenFilter);
   }
   catch (const std::invalid_argument& /*ia*/)
   {
     //assertEquals("InvalidSyntaxException.GetFilter should be same as input string", brokenFilter, ise.GetFilter());
   }
   catch (...)
   {
     US_TEST_FAILED_MSG(<< "test module, wrong exception on broken LDAP filter:");
   }
 }
 
 
 int usModuleTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ModuleTest");
 
+  frame02a();
+
   ModuleContext* mc = GetModuleContext();
   TestModuleListener listener(mc);
 
   try
   {
     mc->AddModuleListener(&listener, &TestModuleListener::ModuleChanged);
   }
   catch (const std::logic_error& ise)
   {
     US_TEST_OUTPUT( << "module listener registration failed " << ise.what() );
     throw;
   }
 
   try
   {
     mc->AddServiceListener(&listener, &TestModuleListener::ServiceChanged);
   }
   catch (const std::logic_error& ise)
   {
     US_TEST_OUTPUT( << "service listener registration failed " << ise.what() );
     throw;
   }
 
   frame005a(mc);
   frame010a(mc);
   frame018a(mc);
 
   SharedLibraryHandle libA("TestModuleA"
                              #ifndef US_BUILD_SHARED_LIBS
                                , _us_module_activator_instance_TestModuleA
                              #endif
                                );
   frame020a(mc, listener, libA);
   frame030b(mc, listener, libA);
 
   frame045a(mc);
 
   mc->RemoveModuleListener(&listener, &TestModuleListener::ModuleChanged);
   mc->RemoveServiceListener(&listener, &TestModuleListener::ServiceChanged);
 
   US_TEST_END()
 }
diff --git a/Core/Code/CppMicroServices/test/usServiceListenerTest.cpp b/Core/Code/CppMicroServices/test/usServiceListenerTest.cpp
index 0c6632bb6d..b7730db42a 100644
--- a/Core/Code/CppMicroServices/test/usServiceListenerTest.cpp
+++ b/Core/Code/CppMicroServices/test/usServiceListenerTest.cpp
@@ -1,540 +1,586 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 #include <usConfig.h>
 
 #include <usTestingMacros.h>
 
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 
 #include US_BASECLASS_HEADER
 
 #include <usModulePropsInterface.h>
 
 #include "usTestUtilSharedLibrary.cpp"
 
 US_USE_NAMESPACE
 
 extern ModuleActivator* _us_module_activator_instance_TestModuleA();
 extern ModuleActivator* _us_module_activator_instance_TestModuleA2();
 extern ModuleActivator* _us_module_activator_instance_TestModuleSL1();
 extern ModuleActivator* _us_module_activator_instance_TestModuleSL3();
 extern ModuleActivator* _us_module_activator_instance_TestModuleSL4();
 
 class TestServiceListener
 {
 
 private:
 
   friend bool runLoadUnloadTest(const std::string&, int cnt, SharedLibraryHandle&,
                                 const std::vector<ServiceEvent::Type>&);
 
   const bool checkUsingModules;
   std::vector<ServiceEvent> events;
 
   bool teststatus;
 
   ModuleContext* mc;
 
 public:
 
   TestServiceListener(ModuleContext* mc, bool checkUsingModules = true)
     : checkUsingModules(checkUsingModules), events(), teststatus(true), mc(mc)
   {}
 
   bool getTestStatus() const
   {
     return teststatus;
   }
 
   void clearEvents()
   {
     events.clear();
   }
 
   bool checkEvents(const std::vector<ServiceEvent::Type>& eventTypes)
   {
     if (events.size() != eventTypes.size())
     {
       dumpEvents(eventTypes);
       return false;
     }
 
     for (std::size_t i=0; i < eventTypes.size(); ++i)
     {
       if (eventTypes[i] != events[i].GetType())
       {
         dumpEvents(eventTypes);
         return false;
       }
     }
     return true;
   }
 
   void serviceChanged(const ServiceEvent evt)
   {
     events.push_back(evt);
     US_TEST_OUTPUT( << "ServiceEvent: " << evt );
     if (ServiceEvent::UNREGISTERING == evt.GetType())
     {
       ServiceReference sr = evt.GetServiceReference();
 
       // Validate that no module is marked as using the service
       std::vector<Module*> usingModules;
       sr.GetUsingModules(usingModules);
       if (checkUsingModules && !usingModules.empty())
       {
         teststatus = false;
         printUsingModules(sr, "*** Using modules (unreg) should be empty but is: ");
       }
 
       // Check if the service can be fetched
       US_BASECLASS_NAME* service = mc->GetService(sr);
       sr.GetUsingModules(usingModules);
       // if (UNREGISTERSERVICE_VALID_DURING_UNREGISTERING) {
       // In this mode the service shall be obtainable during
       // unregistration.
       if (service == 0)
       {
         teststatus = false;
         US_TEST_OUTPUT( << "*** Service should be available to ServiceListener "
                           << "while handling unregistering event." );
       }
       US_TEST_OUTPUT( << "Service (unreg): " << us_service_impl_name(service) );
       if (checkUsingModules && usingModules.size() != 1)
       {
         teststatus = false;
         printUsingModules(sr, "*** One using module expected "
                           "(unreg, after getService), found: ");
       }
       else
       {
         printUsingModules(sr, "Using modules (unreg, after getService): ");
       }
       //    } else {
       //      // In this mode the service shall NOT be obtainable during
       //      // unregistration.
       //      if (null!=service) {
       //        teststatus = false;
       //        out.print("*** Service should not be available to ServiceListener "
       //                  +"while handling unregistering event.");
       //      }
       //      if (checkUsingBundles && null!=usingBundles) {
       //        teststatus = false;
       //        printUsingBundles(sr,
       //                          "*** Using bundles (unreg, after getService), "
       //                          +"should be null but is: ");
       //      } else {
       //        printUsingBundles(sr,
       //                          "Using bundles (unreg, after getService): null");
       //      }
       //    }
       mc->UngetService(sr);
 
       // Check that the UNREGISTERING service can not be looked up
       // using the service registry.
       try
       {
         long sid = any_cast<long>(sr.GetProperty(ServiceConstants::SERVICE_ID()));
         std::stringstream ss;
         ss << "(" << ServiceConstants::SERVICE_ID() << "=" << sid << ")";
         std::list<ServiceReference> srs = mc->GetServiceReferences("", ss.str());
         if (srs.empty())
         {
           US_TEST_OUTPUT( << "ServiceReference for UNREGISTERING service is not"
                             " found in the service registry; ok." );
         }
         else
         {
           teststatus = false;
           US_TEST_OUTPUT( << "*** ServiceReference for UNREGISTERING service,"
                             << sr << ", not found in the service registry; fail." );
           US_TEST_OUTPUT( << "Found the following Service references:") ;
           for(std::list<ServiceReference>::const_iterator sr = srs.begin();
               sr != srs.end(); ++sr)
           {
             US_TEST_OUTPUT( << (*sr) );
           }
         }
       }
       catch (const std::exception& e)
       {
         teststatus = false;
         US_TEST_OUTPUT( << "*** Unexpected excpetion when trying to lookup a"
                           " service while it is in state UNREGISTERING: "
                           << e.what() );
       }
     }
   }
 
   void printUsingModules(const ServiceReference& sr, const std::string& caption)
   {
     std::vector<Module*> usingModules;
     sr.GetUsingModules(usingModules);
 
     US_TEST_OUTPUT( << (caption.empty() ? "Using modules: " : caption) );
     for(std::vector<Module*>::const_iterator module = usingModules.begin();
         module != usingModules.end(); ++module)
     {
       US_TEST_OUTPUT( << "  -" << (*module) );
     }
   }
 
   // Print expected and actual service events.
   void dumpEvents(const std::vector<ServiceEvent::Type>& eventTypes)
   {
     std::size_t max = events.size() > eventTypes.size() ? events.size() : eventTypes.size();
     US_TEST_OUTPUT( << "Expected event type --  Actual event" );
     for (std::size_t i=0; i < max; ++i)
     {
       ServiceEvent evt = i < events.size() ? events[i] : ServiceEvent();
       if (i < eventTypes.size())
       {
         US_TEST_OUTPUT( << " " << eventTypes[i] << "--" << evt );
       }
       else
       {
         US_TEST_OUTPUT( << " " << "- NONE - " << "--" << evt );
       }
     }
   }
 
 }; // end of class ServiceListener
 
 bool runLoadUnloadTest(const std::string& name, int cnt, SharedLibraryHandle& target,
                        const std::vector<ServiceEvent::Type>& events)
 {
   bool teststatus = true;
 
   ModuleContext* mc = GetModuleContext();
 
   for (int i = 0; i < cnt && teststatus; ++i)
   {
     TestServiceListener sListen(mc);
     try
     {
       mc->AddServiceListener(&sListen, &TestServiceListener::serviceChanged);
       //mc->AddServiceListener(MessageDelegate1<ServiceListener, const ServiceEvent&>(&sListen, &ServiceListener::serviceChanged));
     }
     catch (const std::logic_error& ise)
     {
       teststatus  = false;
       US_TEST_FAILED_MSG( << "service listener registration failed " << ise.what()
                           << " :" << name << ":FAIL" );
     }
 
     // Start the test target to get a service published.
     try
     {
       target.Load();
     }
     catch (const std::exception& e)
     {
       teststatus  = false;
       US_TEST_FAILED_MSG( << "Failed to load module, got exception: "
                           << e.what() << " + in " << name << ":FAIL" );
     }
 
     // Stop the test target to get a service unpublished.
     try
     {
       target.Unload();
     }
     catch (const std::exception& e)
     {
       teststatus  = false;
       US_TEST_FAILED_MSG( << "Failed to unload module, got exception: "
                           << e.what() << " + in " << name << ":FAIL" );
     }
 
     if (teststatus && !sListen.checkEvents(events))
     {
       teststatus  = false;
       US_TEST_FAILED_MSG( << "Service listener event notification error :"
                           << name << ":FAIL" );
     }
 
     try
     {
       mc->RemoveServiceListener(&sListen, &TestServiceListener::serviceChanged);
       teststatus &= sListen.teststatus;
       sListen.clearEvents();
     }
     catch (const std::logic_error& ise)
     {
       teststatus  = false;
       US_TEST_FAILED_MSG( << "service listener removal failed " << ise.what()
                           << " :" << name << ":FAIL" );
     }
   }
   return teststatus;
 }
 
+void frameSL02a()
+{
+  ModuleContext* mc = GetModuleContext();
+
+  TestServiceListener listener1(mc);
+  TestServiceListener listener2(mc);
+
+  try
+  {
+    mc->RemoveServiceListener(&listener1, &TestServiceListener::serviceChanged);
+    mc->AddServiceListener(&listener1, &TestServiceListener::serviceChanged);
+    mc->RemoveServiceListener(&listener2, &TestServiceListener::serviceChanged);
+    mc->AddServiceListener(&listener2, &TestServiceListener::serviceChanged);
+  }
+  catch (const std::logic_error& ise)
+  {
+    US_TEST_FAILED_MSG( << "service listener registration failed " << ise.what()
+                        << " : frameSL02a:FAIL" );
+  }
+
+  SharedLibraryHandle target("TestModuleA");
+
+  // Start the test target to get a service published.
+  try
+  {
+    target.Load();
+  }
+  catch (const std::exception& e)
+  {
+    US_TEST_FAILED_MSG( << "Failed to load module, got exception: "
+                        << e.what() << " + in frameSL02a:FAIL" );
+  }
+
+  std::vector<ServiceEvent::Type> events;
+  events.push_back(ServiceEvent::REGISTERED);
+
+  US_TEST_CONDITION(listener1.checkEvents(events), "Check first service listener")
+  US_TEST_CONDITION(listener2.checkEvents(events), "Check second service listener")
+
+  mc->RemoveServiceListener(&listener1, &TestServiceListener::serviceChanged);
+  mc->RemoveServiceListener(&listener2, &TestServiceListener::serviceChanged);
+
+  target.Unload();
+}
+
 void frameSL05a()
 {
   std::vector<ServiceEvent::Type> events;
   events.push_back(ServiceEvent::REGISTERED);
   events.push_back(ServiceEvent::UNREGISTERING);
   SharedLibraryHandle libA("TestModuleA"
                              #ifndef US_BUILD_SHARED_LIBS
                                , _us_module_activator_instance_TestModuleA
                              #endif
                                );
   bool testStatus = runLoadUnloadTest("FrameSL05a", 1, libA, events);
   US_TEST_CONDITION(testStatus, "FrameSL05a")
 }
 
 void frameSL10a()
 {
   std::vector<ServiceEvent::Type> events;
   events.push_back(ServiceEvent::REGISTERED);
   events.push_back(ServiceEvent::UNREGISTERING);
   SharedLibraryHandle libA2("TestModuleA2"
                               #ifndef US_BUILD_SHARED_LIBS
                                 , _us_module_activator_instance_TestModuleA2
                               #endif
                                 );
   bool testStatus = runLoadUnloadTest("FrameSL10a", 1, libA2, events);
   US_TEST_CONDITION(testStatus, "FrameSL10a")
 }
 
 void frameSL25a()
 {
   ModuleContext* mc = GetModuleContext();
 
   TestServiceListener sListen(mc, false);
   try
   {
     mc->AddServiceListener(&sListen, &TestServiceListener::serviceChanged);
   }
   catch (const std::logic_error& ise)
   {
     US_TEST_OUTPUT( << "service listener registration failed " << ise.what() );
     throw;
   }
 
   SharedLibraryHandle libSL1("TestModuleSL1"
                                #ifndef US_BUILD_SHARED_LIBS
                                  , _us_module_activator_instance_TestModuleSL1
                                #endif
                                  );
   SharedLibraryHandle libSL3("TestModuleSL3"
                                #ifndef US_BUILD_SHARED_LIBS
                                  , _us_module_activator_instance_TestModuleSL3
                                #endif
                                  );
   SharedLibraryHandle libSL4("TestModuleSL4"
                                #ifndef US_BUILD_SHARED_LIBS
                                  , _us_module_activator_instance_TestModuleSL4
                                #endif
                                  );
 
   std::vector<ServiceEvent::Type> expectedServiceEventTypes;
 
   // Startup
   expectedServiceEventTypes.push_back(ServiceEvent::REGISTERED); // at start of libSL1
   expectedServiceEventTypes.push_back(ServiceEvent::REGISTERED); // FooService at start of libSL4
   expectedServiceEventTypes.push_back(ServiceEvent::REGISTERED); // at start of libSL3
 
   // Stop libSL4
   expectedServiceEventTypes.push_back(ServiceEvent::UNREGISTERING); // FooService at first stop of libSL4
 
   // Shutdown
   expectedServiceEventTypes.push_back(ServiceEvent::UNREGISTERING); // at stop of libSL1
   expectedServiceEventTypes.push_back(ServiceEvent::UNREGISTERING); // at stop of libSL3
 
 
   // Start libModuleTestSL1 to ensure that the Service interface is available.
   try
   {
     US_TEST_OUTPUT( << "Starting libModuleTestSL1: " << libSL1.GetAbsolutePath() );
     libSL1.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_OUTPUT( << "Failed to load module, got exception: " << e.what() );
     throw;
   }
 
   // Start libModuleTestSL4 that will require the serivce interface and publish
   // ctkFooService
   try
   {
     US_TEST_OUTPUT( << "Starting libModuleTestSL4: " << libSL4.GetAbsolutePath() );
     libSL4.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_OUTPUT( << "Failed to load module, got exception: " << e.what() );
     throw;
   }
 
   // Start libModuleTestSL3 that will require the serivce interface and get the service
   try
   {
     US_TEST_OUTPUT( << "Starting libModuleTestSL3: " << libSL3.GetAbsolutePath() );
     libSL3.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_OUTPUT( << "Failed to load module, got exception: " << e.what() );
     throw;
   }
 
   // Check that libSL3 has been notified about the FooService.
   US_TEST_OUTPUT( << "Check that FooService is added to service tracker in libSL3" );
   try
   {
     ServiceReference libSL3SR = mc->GetServiceReference("ActivatorSL3");
     US_BASECLASS_NAME* libSL3Activator = mc->GetService(libSL3SR);
     US_TEST_CONDITION_REQUIRED(libSL3Activator, "ActivatorSL3 service != 0");
 
     ModulePropsInterface* propsInterface = dynamic_cast<ModulePropsInterface*>(libSL3Activator);
     US_TEST_CONDITION_REQUIRED(propsInterface, "Cast to ModulePropsInterface");
 
     ModulePropsInterface::Properties::const_iterator i = propsInterface->GetProperties().find("serviceAdded");
     US_TEST_CONDITION_REQUIRED(i != propsInterface->GetProperties().end(), "Property serviceAdded");
     Any serviceAddedField3 = i->second;
     US_TEST_CONDITION_REQUIRED(!serviceAddedField3.Empty() && any_cast<bool>(serviceAddedField3),
                                  "libSL3 notified about presence of FooService");
     mc->UngetService(libSL3SR);
   }
   catch (const ServiceException& se)
   {
     US_TEST_FAILED_MSG( << "Failed to get service reference:" << se );
   }
 
   // Check that libSL1 has been notified about the FooService.
   US_TEST_OUTPUT( << "Check that FooService is added to service tracker in libSL1" );
   try
   {
     ServiceReference libSL1SR = mc->GetServiceReference("ActivatorSL1");
     US_BASECLASS_NAME* libSL1Activator = mc->GetService(libSL1SR);
     US_TEST_CONDITION_REQUIRED(libSL1Activator, "ActivatorSL1 service != 0");
 
     ModulePropsInterface* propsInterface = dynamic_cast<ModulePropsInterface*>(libSL1Activator);
     US_TEST_CONDITION_REQUIRED(propsInterface, "Cast to ModulePropsInterface");
 
     ModulePropsInterface::Properties::const_iterator i = propsInterface->GetProperties().find("serviceAdded");
     US_TEST_CONDITION_REQUIRED(i != propsInterface->GetProperties().end(), "Property serviceAdded");
     Any serviceAddedField1 = i->second;
     US_TEST_CONDITION_REQUIRED(!serviceAddedField1.Empty() && any_cast<bool>(serviceAddedField1),
                                  "libSL1 notified about presence of FooService");
     mc->UngetService(libSL1SR);
   }
   catch (const ServiceException& se)
   {
     US_TEST_FAILED_MSG( << "Failed to get service reference:" << se );
   }
 
   // Stop the service provider: libSL4
   try
   {
     US_TEST_OUTPUT( << "Stop libSL4: " << libSL4.GetAbsolutePath() );
     libSL4.Unload();
   }
   catch (const std::exception& e)
   {
     US_TEST_OUTPUT( << "Failed to unload module, got exception:" << e.what() );
     throw;
   }
 
   // Check that libSL3 has been notified about the removal of FooService.
   US_TEST_OUTPUT( << "Check that FooService is removed from service tracker in libSL3" );
   try
   {
     ServiceReference libSL3SR = mc->GetServiceReference("ActivatorSL3");
     US_BASECLASS_NAME* libSL3Activator = mc->GetService(libSL3SR);
     US_TEST_CONDITION_REQUIRED(libSL3Activator, "ActivatorSL3 service != 0");
 
     ModulePropsInterface* propsInterface = dynamic_cast<ModulePropsInterface*>(libSL3Activator);
     US_TEST_CONDITION_REQUIRED(propsInterface, "Cast to ModulePropsInterface");
 
     ModulePropsInterface::Properties::const_iterator i = propsInterface->GetProperties().find("serviceRemoved");
     US_TEST_CONDITION_REQUIRED(i != propsInterface->GetProperties().end(), "Property serviceRemoved");
 
     Any serviceRemovedField3 = i->second;
     US_TEST_CONDITION(!serviceRemovedField3.Empty() && any_cast<bool>(serviceRemovedField3),
                         "libSL3 notified about removal of FooService");
     mc->UngetService(libSL3SR);
   }
   catch (const ServiceException& se)
   {
     US_TEST_FAILED_MSG( << "Failed to get service reference:" << se );
   }
 
   // Stop libSL1
   try
   {
     US_TEST_OUTPUT( << "Stop libSL1:" << libSL1.GetAbsolutePath() );
     libSL1.Unload();
   }
   catch (const std::exception& e)
   {
     US_TEST_OUTPUT( << "Failed to unload module got exception" << e.what() );
     throw;
   }
 
   // Stop pSL3
   try
   {
     US_TEST_OUTPUT( << "Stop libSL3:" << libSL3.GetAbsolutePath() );
     libSL3.Unload();
   }
   catch (const std::exception& e)
   {
     US_TEST_OUTPUT( << "Failed to unload module got exception" << e.what() );
     throw;
   }
 
   // Check service events seen by this class
   US_TEST_OUTPUT( << "Checking ServiceEvents(ServiceListener):" );
   if (!sListen.checkEvents(expectedServiceEventTypes))
   {
     US_TEST_FAILED_MSG( << "Service listener event notification error" );
   }
 
   US_TEST_CONDITION_REQUIRED(sListen.getTestStatus(), "Service listener checks");
   try
   {
     mc->RemoveServiceListener(&sListen, &TestServiceListener::serviceChanged);
     sListen.clearEvents();
   }
   catch (const std::logic_error& ise)
   {
     US_TEST_FAILED_MSG( << "service listener removal failed: " << ise.what() );
   }
 
 }
 
 int usServiceListenerTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ServiceListenerTest");
 
+  frameSL02a();
   frameSL05a();
   frameSL10a();
   frameSL25a();
 
   US_TEST_END()
 }
 
diff --git a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtDefaultPerspective.h b/Core/Code/IO/mitkItkLoggingAdapter.cpp
old mode 100755
new mode 100644
similarity index 55%
copy from Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtDefaultPerspective.h
copy to Core/Code/IO/mitkItkLoggingAdapter.cpp
index 48e98aae9f..eb6cd29237
--- a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtDefaultPerspective.h
+++ b/Core/Code/IO/mitkItkLoggingAdapter.cpp
@@ -1,36 +1,37 @@
 /*===================================================================
 
 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 "mitkItkLoggingAdapter.h"
+#include "mitkLogMacros.h"
 
-#ifndef QMITKEXTDEFAULTPERSPECTIVE_H_
-#define QMITKEXTDEFAULTPERSPECTIVE_H_
-
-#include <berryIPerspectiveFactory.h>
-
-class QmitkExtDefaultPerspective : public QObject, public berry::IPerspectiveFactory
+void mitk::ItkLoggingAdapter::Initialize()
 {
-  Q_OBJECT
-  Q_INTERFACES(berry::IPerspectiveFactory)
-  
-public:
+   itk::OutputWindow::SetInstance(mitk::ItkLoggingAdapter::New());
+}
 
-  QmitkExtDefaultPerspective();
+void mitk::ItkLoggingAdapter::DisplayText(const char* s)
+{
+   MITK_INFO("ItkLogging") << s;
+}
 
-  void CreateInitialLayout(berry::IPageLayout::Pointer layout);
+mitk::ItkLoggingAdapter::ItkLoggingAdapter()
+{
+}
 
-};
+mitk::ItkLoggingAdapter::~ItkLoggingAdapter()
+{
+}
 
-#endif /* QMITKEXTDEFAULTPERSPECTIVE_H_ */
diff --git a/Core/Code/IO/mitkItkLoggingAdapter.h b/Core/Code/IO/mitkItkLoggingAdapter.h
new file mode 100644
index 0000000000..3e45955653
--- /dev/null
+++ b/Core/Code/IO/mitkItkLoggingAdapter.h
@@ -0,0 +1,63 @@
+/*===================================================================
+
+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 ItkLoggingAdapter_H_HEADER_INCLUDED
+#define ItkLoggingAdapter_H_HEADER_INCLUDED
+
+#include <MitkExports.h>
+#include <itkOutputWindow.h>
+#include <itkObjectFactory.h>
+
+namespace mitk {
+//##Documentation
+//## @brief Adapter that overwrites the standard itk logging output window and sends the logging messages to the MITK logging instead.
+//## @ingroup IO
+
+// this class is used to send output to stdout and not the itk window
+class MITK_CORE_EXPORT ItkLoggingAdapter : public itk::OutputWindow
+{
+public:
+  typedef ItkLoggingAdapter                Self;
+  typedef itk::SmartPointer<Self>                Pointer;
+  typedef itk::SmartPointer<const Self>          ConstPointer;
+
+  /** Run-time type information (and related methods).   */
+  itkTypeMacro( ItkLoggingAdapter, itk::OutputWindow );
+
+  /** New macro for creation of through a Smart Pointer   */
+  itkNewMacro(ItkLoggingAdapter);
+
+  /** @brief Initializes the logging adapter. Itk logging 
+    *        messages are redirected to MITK logging afterwards. 
+    */
+  static void Initialize();
+  
+  virtual void DisplayText(const char* s);
+
+protected:
+  ItkLoggingAdapter();
+  virtual ~ItkLoggingAdapter();
+
+private:
+  ItkLoggingAdapter(const Self&); //purposely not implemented
+  void operator=(const Self&); //purposely not implemented
+};
+
+
+}
+
+#endif /* mitkItkLoggingAdapter_H_HEADER_INCLUDED */
diff --git a/Core/Code/IO/mitkVtkLoggingAdapter.cpp b/Core/Code/IO/mitkVtkLoggingAdapter.cpp
new file mode 100644
index 0000000000..a642d628f5
--- /dev/null
+++ b/Core/Code/IO/mitkVtkLoggingAdapter.cpp
@@ -0,0 +1,56 @@
+/*===================================================================
+
+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 "mitkVtkLoggingAdapter.h"
+#include "mitkLogMacros.h"
+#include <vtkObjectFactory.h>
+
+namespace mitk
+{
+  vtkStandardNewMacro(VtkLoggingAdapter);
+}
+
+void mitk::VtkLoggingAdapter::Initialize()
+{
+  mitk::VtkLoggingAdapter* vtklog = mitk::VtkLoggingAdapter::New();
+  vtkOutputWindow::SetInstance(vtklog);
+  vtklog->Delete();
+}
+
+void mitk::VtkLoggingAdapter::DisplayText(const char* t)
+{
+  MITK_INFO("VtkText") << t; 
+}
+
+void mitk::VtkLoggingAdapter::DisplayErrorText(const char *t)
+{
+  MITK_ERROR("VtkError") << t;
+}
+
+void mitk::VtkLoggingAdapter::DisplayWarningText(const char *t)
+{
+  MITK_WARN("VtkWarning") << t;
+}
+
+void mitk::VtkLoggingAdapter::DisplayGenericWarningText(const char *t)
+{
+  MITK_WARN("VtkGenericWarning") << t;
+}
+
+void mitk::VtkLoggingAdapter::DisplayDebugText(const char *t)
+{
+  MITK_DEBUG("VtkDebug") << t;
+}
diff --git a/Core/Code/IO/mitkVtkLoggingAdapter.h b/Core/Code/IO/mitkVtkLoggingAdapter.h
new file mode 100644
index 0000000000..ba0b9a8613
--- /dev/null
+++ b/Core/Code/IO/mitkVtkLoggingAdapter.h
@@ -0,0 +1,57 @@
+/*===================================================================
+
+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 VtkLoggingAdapter_H_HEADER_INCLUDED
+#define VtkLoggingAdapter_H_HEADER_INCLUDED
+
+#include <MitkExports.h>
+#include <vtkOutputWindow.h>
+#include <vtkSmartPointer.h>
+
+namespace mitk {
+//##Documentation
+//## @brief Adapter that overwrites the standard vtk logging output window and sends the logging messages to the MITK logging instead.
+//## @ingroup IO
+class MITK_CORE_EXPORT VtkLoggingAdapter : public vtkOutputWindow
+{
+public:
+  
+  static VtkLoggingAdapter* New();
+
+  /** @brief Initializes the logging adapter. Vtk logging 
+    *        messages are redirected to MITK logging afterwards. 
+    */
+  static void Initialize();
+  
+  virtual void DisplayText(const char* t);
+  
+  virtual void DisplayErrorText(const char *t);
+  
+  virtual void DisplayWarningText(const char *t);
+  
+  virtual void DisplayGenericWarningText(const char *t);
+  
+  virtual void DisplayDebugText(const char *t);
+  
+  
+protected:
+
+};
+
+} // namespace mitk
+
+#endif /* VtkLoggingAdapter_H_HEADER_INCLUDED */
diff --git a/Core/Code/Interactions/mitkDisplayVectorInteractor.cpp b/Core/Code/Interactions/mitkDisplayVectorInteractor.cpp
index 909afd859a..2bec3f0dca 100644
--- a/Core/Code/Interactions/mitkDisplayVectorInteractor.cpp
+++ b/Core/Code/Interactions/mitkDisplayVectorInteractor.cpp
@@ -1,148 +1,166 @@
 /*===================================================================
 
 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 "mitkDisplayVectorInteractor.h"
 #include "mitkOperation.h"
 #include "mitkDisplayCoordinateOperation.h"
 #include "mitkDisplayPositionEvent.h"
 #include "mitkUndoController.h"
 #include "mitkStateEvent.h"
 #include "mitkInteractionConst.h"
 #include "mitkAction.h"
 
 void mitk::DisplayVectorInteractor::ExecuteOperation(Operation* itkNotUsed( operation ) )
 {
   /*DisplayCoordinateOperation* dcOperation = static_cast<DisplayCoordinateOperation*>(operation);
   if(dcOperation==NULL) return;
   
   switch(operation->GetOperationType())
   {
   case OpSELECTPOINT:
     m_Sender=dcOperation->GetRenderer();
     m_StartDisplayCoordinate=dcOperation->GetStartDisplayCoordinate();
     m_LastDisplayCoordinate=dcOperation->GetLastDisplayCoordinate();
     m_CurrentDisplayCoordinate=dcOperation->GetCurrentDisplayCoordinate();
 //    MITK_INFO << m_CurrentDisplayCoordinate << std::endl;
     
     MITK_INFO<<"Message from DisplayVectorInteractor.cpp::ExecuteOperation() : "
       << "StartDisplayCoordinate:" <<     m_StartDisplayCoordinate 
       << "LastDisplayCoordinate:" <<      m_LastDisplayCoordinate 
       << "CurrentDisplayCoordinate:" <<   m_CurrentDisplayCoordinate 
       << std::endl;
     
     break;
   }*/
   
 }
 
+float mitk::DisplayVectorInteractor::CanHandleEvent(const StateEvent *stateEvent) const
+{
+  const DisplayPositionEvent* posEvent=dynamic_cast<const DisplayPositionEvent*>(stateEvent->GetEvent());
+  if(posEvent==NULL) return 0.0;
+
+  //StateEvents from "moveNzoom", "alternativePan", "alternativeZoom" interaction pattern. If EventID can be handled by these statemachine patterns return a high value
+  if (stateEvent->GetId() == EIDRIGHTMOUSEBTN || stateEvent->GetId() == EIDMIDDLEMOUSEBTN || stateEvent->GetId() == EIDRIGHTMOUSEBTNANDCTRL ||
+      stateEvent->GetId() == EIDMIDDLEMOUSERELEASE || stateEvent->GetId() == EIDRIGHTMOUSERELEASE || stateEvent->GetId() == EIDRIGHTMOUSEBTNANDMOUSEMOVE ||
+      stateEvent->GetId() == EIDMIDDLEMOUSEBTNANDMOUSEMOVE || stateEvent->GetId() == EIDCTRLANDRIGHTMOUSEBTNANDMOUSEMOVE || stateEvent->GetId() == EIDCTRLANDRIGHTMOUSEBTNRELEASE )
+  {
+    return 0.9;
+  }
+  else
+  {
+    return 0.0;
+  }
+}
+
 bool mitk::DisplayVectorInteractor::ExecuteAction(Action* action, mitk::StateEvent const* stateEvent)
 {
   bool ok=false;
   
   const DisplayPositionEvent* posEvent=dynamic_cast<const DisplayPositionEvent*>(stateEvent->GetEvent());
   if(posEvent==NULL) return false;
 
   int actionId = action->GetActionId();
   //initzoom and initmove is the same!
   if (actionId == AcINITZOOM)
     actionId = AcINITMOVE;
   switch(actionId)
   {
   //case 0:
   //  {
   //    DisplayCoordinateOperation* doOp = new mitk::DisplayCoordinateOperation(OpTEST,  posEvent->GetSender(), posEvent->GetDisplayPosition(), posEvent->GetDisplayPosition(), posEvent->GetDisplayPosition());
   //
   //    //execute the Operation
   //    m_Destination->ExecuteOperation(doOp);
   //    ok = true;
   //    break;
   //  }
   case AcSENDCOORDINATES:
     {
       DisplayCoordinateOperation* doOp = new mitk::DisplayCoordinateOperation(OpSENDCOORDINATES,  posEvent->GetSender(), posEvent->GetDisplayPosition(), posEvent->GetDisplayPosition(), posEvent->GetDisplayPosition());
       m_Destination->ExecuteOperation(doOp);
       ok = true;
       break;
     }
   case AcINITMOVE:
     {
       m_Sender=posEvent->GetSender();
 
       mitk::Vector2D origin = m_Sender->GetDisplayGeometry()->GetOriginInMM();
        double scaleFactorMMPerDisplayUnit = m_Sender->GetDisplayGeometry()->GetScaleFactorMMPerDisplayUnit();
 
       m_StartDisplayCoordinate=posEvent->GetDisplayPosition();
       m_LastDisplayCoordinate=posEvent->GetDisplayPosition();
       m_CurrentDisplayCoordinate=posEvent->GetDisplayPosition();
       m_StartCoordinateInMM=mitk::Point2D( ( origin+m_StartDisplayCoordinate.GetVectorFromOrigin()*scaleFactorMMPerDisplayUnit ).GetDataPointer() );
       ok = true;
       break;
     }
   case AcMOVE:
     {
       DisplayCoordinateOperation* doOp = new DisplayCoordinateOperation(OpMOVE,  m_Sender, m_StartDisplayCoordinate, m_CurrentDisplayCoordinate, posEvent->GetDisplayPosition());
       //make Operation
       m_LastDisplayCoordinate=m_CurrentDisplayCoordinate;
       m_CurrentDisplayCoordinate=posEvent->GetDisplayPosition();
       
       //execute the Operation
       m_Destination->ExecuteOperation(doOp);
       ok = true;
       break;
     }
   case AcFINISHMOVE:
     {     
       ok = true;
       break;
     }
   case AcZOOM:
     {
       DisplayCoordinateOperation* doOp = new DisplayCoordinateOperation(OpZOOM,  m_Sender, m_StartDisplayCoordinate, m_LastDisplayCoordinate, posEvent->GetDisplayPosition(),m_StartCoordinateInMM);
             
       //make Operation
       m_LastDisplayCoordinate=m_CurrentDisplayCoordinate;
       m_CurrentDisplayCoordinate=posEvent->GetDisplayPosition();
       //MITK_INFO << m_CurrentDisplayCoordinate << std::endl;
       
       //execute the Operation
       m_Destination->ExecuteOperation(doOp);
       ok = true;
       break;
     }
   default:
     ok = false;
     break;
   }
   return ok;
 }
 
 mitk::DisplayVectorInteractor::DisplayVectorInteractor(const char * type, mitk::OperationActor* destination)
   : mitk::StateMachine(type), m_Sender(NULL), m_Destination(destination)
 {
   m_StartDisplayCoordinate.Fill(0);
   m_LastDisplayCoordinate.Fill(0);
   m_CurrentDisplayCoordinate.Fill(0);
 
   if(m_Destination==NULL)
     m_Destination=this;
 }
 
 
 mitk::DisplayVectorInteractor::~DisplayVectorInteractor()
 {
 }
 
diff --git a/Core/Code/Interactions/mitkDisplayVectorInteractor.h b/Core/Code/Interactions/mitkDisplayVectorInteractor.h
index 2facfac41c..7c829e0a09 100644
--- a/Core/Code/Interactions/mitkDisplayVectorInteractor.h
+++ b/Core/Code/Interactions/mitkDisplayVectorInteractor.h
@@ -1,79 +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.
 
 ===================================================================*/
 
 
 #ifndef MITKDISPLAYVECTORINTERACTOR_H_HEADER_INCLUDED_C10DC4EB
 #define MITKDISPLAYVECTORINTERACTOR_H_HEADER_INCLUDED_C10DC4EB
 
 #include <MitkExports.h>
 #include "mitkBaseRenderer.h"
 #include "mitkStateMachine.h"
 
 namespace mitk {
 
   class Operation;
   class OperationActor;
 
   /**
   *@brief Interactor for displaying different slices in orthogonal views.
   * This includes the interaction of Zooming and Panning.
   * @ingroup Interaction
   **/
   class MITK_CORE_EXPORT DisplayVectorInteractor : public StateMachine
   {
   public:
     mitkClassMacro(DisplayVectorInteractor, StateMachine);
     mitkNewMacro2Param(Self, const char*, OperationActor*);
 
     /**
     * @brief Method derived from OperationActor to recieve and execute operations
     **/
     virtual void ExecuteOperation(Operation* operation);
 
+    /**
+     * @brief Method that returns how well this event can be handled by the DisplayVectorInteractor
+     *        a right click into a 2D renderwindow can be handled very well!
+     **/
+    float CanHandleEvent(const StateEvent *stateEvent) const;
+
   protected:
     /**
     * @brief Default Constructor
     **/
     DisplayVectorInteractor(const char * type, mitk::OperationActor* destination=NULL);
     
     /**
     * @brief Default Destructor
     **/
     virtual ~DisplayVectorInteractor();
     
     /**
     * @brief Method derived from StateMachine to implement the own actions
     **/
     virtual bool ExecuteAction(Action* action, mitk::StateEvent const* stateEvent);
 
   private:
     BaseRenderer::Pointer m_Sender;
 
     mitk::Point2D m_StartDisplayCoordinate;
     mitk::Point2D m_LastDisplayCoordinate;
     mitk::Point2D m_CurrentDisplayCoordinate;
     mitk::Point2D m_StartCoordinateInMM;
 
     OperationActor* m_Destination;
   };
 
 } // namespace mitk
 
 
 
 #endif /* MITKDISPLAYVECTORINTERACTOR_H_HEADER_INCLUDED_C10DC4EB */
 
 
diff --git a/Core/Code/Interactions/mitkGlobalInteraction.cpp b/Core/Code/Interactions/mitkGlobalInteraction.cpp
index a73ccb5d74..3389c4461a 100755
--- a/Core/Code/Interactions/mitkGlobalInteraction.cpp
+++ b/Core/Code/Interactions/mitkGlobalInteraction.cpp
@@ -1,457 +1,510 @@
 /*===================================================================
 
 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 "mitkGlobalInteraction.h"
 #include "mitkInteractionConst.h"
 #include "mitkStateEvent.h"
 #include "mitkPositionEvent.h"
 
 #include <itksys/SystemTools.hxx>
 
 #include <vtkWorldPointPicker.h>
 
 
 
 mitk::GlobalInteraction::GlobalInteraction()
 : StateMachine(NULL)
 , m_StateMachineFactory(NULL)
 , m_EventMapper(NULL)
 , m_CurrentlyInInformListenersLoop(false)
 , m_CurrentlyInInformInteractorsLoop(false)
 , m_IsInitialized(false)
+, m_EventNotificationPolicy(INFORM_MULTIPLE)
 {
 }
 
 mitk::GlobalInteraction::~GlobalInteraction()
 {
   //s_GlobalInteraction doesn't have to be set = NULL;
 
   
 
   // StateMachineFactory and EventMapper have to be deleted explicitly, as they inherit from Vtk
   if (this->IsInitialized())
   {
     m_StateMachineFactory->Delete();
     m_StateMachineFactory = NULL;
     m_EventMapper->Delete();
     m_EventMapper = NULL;
   }
   m_ListenerList.clear();
   m_InteractorList.clear();
   m_SelectedList.clear();
-  m_JurisdictionMap.clear();
+  m_InteractorRelevanceMap.clear();
+  m_ListenerRelevanceMap.clear();
   m_FocusManager = NULL;
 }
 
 
 inline mitk::StateEvent* GenerateEmptyStateEvent(int eventId)
 {
   mitk::Event *noEvent = new mitk::Event(NULL,
     mitk::Type_User,
     mitk::BS_NoButton,
     mitk::BS_NoButton,
     mitk::Key_none);
   mitk::StateEvent *stateEvent = new mitk::StateEvent(eventId, noEvent);
   return stateEvent;
 }
 
 
 void mitk::GlobalInteraction::AddListener(mitk::StateMachine* listener)
 {
   if(listener == NULL) return;
   if(dynamic_cast<Interactor*>(listener)!=NULL)
   {
     MITK_WARN << "Trying to add an Interactor ("
       << listener->GetNameOfClass() << ") as a listener. "
       << "This will probably cause problems";
   }
 
   if ( std::find(m_ListenerList.begin(), m_ListenerList.end(),listener) == m_ListenerList.end() )
   {
     m_ListenerList.push_back(listener);
   }
 }
 
 
 bool mitk::GlobalInteraction::RemoveListener(mitk::StateMachine* listener)
 {
   // Defers removal to a time after the current event handling is finished. Otherwise the implementation of InformListeners would crash sometimes.
   m_ListenersFlaggedForRemoval.push_back(listener);
 
   StateMachineListIter position = std::find(m_ListenerList.begin(), m_ListenerList.end(),listener);
   bool removePossible = (position != m_ListenerList.end());
 
   RemoveFlaggedListeners();
 
+  //check if in RelevanceMap
+  for (StateMachineMapIter it = m_ListenerRelevanceMap.begin(); it != m_ListenerRelevanceMap.end(); it++)
+  {
+    if ((*it).second == listener)
+    {
+      m_ListenerRelevanceMap.erase(it);
+      break;
+    }
+  }
+
   return removePossible;
 }
 
 void mitk::GlobalInteraction::RemoveFlaggedListeners()
 {
   if (m_CurrentlyInInformListenersLoop) return;
 
   // iterate flagged listeners, remove them if possible
   if (m_ListenersFlaggedForRemoval.empty()) return;
 
   for (StateMachineCPointerListIter it = m_ListenersFlaggedForRemoval.begin(); it != m_ListenersFlaggedForRemoval.end(); ++it)
   {
     StateMachineListIter foundPosition = std::find( m_ListenerList.begin(), m_ListenerList.end(), *it );
     if (foundPosition != m_ListenerList.end())
     {
       m_ListenerList.erase( foundPosition );
     }
   }
 
   m_ListenersFlaggedForRemoval.clear();
 }
 
 void mitk::GlobalInteraction::AddInteractor(mitk::Interactor* interactor)
 {
   if(interactor == NULL) return;
   if ( std::find(m_InteractorList.begin(), m_InteractorList.end(),interactor) == m_InteractorList.end() )
   {
     m_InteractorList.push_back(interactor);
 
     //if Interactor already selected, then add to selected list
     if (interactor->GetMode()==Interactor::SMSELECTED)
       this->AddToSelectedInteractors(interactor);
   }
 }
 
 bool mitk::GlobalInteraction::InteractorRegistered (mitk::Interactor* interactor)
 {
   if ( std::find(m_InteractorList.begin(), m_InteractorList.end(), interactor) == m_InteractorList.end() )
     return false;
   else
     return true;
 }
 
 bool mitk::GlobalInteraction::ListenerRegistered (mitk::StateMachine* listener)
 {
   if ( std::find(m_ListenerList.begin(), m_ListenerList.end(), listener) == m_ListenerList.end() )
     return false;
   else
     return true;
 }
 
 bool mitk::GlobalInteraction::RemoveInteractor(mitk::Interactor* interactor)
 {
   InteractorListIter position = std::find(m_InteractorList.begin(), m_InteractorList.end(),interactor);
   if (position == m_InteractorList.end())
     return false;
   position = m_InteractorList.erase(position);
 
   //check if the interactor is also held in SelectedList
   this->RemoveFromSelectedInteractors(interactor);  
 
-  //check if in JurisdictionMap
-  for (InteractorMapIter it = m_JurisdictionMap.begin(); it != m_JurisdictionMap.end(); it++)
+  //check if in RelevanceMap
+  for (InteractorMapIter it = m_InteractorRelevanceMap.begin(); it != m_InteractorRelevanceMap.end(); it++)
   {
     if ((*it).second == interactor)
     {
       if (m_CurrentInteractorIter == it)
-        m_CurrentInteractorIter = m_JurisdictionMap.end();
-      m_JurisdictionMap.erase(it);
+        m_CurrentInteractorIter = m_InteractorRelevanceMap.end();
+      m_InteractorRelevanceMap.erase(it);
       break;
     }
   }
 
   return true;
 }
 
 void mitk::GlobalInteraction::InformListeners(mitk::StateEvent const* stateEvent)
 {
   m_CurrentlyInInformListenersLoop = true;
 
   for (StateMachineListIter it = m_ListenerList.begin(); it != m_ListenerList.end(); it++)
   {
     if((*it).IsNotNull())
       (*it)->HandleEvent(stateEvent);
   }
 
   m_CurrentlyInInformListenersLoop = false;
   RemoveFlaggedListeners();
 }
 
 bool mitk::GlobalInteraction::AskSelected(mitk::StateEvent const* stateEvent)
 {
   if (m_SelectedList.empty())
     return false;
 
   bool ok = false, oneOk = false;
 
   //copy of m_SelectedList to be stable if an iterator gets removed during the following steps
   InteractorList copyOfSelectedList = m_SelectedList;
   InteractorListIter it = copyOfSelectedList.begin();
 
   for (; it != copyOfSelectedList.end(); it++)
   {
     oneOk = (*it)->HandleEvent(stateEvent);
 
     //if one HandleEvent did succeed, then set returnvalue on true;
     if (oneOk)
       ok = true;
   }
   return ok;
 }
 
 
-void mitk::GlobalInteraction::FillJurisdictionMap(mitk::StateEvent const* stateEvent, float threshold)
+void mitk::GlobalInteraction::FillInteractorRelevanceMap(mitk::StateEvent const* stateEvent, float threshold)
 {
-  m_JurisdictionMap.clear();
+  m_InteractorRelevanceMap.clear();
 
   for (InteractorListIter it = m_InteractorList.begin(); it != m_InteractorList.end(); it++)
   {
     if ((*it).IsNotNull())
     {
       //first ask for CanHandleEvent(..) and write it into the map if > 0
       float value = (*it)->CanHandleEvent(stateEvent);
       if (value > threshold)
       {
-        m_JurisdictionMap.insert(InteractorMap::value_type(value, (*it)));
+        m_InteractorRelevanceMap.insert(InteractorMap::value_type(value, (*it)));
       }
     }
   }
   //set the iterator to the first element to start stepping through interactors
-  if (! m_JurisdictionMap.empty())
-    m_CurrentInteractorIter = m_JurisdictionMap.begin();
+  if (! m_InteractorRelevanceMap.empty())
+    m_CurrentInteractorIter = m_InteractorRelevanceMap.begin();
   else
-    m_CurrentInteractorIter = m_JurisdictionMap.end();
+    m_CurrentInteractorIter = m_InteractorRelevanceMap.end();
+}
+
+void mitk::GlobalInteraction::FillListenerRelevanceMap(const mitk::StateEvent *stateEvent, float threshold)
+{
+  m_ListenerRelevanceMap.clear();
+
+  for (StateMachineListIter it = m_ListenerList.begin(); it != m_ListenerList.end(); it++)
+  {
+    if((*it).IsNotNull())
+    {
+      float value = (*it)->CanHandleEvent(stateEvent);
+      if (value > threshold)
+      {
+        m_ListenerRelevanceMap.insert(StateMachineMap::value_type(value, (*it)));
+      }
+    }
+  }
 }
 
 /*
 * Go through the list of interactors, that could possibly handle an event and ask if it has handled the event.
 * If an interactor has handled an event, it should add itself to the list of selectedInteractors
 * Ask as long as no interactor answers, that it could be handled
 */
 bool mitk::GlobalInteraction::AskCurrentInteractor(mitk::StateEvent const* stateEvent)
 {
-  //no need to check if we don't have any interactors. nearly equal to m_CurrentInteractorIter == m_JurisdictionMap.end
-  if (m_JurisdictionMap.empty())
+  //no need to check if we don't have any interactors. nearly equal to m_CurrentInteractorIter == m_InteractorRelevanceMap.end
+  if (m_InteractorRelevanceMap.empty())
     return false;
 
   bool handled = false;
-  while ( m_CurrentInteractorIter != m_JurisdictionMap.end()&& !handled)
+  while ( m_CurrentInteractorIter != m_InteractorRelevanceMap.end()&& !handled)
   {
     handled = (*m_CurrentInteractorIter).second->HandleEvent(stateEvent);
 
     if (!handled) 
       m_CurrentInteractorIter++;
   }
 
   //loop for later usage
-  if (m_CurrentInteractorIter == m_JurisdictionMap.end())
-    m_CurrentInteractorIter = m_JurisdictionMap.begin();
+  if (m_CurrentInteractorIter == m_InteractorRelevanceMap.end())
+    m_CurrentInteractorIter = m_InteractorRelevanceMap.begin();
   return handled;
 }
 
 bool mitk::GlobalInteraction::AddFocusElement(mitk::FocusManager::FocusElement* element)
 {
   return m_FocusManager->AddElement(element);
 }
 
 bool mitk::GlobalInteraction::RemoveFocusElement(mitk::FocusManager::FocusElement* element)
 {
   return m_FocusManager->RemoveElement(element);
 }
 
 mitk::FocusManager::FocusElement* mitk::GlobalInteraction::GetFocus()
 {
   return m_FocusManager->GetFocused();
 }
 
 bool mitk::GlobalInteraction::SetFocus(mitk::FocusManager::FocusElement* element)
 {
   return m_FocusManager->SetFocused(element);
 }
 
 mitk::FocusManager* mitk::GlobalInteraction::GetFocusManager()
 {
   return m_FocusManager.GetPointer();
 }
 
 mitk::EventMapper* mitk::GlobalInteraction::GetEventMapper()
 {
   if (!this->IsInitialized())
   {
     MITK_FATAL <<"Global Interaction needs initialization!\n";
     return NULL;
   }
   return m_EventMapper;
 }
 
 
 bool mitk::GlobalInteraction::ExecuteAction(Action* action, mitk::StateEvent const* stateEvent)
 {
   bool ok = false;
 
   ok = false;
   switch (action->GetActionId())
   {
   case AcDONOTHING:
     ok = true;
     break;
   case AcINFORMLISTENERS:
-    InformListeners(stateEvent);
-    ok = true;
-    break;
+    if (m_EventNotificationPolicy == INFORM_MULTIPLE)
+    {
+      InformListeners(stateEvent);
+      ok = true;
+      break;
+    }
+    else
+    {
+      //0.5 since this is the default value which is returned by the superclass implementation of statemachine
+      this->FillListenerRelevanceMap(stateEvent, 0.5);
+      if (!m_ListenerRelevanceMap.empty())
+      {
+        StateMachineMapIter iter = m_ListenerRelevanceMap.begin();
+        ok = (*iter).second->HandleEvent(stateEvent);
+      }
+      break;
+    }
   case AcASKINTERACTORS:
     if (! AskSelected(stateEvent))//no interactor selected anymore
     {
-      //fill the jurisdictionMap to ask them bit by bit.
+      //fill the RelevanceMap to ask them bit by bit.
       //currentInteractor is set here to the beginning
-      FillJurisdictionMap(stateEvent, 0);
+      FillInteractorRelevanceMap(stateEvent, 0);
 
       //ask the Interactors to handle that event
       AskCurrentInteractor(stateEvent);
     }
     ok = true;
     break;
   default:
     ok = true;
   }
   return ok;
 }
 
 
 mitk::GlobalInteraction* mitk::GlobalInteraction::GetInstance()
 {
   static mitk::GlobalInteraction::Pointer s_GlobalInteraction;
 
   if (s_GlobalInteraction.IsNull())
   {
     s_GlobalInteraction = mitk::GlobalInteraction::New();
   }
   return s_GlobalInteraction;
 }
 
 
 mitk::State* mitk::GlobalInteraction::GetStartState(const char* type)
 {
   if ( this->IsInitialized() )
     return m_StateMachineFactory->GetStartState(type);
   
   MITK_FATAL << "Fatal Error in mitkGlobalInteraction.cpp: GlobalInteraction not initialized!\n";
   return NULL;
 }
 
 bool mitk::GlobalInteraction::AddToSelectedInteractors(mitk::Interactor* interactor)
 {
   InteractorListIter position = std::find(m_SelectedList.begin(), m_SelectedList.end(),interactor);
   if (position != m_SelectedList.end())
   {
     //already added so don't add once more!
     return true;
   }
   else
     m_SelectedList.push_back(interactor);
 
   return true;
 }
 
 bool mitk::GlobalInteraction::RemoveFromSelectedInteractors(mitk::Interactor* interactor)
 {
   if (interactor == NULL)
     return false;
 
   InteractorListIter position = std::find(m_SelectedList.begin(), m_SelectedList.end(),interactor);
   if (position != m_SelectedList.end())
   {
     position = m_SelectedList.erase(position);
     return true;
   }
   else
     return false;
 }
 
 mitk::StateMachineFactory* mitk::GlobalInteraction::GetStateMachineFactory()
 {
   return m_StateMachineFactory;
 }
 
 bool mitk::GlobalInteraction::Initialize(const char* globalInteractionName, const std::string XMLBehaviorInput)
 {
   if (this->IsInitialized())
   {
     MITK_WARN <<"Global Interaction has already been initialized.\n";
     return false;
   }
 
   m_FocusManager = FocusManager::New();
 
   // instantiates m_StateMachineFactory and load interaction patterns from XML string
   //if factory has been initialized before, delete it and initialize once more to not add patterns
   if (m_StateMachineFactory)
     m_StateMachineFactory->Delete();
   m_StateMachineFactory = StateMachineFactory::New();
   
   //if EventMapper was initialized before, delete it and initialize once more 
   // to create new event descriptions and not to add them
   if (m_EventMapper)
     m_EventMapper->Delete();
   m_EventMapper = EventMapper::New();
   
 
   bool success = true;
 
   if (XMLBehaviorInput == "")
   {
     //load default behavior
     success &= m_StateMachineFactory->LoadStandardBehavior();
     success &= m_EventMapper->LoadStandardBehavior();
   }
   else if (itksys::SystemTools::FileExists(XMLBehaviorInput.c_str()) )
   {
     // load standard behavior from file
     success &= m_StateMachineFactory->LoadBehavior(XMLBehaviorInput);
     success &= m_EventMapper->LoadBehavior(XMLBehaviorInput);
   }
   else
   {
     //load standard behavior from XML string
     success &= m_StateMachineFactory->LoadBehaviorString(XMLBehaviorInput);
     success &= m_EventMapper->LoadBehaviorString(XMLBehaviorInput);
   }
 
   if(!success) 
   {
     MITK_FATAL << "Error initializing global interaction!\n";
     return false;
   }
 
   //now instantiate what could not be done in InitializeStateStates because StateMachineFactory was not up yet:
 
   // (Re-) Initialize Superclass (StateMachine), because type was not given at time of construction
   m_Type = globalInteractionName;
 
   //get the start state of the pattern
   State::Pointer startState = m_StateMachineFactory->GetStartState(globalInteractionName);
 
   if (startState.IsNull())
   {
     MITK_FATAL << "Fatal Error in mitkGlobalInteraction.cpp: No StartState recieved from StateMachineFactory!\n";
     return false;
   }
 
   //clear the vector
   m_CurrentStateVector.clear();
   //add the start state pointer for the first time step to the list
   m_CurrentStateVector.push_back(startState);
   m_IsInitialized = true;
   return true;  
 }
 
+void mitk::GlobalInteraction::SetEventNotificationPolicy(EVENT_NOTIFICATION_POLICY policy)
+{
+  this->m_EventNotificationPolicy = policy;
+}
+
+mitk::GlobalInteraction::EVENT_NOTIFICATION_POLICY mitk::GlobalInteraction::GetEventNotificationPolicy() const
+{
+  return this->m_EventNotificationPolicy;
+}
+
diff --git a/Core/Code/Interactions/mitkGlobalInteraction.h b/Core/Code/Interactions/mitkGlobalInteraction.h
index 8947e9e0e7..44dfc86b15 100755
--- a/Core/Code/Interactions/mitkGlobalInteraction.h
+++ b/Core/Code/Interactions/mitkGlobalInteraction.h
@@ -1,274 +1,317 @@
 /*===================================================================
 
 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 GLOBALINTERACTION_H_HEADER_INCLUDED_C152938A
 #define GLOBALINTERACTION_H_HEADER_INCLUDED_C152938A
 
 #include "mitkFocusManager.h"
 #include <MitkExports.h>
 #include "mitkStateMachineFactory.h"
 #include "mitkEventMapper.h"
 #include "mitkInteractor.h"
 
 namespace mitk {
 
   class PositionEvent;
 
   //##Documentation
   //## @brief handles all global Events
   //##
   //## superior statemachine, that spreads the events to all other interactors
   //##
   //## Initialization
   //## Attention: GlobalInteraction <strong>must</strong> be initialized by the Initialize() method
   //## before usage by giving it an XML scheme. Possibilities are giving it an empty string (default),
   //## the filename of an XML file or the actual XML content as std::string. If an empty string is given,
   //## the content is tried to be loaded from the default file location.
   //##
   //## Concept of sending events:
   //## In this concept of interaction, the statemachines can be divided into two main statemachines:
   //## Listeners and interactors.
   //## Listeners only receive the event to process it, but don't change any data. They want to listen to all events.
   //## Interactors do change data according to the received event. They do not need to receive all events, only
   //## those they are interested in.
+  //## Additional to that a EVENT_NOTIFICATION_POLICY can be set. This can be either INFORM_MULTIPLE (the event is passed
+  //## to all listeners) or INFORM_ONE (event is passed to the listener which can handle the event best and only to this one).
   //##
-  //## To divide these two types of statemachine this class holds three lists and one map:
-  //## m_ListenerList, m_InteractorList, m_SelectedList and m_JurisdictionMap
+  //## To divide these two types of statemachine this class holds three lists and two maps:
+  //## m_ListenerList, m_InteractorList, m_SelectedList and m_InteractorRelevanceMap and m_ListenerRelevanceMap
   //## The list m_ListenerList holds all listeners.
   //## m_InteractorList holds all interactors, and the List m_SelectedList holds all machines, that were set to SELECTED or SUBSELECTED.
-  //## m_JurisdictionMap maps values returned from CanHandleEvent to the asked Interactors.
-  //## Through this map stepping through interactors, that were not selected and could handle that event, can be done.
+  //## m_InteractorRelevanceMap and m_ListenerRelevanceMap map values returned from CanHandleEvent to the asked Interactors and Listeners.
+  //## Through m_InteractorRelevanceMap stepping through interactors, that were not selected and could handle that event, can be done.
+  //## Through m_ListenerRelevanceMap the listener which can handle the event best can be determined. In case of the INFORM_ONE notification policy
+  //## the event is passed to just this listener
   //## 
   //## First the listeners are informed with the event.
   //## Then the selected or subselected interactors are asked if they can handle that event.
   //## They can handle it, if the mode of the interactor after HandleEvent(..) is still in SMSELECTED or SMSUBSELECTED.
   //## They can't handle it, if the mode changed to SMDESELECTED. Then the interactor is removed from the selected-list.
-  //## In that case, all interactors are asked to calculate and return their area of jurisdiction.
+  //## In that case, all interactors are asked to calculate and return their area of Relevance.
   //## An iterator is held on one interactor in the map. With the iterator, the map can be looped through so 
   //## so that several geometric objects, that lie on top of each other, can be selected.
   //## @ingroup Interaction
  class MITK_CORE_EXPORT GlobalInteraction : public StateMachine
   {
   public:
     mitkClassMacro(GlobalInteraction, StateMachine);
     itkNewMacro(Self);
 
     typedef std::vector<StateMachine::Pointer>  StateMachineList;
     typedef std::vector<StateMachine*>  StateMachineCPointerList;
     typedef StateMachineList::iterator          StateMachineListIter;
     typedef StateMachineCPointerList::iterator          StateMachineCPointerListIter;
     typedef std::vector<Interactor::Pointer>    InteractorList;
     typedef InteractorList::iterator            InteractorListIter;
     typedef std::multimap<float, Interactor::Pointer, std::greater<double> > InteractorMap;
+    typedef std::multimap<float, StateMachine::Pointer, std::greater<double> > StateMachineMap;
     typedef InteractorMap::iterator             InteractorMapIter;
+    typedef StateMachineMap::iterator             StateMachineMapIter;
+
+    /**
+      * Enum for setting the event notification policy of the GlobalInteraction.
+      */
+    enum EVENT_NOTIFICATION_POLICY
+    {
+      INFORM_MULTIPLE, /** For setting that all registered listeners are informed */
+      INFORM_ONE /** For setting that just the listener that can handle the event best is informed */
+    };
     
     //##Documentation
     //## @brief add an Interactor to the list of all interactors that are asked for handling an event
     //##
     //## returns true in case of success
     void AddInteractor(Interactor* interactor);
 
     //##Documentation
     //## @brief remove a certain Interactor from the set of interactors that are asked for handling an event
     //##
     //## returns true in case of success
     bool RemoveInteractor(Interactor* interactor);
 
     //##Documentation
     //## @brief returns true, if the given interactor is already added to the Interactor-List
     bool InteractorRegistered (Interactor* interactor);
 
     //##Documentation
     //## @brief add a Listener to the list of all Listeners that are informed of an event
     //##
     //## returns true in case of success
     void AddListener(StateMachine* listener);
 
     //##Documentation
     //## @brief remove a certain Listener from the set of Listeners that are informed of an event
     //##
     //## returns true in case of success
     bool RemoveListener(StateMachine* listener);
 
     //##Documentation
     //## @brief returns true, if the given interactor is already added to the Listener-List
     bool ListenerRegistered (StateMachine* listener);
 
     //##Documentation
     //## @brief adds an element in the list in FocusManager
     //##
     //## true if success, false if the element is already in list
     bool AddFocusElement(FocusManager::FocusElement* element);
 
     //##Documentation
     //## @brief Removes an element in FocusManager
     //##
     //## true if success, false if the element was not in the list
     bool RemoveFocusElement(FocusManager::FocusElement* element);
 
     //##Documentation
     //## @brief Returns the focused Element in FocusManager
     FocusManager::FocusElement* GetFocus();
 
     //##Documentation
     //## @brief Sets the given Element to focused
     //##
     //## returns true if the given element was found and focused
     bool SetFocus(FocusManager::FocusElement* element);
 
     //##Documentation
     //## @brief Returns the pointer to the FocusManager
     //##
     //## to add the observer for an event
     FocusManager* GetFocusManager();
 
     //##Documentation
     //## @brief Returns the pointer to the EventMapper
     //##
     //## to add an addon
     EventMapper* GetEventMapper();
 
     /**
     * @brief Return StateMachineFactory
     **/
     StateMachineFactory* GetStateMachineFactory();
     
     /**
     * @brief Returns the StartState of the StateMachine with the name type;
     *
     * Asks member StateMachineFactory for the StartState.
     * Returns NULL if no entry with name type is found.
     **/    
     State* GetStartState(const char* type);
 
     //##Documentation
     //## @brief Returns the global (singleton) instance of
     //## GlobalInteraction. Create it, if it does not exist.
     static GlobalInteraction* GetInstance();
 
     //##Documentation
     //## @brief Initializes the global (singleton) instance of
     //## GlobalInteraction via an XML string. Must! be done before usage. Can be done only once.
     //## Can be used with an empty string (default), a file name with path, or the actual XML content as string.
     bool Initialize(const char* globalInteractionName, const std::string XMLBehaviorInput = "");
 
     //##Documentation
     //## @brief Check if GlobalInteraction has already been initialized. Init must! be done before usage.
-    bool IsInitialized() {return m_IsInitialized;};
+    bool IsInitialized() {return m_IsInitialized;}
+
+    /**
+      * @brief Set the policy of how the global interaction informs listeners and interactors
+      *
+      * INFORM_MULTIPLE broadcasts the event to all listeners and interactors that can handle the event
+      * INFORM_ONE only informs the listener or interactor which can handle the event best
+      **/
+    void SetEventNotificationPolicy(EVENT_NOTIFICATION_POLICY);
+
+    /**
+      * Return the current set eventspreading policy
+      * @returns the current event spreading policy
+      **/
+    EVENT_NOTIFICATION_POLICY GetEventNotificationPolicy() const;
 
 
     //so that the interactors can call AddToSelectedInteractors() and RemoveFromSelectedInteractors()
     friend class Interactor;
 
   protected:
     /**
     * @brief Default Constructor with type to load the StateMachinePattern of the StateMachine
     * @param XMLbehaviorFile the file which contains the statemachine and event patterns 
     * @param type the name of the statemachine pattern this class shall use
     **/
     GlobalInteraction();
     
     /**
     * @brief Default destructor.
     **/
     ~GlobalInteraction();
 
     virtual bool ExecuteAction(Action* action, mitk::StateEvent const* stateEvent);
 
     /*
     *@brief adds the given interactor to the list of selected interactors. 
     * This list is asked first to handle an event.
     */
     virtual bool AddToSelectedInteractors(Interactor* interactor);
 
     /*
     *@brief removes the given interactor from the list of selected interactors
     * This list is asked first to handle an event.
     */
     virtual bool RemoveFromSelectedInteractors(Interactor* interactor);
 
   private:
 
     //##Documentation
     //##@brief informing all statemachines that are held in the list m_ListenerList
     void InformListeners(mitk::StateEvent const* stateEvent);
 
     //##Documentation
     //##@brief asking the selected Interactor if an event can be handled
     //##
     //## returns false if no Interactor could handle the event
     bool AskSelected(mitk::StateEvent const* stateEvent);
 
     //##Documentation
-    //##@brief asking next interactor of m_JurisdictionMap
+    //##@brief asking next interactor of m_RelevanceMap
     bool AskCurrentInteractor(mitk::StateEvent const* stateEvent);
 
     //##Documentation
-    //##@brief filling m_JurisdictionMap 
+    //##@brief filling m_InteractorRelevanceMap
     //##
-    //## @ params swell: if the calculated jurisdiction value is above swell, then add it to the map
-    void FillJurisdictionMap(mitk::StateEvent const* stateEvent, float threshold);
+    //## @ params threshold: if the calculated Relevance value is above threshold, then add it to the map
+    void FillInteractorRelevanceMap(mitk::StateEvent const* stateEvent, float threshold);
+
+    //##Documentation
+    //##@brief filling m_ListenerRelevanceMap
+    //##
+    //## @ params threshold: if the calculated Relevance value is above threshold, then add it to the map
+    void FillListenerRelevanceMap(mitk::StateEvent const* stateEvent, float threshold);
 
     void RemoveFlaggedListeners();
 
     StateMachineCPointerList m_ListenersFlaggedForRemoval;
 
     //##Documentation
     //## @brief list of all listening statemachines, that want to receive all events
     StateMachineList m_ListenerList;
 
     //##Documentation
     //## @brief list of all interactors (statemachine, that change data)
     InteractorList m_InteractorList;
 
     //##Documentation
     //## @brief list of all interactors, that are in Mode SELECTED or SUBSELECTED
     InteractorList m_SelectedList; 
 
     //##Documentation
     //## @brief map for sorting all interactors by the value returned from CanHandleEvent(..).
     //##
     //## With that list certain interactors can be looped through like diving through layers
-    InteractorMap m_JurisdictionMap;
+    InteractorMap m_InteractorRelevanceMap;
+
+    //##Documentation
+    //## @brief map for sorting all listeners by the value returned from CanHandleEvent(..).
+    //##
+    //## With that list certain listeners can be looped through like diving through layers
+    StateMachineMap m_ListenerRelevanceMap;
 
     //##Documentation
-    //## @brief iterator on an entry in m_JurisdictionMap for stepping through interactors
+    //## @brief iterator on an entry in m_RelevanceMap for stepping through interactors
     InteractorMapIter m_CurrentInteractorIter;
     
     //##Documentation
     //## @brief holds a list of BaseRenderer and one focused
     FocusManager::Pointer m_FocusManager;
 
     /**
     * @brief StatemachineFactory loads statemachine patterns and provides start states
     **/
     StateMachineFactory* m_StateMachineFactory;
 
     /**
     * @brief EventMapper loads event patterns
     **/
     EventMapper* m_EventMapper;
 
     bool m_CurrentlyInInformListenersLoop;
     bool m_CurrentlyInInformInteractorsLoop;
     bool m_IsInitialized;
+
+    EVENT_NOTIFICATION_POLICY m_EventNotificationPolicy;
   };
 } // namespace mitk
 
 #endif /* GLOBALINTERACTION_H_HEADER_INCLUDED_C152938A */
 
 
diff --git a/Core/Code/Interactions/mitkStateMachine.cpp b/Core/Code/Interactions/mitkStateMachine.cpp
index f9bdf67199..8a9d56d08e 100644
--- a/Core/Code/Interactions/mitkStateMachine.cpp
+++ b/Core/Code/Interactions/mitkStateMachine.cpp
@@ -1,315 +1,320 @@
 /*===================================================================
 
 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 "mitkStateMachine.h"
 #include "mitkStateTransitionOperation.h"
 #include "mitkInteractionConst.h"
 #include "mitkInteractor.h"
 #include "mitkTransition.h"
 #include "mitkOperationEvent.h"
 #include "mitkStateEvent.h"
 #include "mitkAction.h"
 #include "mitkUndoController.h"
 #include <itkMacro.h>
 #include "mitkGlobalInteraction.h"
 #include <mbilog.h>
 
 
 /**
 * @brief Constructor
 * daclares a new StateMachine and connects
 * it to a StateMachine of Type type;
 * Also the undo mechanism is instanciated and enabled/disabled
 **/
 mitk::StateMachine::StateMachine(const char * type)
 : m_UndoController(NULL), m_Type("")
 {
   if(type!=NULL) //no need to throw a warning here, because the statemachine yet here doesn't have to be set up. 
   {
     m_Type = type;
     
     //the statemachine doesn't know yet anything about the number of timesteps of the data. So we initialize it with one element.
     this->InitializeStartStates(1);
   }
   
   if (!m_UndoController)
   {
     m_UndoController = new UndoController(UndoController::VERBOSE_LIMITEDLINEARUNDO);//switch to LLU or add LLU
     
     /**
     * here the Undo mechanism is enabled / disabled for all interactors.
     **/
     m_UndoEnabled = true;
   }
 
   m_TimeStep = 0;
 }
 
 mitk::StateMachine::~StateMachine()
 {
   //clean up map using deletes
   for ( mitk::StateMachine::ActionFunctionsMapType::iterator iter = m_ActionFunctionsMap.begin();
         iter != m_ActionFunctionsMap.end();
         ++iter )
   {
     delete iter->second;
   }
 
   delete m_UndoController;
 }
 
 std::string mitk::StateMachine::GetType() const
 {
   return m_Type;
 }
 
 const mitk::State* mitk::StateMachine::GetCurrentState(unsigned int timeStep) const
 {
   if (m_CurrentStateVector.size() > timeStep) //the size of the vector has to be one integer higher than the timeStep.
     return m_CurrentStateVector[timeStep].GetPointer();
   return NULL;
 }
 
 void mitk::StateMachine::ResetStatemachineToStartState(unsigned int timeStep)
 {
   mitk::State* startState = mitk::GlobalInteraction::GetInstance()->GetStartState((const char *)(&m_Type[0]));
 
   if ( m_UndoEnabled )  //write to UndoMechanism if Undo is enabled
   {
     //UNDO for this statechange; 
     StateTransitionOperation* doOp = new StateTransitionOperation(OpSTATECHANGE, startState, timeStep);
     StateTransitionOperation* undoOp = new StateTransitionOperation(OpSTATECHANGE, m_CurrentStateVector[timeStep], timeStep);
     OperationEvent *operationEvent = new OperationEvent(((mitk::OperationActor*)(this)), doOp, undoOp);
     m_UndoController->SetOperationEvent(operationEvent);
   }
   //can be done without calling this->ExecuteOperation()
   m_CurrentStateVector[timeStep] = startState;
 
 }
 
+float mitk::StateMachine::CanHandleEvent(const StateEvent* /*stateEvent*/) const
+{
+  return 0.5;
+}
+
 bool mitk::StateMachine::HandleEvent(StateEvent const* stateEvent)
 {
   if (stateEvent == NULL)
     return false;
 
   if (m_CurrentStateVector.empty())
   {
     STATEMACHINE_ERROR << "Error in mitkStateMachine.cpp: StateMachine not initialized!\n";
     return false;//m_CurrentStateVector needs to be initialized!
   }
 
   if (m_TimeStep >= m_CurrentStateVector.size())
   {
     STATEMACHINE_ERROR << "Error in mitkStateMachine.cpp: StateMachine not initialized for this time step!\n";
     return false;
   }
 
   if (m_CurrentStateVector[m_TimeStep].IsNull())
   {
     STATEMACHINE_ERROR << "Error in mitkStateMachine.cpp: StateMachine not initialized with the right temporal information!\n";
     return false;//m_CurrentState needs to be initialized!
   }
 
   //get the Transition from m_CurrentState which waits for this EventId
   const Transition *tempTransition = m_CurrentStateVector[m_TimeStep]->GetTransition(stateEvent->GetId());
   if (tempTransition == NULL) //no transition in this state for that EventId
   {
     return false;
   }
 
   //get next State
   State *tempNextState = tempTransition->GetNextState();
   if (tempNextState == NULL) //wrong built up statemachine!
   {
     STATEMACHINE_ERROR << "Error in mitkStateMachine.cpp: StateMachinePattern not defined correctly!\n";
     return false;
   }
 
   //and ActionId to execute later on
   if ( m_CurrentStateVector[m_TimeStep]->GetId() != tempNextState->GetId() )//statechange only if there is a real statechange
   {
     if ( m_UndoEnabled )  //write to UndoMechanism if Undo is enabled
     {
       //UNDO for this statechange; since we directly change the state, we don't need the do-Operation in case m_UndoEnables == false
       StateTransitionOperation* doOp = new StateTransitionOperation(OpSTATECHANGE, tempNextState, m_TimeStep);
       StateTransitionOperation* undoOp = new StateTransitionOperation(OpSTATECHANGE, m_CurrentStateVector[m_TimeStep], m_TimeStep);
       OperationEvent *operationEvent = new OperationEvent(((mitk::OperationActor*)(this)), doOp, undoOp);
       m_UndoController->SetOperationEvent(operationEvent);
     }
 
     STATEMACHINE_DEBUG << "from " << m_CurrentStateVector[m_TimeStep]->GetId()
                        << " " << m_CurrentStateVector[m_TimeStep]->GetName()
                        << " to " << tempNextState->GetId() <<" "<<tempNextState->GetName();
 
     //first following StateChange(or calling ExecuteOperation(tempNextStateOp)), then operation(action)
     m_CurrentStateVector[m_TimeStep] = tempNextState;
   }
 
   mitk::Transition::ActionVectorIterator actionIdIterator = tempTransition->GetActionBeginIterator();
   mitk::Transition::ActionVectorConstIterator actionIdIteratorEnd = tempTransition->GetActionEndIterator();
   bool ok = true;
 
   while ( actionIdIterator != actionIdIteratorEnd ) 
   {
     if ( !ExecuteAction(*actionIdIterator, stateEvent) )
     {
       ok = false;
     }
     actionIdIterator++;
   }
   return ok;
 }
 
 void mitk::StateMachine::EnableUndo(bool enable)
 {
   m_UndoEnabled = enable;
 }
 
 void mitk::StateMachine::IncCurrGroupEventId()
 {
   mitk::OperationEvent::IncCurrGroupEventId();
 }
 
 /// look up which object method is associated to the given action and call the method
 bool mitk::StateMachine::ExecuteAction(Action* action, StateEvent const* stateEvent)
 {
   if (!action) return false;
 
   int actionId = action->GetActionId();
 
   TStateMachineFunctor* actionFunction = m_ActionFunctionsMap[actionId];
   if (!actionFunction) return false;
 
   bool retVal = actionFunction->DoAction(action, stateEvent);
   return retVal;
 }
 
 void mitk::StateMachine::AddActionFunction(int action, mitk::TStateMachineFunctor* functor)
 {
   if (!functor) return;
 
   // make sure double calls for same action won't cause memory leaks
   delete m_ActionFunctionsMap[action]; // delete NULL does no harm
 
   m_ActionFunctionsMap[action] = functor;
 }
 
 
 void mitk::StateMachine::ExecuteOperation(Operation* operation)
 {
   switch (operation->GetOperationType())
   {
   case OpNOTHING:
     break;
   case OpSTATECHANGE:
     {
       mitk::StateTransitionOperation* stateTransOp = dynamic_cast<mitk::StateTransitionOperation *>(operation);
       if (stateTransOp == NULL)
       {
         STATEMACHINE_WARN<<"Error! see mitkStateMachine.cpp";
         return;
       }
       unsigned int time = stateTransOp->GetTime();
       m_CurrentStateVector[time] = stateTransOp->GetState();
     }
     break;
   case OpTIMECHANGE:
     {
       mitk::StateTransitionOperation* stateTransOp = dynamic_cast<mitk::StateTransitionOperation *>(operation);
       if (stateTransOp == NULL)
       {
         STATEMACHINE_WARN<<"Error! see mitkStateMachine.cpp";
         return;
       }
       m_TimeStep = stateTransOp->GetTime();
     }
     break;
   case OpDELETE:
     {
       //delete this!
       //before all lower statemachines has to be deleted in a action
       //this->Delete();//might not work!!!check itk!
     }
   case OpUNDELETE:
     {
       //now the m_CurrentState has to be set on a special State
       //that way a delete of a StateMachine can be undone 
       //IMPORTANT: The type has to be the same!!!Done by a higher instance, that creates this!
       mitk::StateTransitionOperation* stateTransOp = dynamic_cast<mitk::StateTransitionOperation *>(operation);
       if (stateTransOp != NULL)
       {
         unsigned int time = stateTransOp->GetTime();
         m_CurrentStateVector[time] = stateTransOp->GetState();
       }
     }
   default:
     ;
   }
 }
 
 void mitk::StateMachine::InitializeStartStates(unsigned int timeSteps)
 {
   //get the startstate of the pattern
   State::Pointer startState = mitk::GlobalInteraction::GetInstance()->GetStartState(m_Type.c_str());
 
   if (startState.IsNull())
   {
     STATEMACHINE_FATAL << "Fatal Error in mitkStateMachine.cpp: Initialization of statemachine unsuccessfull! Initialize GlobalInteraction!\n";
   }
 
   //clear the vector
   m_CurrentStateVector.clear();
   //add n=timesteps pointers pointing to to the startstate
   for (unsigned int i = 0; i < timeSteps; i++)
     m_CurrentStateVector.push_back(startState);
 }
 
 // Check if the vector is long enough to contain the new element
 // at the given position. If not, expand it with sufficient pre-initialized
 // elements.
 //
 // NOTE: This method will never REDUCE the vector size; it should only
 // be used to make sure that the vector has enough elements to include the
 // specified time step.
 void mitk::StateMachine::ExpandStartStateVector(unsigned int timeSteps)
 {
   unsigned int oldSize = m_CurrentStateVector.size();
 
   if ( timeSteps > oldSize )
   {
     State::Pointer startState = mitk::GlobalInteraction::GetInstance()->GetStartState(m_Type.c_str());
     for ( unsigned int i = oldSize; i < timeSteps; ++i )
       m_CurrentStateVector.insert(m_CurrentStateVector.end(), startState);
   }
 }
 
 void mitk::StateMachine::UpdateTimeStep(unsigned int timeStep)
 {
   //don't need to fill up the memory if the time is uptodate
   if (timeStep == m_TimeStep)
     return;
 
   //create an operation that changes the time and send it to undocontroller 
   StateTransitionOperation* doOp = new StateTransitionOperation(OpTIMECHANGE, NULL, timeStep);
   if ( m_UndoEnabled )  //write to UndoMechanism if Undo is enabled
   {
     StateTransitionOperation* undoOp = new StateTransitionOperation(OpTIMECHANGE, NULL, m_TimeStep);
     OperationEvent *operationEvent = new OperationEvent(((mitk::OperationActor*)(this)), doOp, undoOp);
     m_UndoController->SetOperationEvent(operationEvent);
   }
   this->ExecuteOperation(doOp);
 }
 
diff --git a/Core/Code/Interactions/mitkStateMachine.h b/Core/Code/Interactions/mitkStateMachine.h
index 3816ecdfb6..d6f39af2a8 100644
--- a/Core/Code/Interactions/mitkStateMachine.h
+++ b/Core/Code/Interactions/mitkStateMachine.h
@@ -1,291 +1,301 @@
 /*===================================================================
 
 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 STATEMACHINE_H_HEADER_INCLUDED_C18896BD
 #define STATEMACHINE_H_HEADER_INCLUDED_C18896BD
 
 #include <MitkExports.h>
 #include <itkObject.h>
 #include "mitkOperationActor.h"
 #include <string>
 #include "mitkState.h"
 #include "mitkUndoModel.h"
 
 namespace mitk {
 
   class Action;
   class StateEvent;
   class UndoController;
 
   // base class of statem machine functors
   class MITK_CORE_EXPORT TStateMachineFunctor
   {
     public:
       virtual bool DoAction(Action*, const StateEvent*)=0;        // call using function
       virtual ~TStateMachineFunctor() {}
   };
 
   // the template functor for arbitrary StateMachine derivations
   template <class T>
   class TSpecificStateMachineFunctor : public TStateMachineFunctor
   {
     public:
 
       // constructor - takes pointer to an object and pointer to a member and stores
       // them in two private variables
       TSpecificStateMachineFunctor(T* object, bool(T::*memberFunctionPointer)(Action*, const StateEvent*))
       :m_Object(object),
       m_MemberFunctionPointer(memberFunctionPointer)
       {
       }
 
       virtual ~TSpecificStateMachineFunctor() {} // virtual destructor
 
       // override function "Call"
       virtual bool DoAction(Action* action, const StateEvent* stateEvent)
       {
         return (*m_Object.*m_MemberFunctionPointer)(action, stateEvent);             // execute member function
       }
 
     private:
       T* m_Object;                  // pointer to object
       bool (T::*m_MemberFunctionPointer)(Action*, const StateEvent*);   // pointer to member function
   };
 
 /// Can be uses by derived classes of StateMachine to connect action IDs to methods
 /// Assumes that there is a typedef Classname Self in classes that use this macro
 #define CONNECT_ACTION(a, f) \
   StateMachine::AddActionFunction(a, new TSpecificStateMachineFunctor<Self>(this, &Self::f));
 
 #define STATEMACHINE_INFO MITK_INFO("StateMachine") << "[type: " << GetType() << "] "
 #define STATEMACHINE_WARN MITK_WARN("StateMachine") << "[type: " << GetType() << "] "
 #define STATEMACHINE_FATAL MITK_FATAL("StateMachine") << "[type: " << GetType() << "] "
 #define STATEMACHINE_ERROR MITK_ERROR("StateMachine") << "[type: " << GetType() << "] "
 #define STATEMACHINE_DEBUG MITK_DEBUG("StateMachine") << "[type: " << GetType() << "] "
 
 /**
 @brief Superior statemachine
 @ingroup Interaction
 
   Realizes the methods, that every statemachine has to have.
   Undo can be enabled and disabled through EnableUndo.
 
   To implement your own state machine, you have to derive a class from mitk::StateMachine and either
 
   - override ExecuteAction()
   or
   - Write bool methods that take (Action*, const StateEvent*) as parameter and use the CONNECT_ACTION macro in your constructor
 
   The second version is recommended, since it provides more structured code. The following piece of code demonstrates how to
   use the CONNECT_ACTION macro. The important detail is to provide a <i>typedef classname Self</i>
 
   \code
 class LightSwitch : public StateMachine
 {
   public:
 
     mitkClassMacro(LightSwitch, StateMachine); // this creates the Self typedef
 
     LightSwitch(const char*);
 
     bool DoSwitchOn(Action*, const StateEvent*);
     bool DoSwitchOff(Action*, const StateEvent*);
 }
 
 LightSwitch::LightSwitch(const char* type)
 :StateMachine(type)
 {
   // make sure that AcSWITCHON and AcSWITCHOFF are defined int constants somewhere (e.g. mitkInteractionConst.h)
   CONNECT_ACTION( AcSWITCHON, DoSwitchOn );
   CONNECT_ACTION( AcSWITCHOFF, DoSwitchOff );
 }
 
 bool LightSwitch::DoSwitchOn(Action*, const StateEvent*)
 {
   std::cout << "Enlightenment" << std::endl;
 }
 
 bool LightSwitch::DoSwitchOff(Action*, const StateEvent*)
 {
   std::cout << "Confusion" << std::endl;
 }
 \endcode
 
   What CONNECT_ACTION does, is call StateMachine::AddActionFunction(...) to add some function pointer wrapping class (functor) to
   a std::map of StateMachine. Whenever StateMachines ExecuteAction is called, StateMachine will lookup the desired Action in its
   map and call the appropriate method in your derived class.
 
 **/
   class MITK_CORE_EXPORT StateMachine : public itk::Object, public mitk::OperationActor
   {
 
   public:
     mitkClassMacro(StateMachine,itk::Object);
 
     /**
     * @brief New Macro with one parameter for creating this object with static New(..) method
     **/
     mitkNewMacro1Param(Self, const char*);
 
 
     /**
     * @brief Map to connect action IDs with method calls. Use AddActionFunction or (even better) the CONNECT_ACTION macro to fill the map.
     **/
     typedef std::map<int, TStateMachineFunctor*> ActionFunctionsMapType;
 
     /**
     * @brief Type for a vector of StartStatePointers
     **/
     typedef std::vector<State::Pointer> StartStateVectorType;
 
     /**
     * @brief Get the name and with this the type of the StateMachine
     **/
     std::string GetType() const;
 
     /**
     * @brief handles an Event accordingly to its current State
     *
     * Statechange with Undo functionality;
     * EventMapper gives each event a new objectEventId
     * and a StateMachine::ExecuteAction can descide weather it gets a
     * new GroupEventId or not, depending on its state (e.g. finishedNewObject then new GroupEventId).
     * Object- and group-EventId can also be accessed through static methods from OperationEvent
     **/
     virtual bool HandleEvent(StateEvent const* stateEvent);
 
+    /**
+     * @brief calculates how good this statemachine can handle the event.
+     *
+     *  Returns a value between 0 and 1
+     *  where 0 represents not responsible and 1 represents definitive responsible!
+     *  Standard function to override if needed.
+     *  (Used by GlobalInteraction to decide which DESELECTED statemachine to send the event to.)
+    **/
+    virtual float CanHandleEvent(const StateEvent *) const;
+
     /**
     * @brief Enables or disabled Undo.
     **/
     void EnableUndo(bool enable);
 
     /**
     * @brief A statemachine is also an OperationActor due to the UndoMechanism.
     *
     * The statechange is done in ExecuteOperation, so that the statechange can be undone by UndoMechanism.
     * Is set private here and in superclass it is set public, so UndoController
     * can reach ist, but it can't be overwritten by a subclass
     * *ATTENTION*: THIS METHOD SHOULD NOT BE CALLED FROM OTHER CLASSES DIRECTLY!
     **/
     virtual void ExecuteOperation(Operation* operation);
 
     /**
     * @brief Friend so that UndoModel can call ExecuteOperation for Undo.
     **/
     friend class UndoModel;
 
     friend class GlobalInteraction;
 
 
   protected:
     /**
     * @brief Default Constructor. Obsolete to instanciate it with this method! Use ::New(..) method instead. Set the "type" and with this the pattern of the StateMachine
     **/
     StateMachine(const char * type);
 
     /**
     * @brief Default Destructor
     **/
     ~StateMachine();
 
     /**
     * @brief Adds the Function to ActionList.
     **/
     void AddActionFunction(int action, TStateMachineFunctor* functor);
 
     /**
     * @brief Method called in HandleEvent after Statechange.
     *
     * Each statechange has actions, which can be assigned by it's number.
     * If you are developing a new statemachine, declare all your operations here and send them to Undo-Controller and to the Data.
     * Object- and group-EventId can also be accessed through static methods from OperationEvent
     **/
     virtual bool ExecuteAction(Action* action, StateEvent const* stateEvent);
 
     /**
     * @brief returns the current state
     **/
     const State* GetCurrentState(unsigned int timeStep = 0) const;
 
     /**
     * @brief if true, then UndoFunctionality is enabled
     *
     * Default value is true;
     **/
     bool m_UndoEnabled;
 
     /**
     * @brief Friend protected function of OperationEvent; that way all StateMachines can set GroupEventId to be incremented!
     **/
     void IncCurrGroupEventId();
 
     /**
     * @brief holds an UndoController, that can be accessed from all StateMachines. For ExecuteAction
     **/
     UndoController* m_UndoController;
 
     /**
     * @brief Resets the current state from the given timeStep to the StartState with undo functionality! Use carefully!
     * @param[in] timeStep If the statemachine has several timesteps to take care of, specify the according timestep
     **/
     void ResetStatemachineToStartState(unsigned int timeStep = 0);
 
     /**
     * @brief Check if the number of timeSteps is equal to the number of stored StartStates. Nothing is changed if the number is equal.
     **/
     void ExpandStartStateVector(unsigned int timeSteps);
 
     /**
     * @brief initializes m_CurrentStateVector
     **/
     void InitializeStartStates(unsigned int timeSteps);
 
     /**
     * @brief Update the TimeStep of the statemachine with undo-support if undo enabled
     **/
     virtual void UpdateTimeStep(unsigned int timeStep);
 
     /**
     * @brief Current TimeStep if the data which is to be interacted on, has more than 1 TimeStep
     **/
     unsigned int m_TimeStep;
 
   private:
     /**
     * @brief The type of the StateMachine. This string specifies the StateMachinePattern that is loaded from the StateMachineFactory.
     **/
     std::string m_Type;
 
     /**
     * @brief Points to the current state.
     **/
     StartStateVectorType m_CurrentStateVector;
 
     /**
     * @brief Map of the added Functions
     **/
     ActionFunctionsMapType m_ActionFunctionsMap;
 
   };
 
 } // namespace mitk
 
 
 
 #endif /* STATEMACHINE_H_HEADER_INCLUDED_C18896BD */
 
 
diff --git a/Core/Code/Rendering/mitkImageVtkMapper2D.cpp b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
index f76a053a98..bc41ed3302 100644
--- a/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
+++ b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
@@ -1,998 +1,998 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //MITK
 #include <mitkAbstractTransformGeometry.h>
 #include <mitkDataNode.h>
 #include <mitkDataNodeFactory.h>
 #include <mitkImageSliceSelector.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkProperties.h>
 #include <mitkResliceMethodProperty.h>
 #include <mitkTimeSlicedGeometry.h>
 #include <mitkVtkResliceInterpolationProperty.h>
 #include <mitkPixelType.h>
 //#include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include "mitkImageStatisticsHolder.h"
 
 //MITK Rendering
 #include "mitkImageVtkMapper2D.h"
 #include "vtkMitkThickSlicesFilter.h"
 #include "vtkMitkApplyLevelWindowToRGBFilter.h"
 
 //VTK
 #include <vtkProperty.h>
 #include <vtkTransform.h>
 #include <vtkMatrix4x4.h>
 #include <vtkLookupTable.h>
 #include <vtkImageData.h>
 #include <vtkPoints.h>
 #include <vtkGeneralTransform.h>
 #include <vtkImageReslice.h>
 #include <vtkImageChangeInformation.h>
 #include <vtkPlaneSource.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkTexture.h>
 #include <vtkCellArray.h>
 #include <vtkCamera.h>
 #include <vtkColorTransferFunction.h>
 
 //ITK
 #include <itkRGBAPixel.h>
 
 mitk::ImageVtkMapper2D::ImageVtkMapper2D()
 {
 }
 
 mitk::ImageVtkMapper2D::~ImageVtkMapper2D()
 {
   //The 3D RW Mapper (Geometry2DDataVtkMapper3D) is listening to this event,
   //in order to delete the images from the 3D RW.
   this->InvokeEvent( itk::DeleteEvent() );
 }
 
 //set the two points defining the textured plane according to the dimension and spacing
 void mitk::ImageVtkMapper2D::GeneratePlane(mitk::BaseRenderer* renderer, vtkFloatingPointType planeBounds[6])
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   float depth = this->CalculateLayerDepth(renderer);
   //Set the origin to (xMin; yMin; depth) of the plane. This is necessary for obtaining the correct
   //plane size in crosshair rotation and swivel mode.
   localStorage->m_Plane->SetOrigin(planeBounds[0], planeBounds[2], depth);
   //These two points define the axes of the plane in combination with the origin.
   //Point 1 is the x-axis and point 2 the y-axis.
   //Each plane is transformed according to the view (axial, coronal and saggital) afterwards.
   localStorage->m_Plane->SetPoint1(planeBounds[1] , planeBounds[2], depth); //P1: (xMax, yMin, depth)
   localStorage->m_Plane->SetPoint2(planeBounds[0], planeBounds[3], depth); //P2: (xMin, yMax, depth)
 }
 
 float mitk::ImageVtkMapper2D::CalculateLayerDepth(mitk::BaseRenderer* renderer)
 {
   //get the clipping range to check how deep into z direction we can render images
   double maxRange = renderer->GetVtkRenderer()->GetActiveCamera()->GetClippingRange()[1];
 
   //Due to a VTK bug, we cannot use the whole clipping range. /100 is empirically determined
   float depth = -maxRange*0.01; // divide by 100
   int layer = 0;
   GetDataNode()->GetIntProperty( "layer", layer, renderer);
   //add the layer property for each image to render images with a higher layer on top of the others
   depth += layer*10; //*10: keep some room for each image (e.g. for QBalls in between)
   if(depth > 0.0f) {
     depth = 0.0f;
     MITK_WARN << "Layer value exceeds clipping range. Set to minimum instead.";
   }
   return depth;
 }
 
 const mitk::Image* mitk::ImageVtkMapper2D::GetInput( void )
 {
   return static_cast< const mitk::Image * >( this->GetData() );
 }
 
 vtkProp* mitk::ImageVtkMapper2D::GetVtkProp(mitk::BaseRenderer* renderer)
 {  
   //return the actor corresponding to the renderer
   return m_LSH.GetLocalStorage(renderer)->m_Actor;
 }
 
 void mitk::ImageVtkMapper2D::MitkRenderOverlay(BaseRenderer* renderer)
 {
   if ( this->IsVisible(renderer)==false )
     return;
   if ( this->GetVtkProp(renderer)->GetVisibility() )
   {
     this->GetVtkProp(renderer)->RenderOverlay(renderer->GetVtkRenderer());
   }
 }
 
 void mitk::ImageVtkMapper2D::MitkRenderOpaqueGeometry(BaseRenderer* renderer)
 {
   if ( this->IsVisible( renderer )==false )
     return;
   if ( this->GetVtkProp(renderer)->GetVisibility() )
   {
     this->GetVtkProp(renderer)->RenderOpaqueGeometry( renderer->GetVtkRenderer() );
   }
 }
 
 void mitk::ImageVtkMapper2D::MitkRenderTranslucentGeometry(BaseRenderer* renderer)
 {
   if ( this->IsVisible(renderer)==false )
     return;
   if ( this->GetVtkProp(renderer)->GetVisibility() )
   {
     this->GetVtkProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer());
   }
 }
 
 void mitk::ImageVtkMapper2D::MitkRenderVolumetricGeometry(BaseRenderer* renderer)
 {
   if(IsVisible(renderer)==false)
     return;
   if ( GetVtkProp(renderer)->GetVisibility() )
   {
     this->GetVtkProp(renderer)->RenderVolumetricGeometry(renderer->GetVtkRenderer());
   }
 }
 
 void mitk::ImageVtkMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
   mitk::DataNode* datanode = this->GetDataNode();
 
   if ( input == NULL || input->IsInitialized() == false )
   {
     return;
   }
 
   //check if there is a valid worldGeometry
   const Geometry2D *worldGeometry = renderer->GetCurrentWorldGeometry2D();
   if( ( worldGeometry == NULL ) || ( !worldGeometry->IsValid() ) || ( !worldGeometry->HasReferenceGeometry() ))
   {
     return;
   }
 
   input->Update();
 
   // early out if there is no intersection of the current rendering geometry
   // and the geometry of the image that is to be rendered.
   if ( !RenderingGeometryIntersectsImage( worldGeometry, input->GetSlicedGeometry() ) )
   {
     localStorage->m_Mapper->SetInput( localStorage->m_EmptyPolyData );
     return;
   }
 
 
   //set main input for ExtractSliceFilter
   localStorage->m_Reslicer->SetInput(input);
   localStorage->m_Reslicer->SetWorldGeometry(worldGeometry);
   localStorage->m_Reslicer->SetTimeStep( this->GetTimestep() );
 
 
   //set the transformation of the image to adapt reslice axis
   localStorage->m_Reslicer->SetResliceTransformByGeometry( input->GetTimeSlicedGeometry()->GetGeometry3D( this->GetTimestep() ) );
 
 
   //is the geometry of the slice based on the input image or the worldgeometry?
   bool inPlaneResampleExtentByGeometry = false;
   datanode->GetBoolProperty("in plane resample extent by geometry", inPlaneResampleExtentByGeometry, renderer);
   localStorage->m_Reslicer->SetInPlaneResampleExtentByGeometry(inPlaneResampleExtentByGeometry);
 
 
   // Initialize the interpolation mode for resampling; switch to nearest
   // neighbor if the input image is too small.
   if ( (input->GetDimension() >= 3) && (input->GetDimension(2) > 1) )
   {
     VtkResliceInterpolationProperty *resliceInterpolationProperty;
     datanode->GetProperty(
       resliceInterpolationProperty, "reslice interpolation" );
 
     int interpolationMode = VTK_RESLICE_NEAREST;
     if ( resliceInterpolationProperty != NULL )
     {
       interpolationMode = resliceInterpolationProperty->GetInterpolation();
     }
 
     switch ( interpolationMode )
     {
     case VTK_RESLICE_NEAREST:
       localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
       break;
     case VTK_RESLICE_LINEAR:
       localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_LINEAR);
       break;
     case VTK_RESLICE_CUBIC:
       localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_CUBIC);
       break;
     }
   }
   else
   {
     localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
   }
 
   //set the vtk output property to true, makes sure that no unneeded mitk image convertion
   //is done.
   localStorage->m_Reslicer->SetVtkOutputRequest(true);
 
 
   //Thickslicing
   int thickSlicesMode = 0;
   int thickSlicesNum = 1;
   // Thick slices parameters
   if( input->GetPixelType().GetNumberOfComponents() == 1 ) // for now only single component are allowed
   {
     DataNode *dn=renderer->GetCurrentWorldGeometry2DNode();
     if(dn)
     {
       ResliceMethodProperty *resliceMethodEnumProperty=0;
 
       if( dn->GetProperty( resliceMethodEnumProperty, "reslice.thickslices" ) && resliceMethodEnumProperty )
         thickSlicesMode = resliceMethodEnumProperty->GetValueAsId();
 
       IntProperty *intProperty=0;
       if( dn->GetProperty( intProperty, "reslice.thickslices.num" ) && intProperty )
       {
         thickSlicesNum = intProperty->GetValue();
         if(thickSlicesNum < 1) thickSlicesNum=1;
         if(thickSlicesNum > 10) thickSlicesNum=10;
       }
     }
     else
     {
       MITK_WARN << "no associated widget plane data tree node found";
     }
   }
 
 
   if(thickSlicesMode > 0)
   {  
     double dataZSpacing = 1.0;
 
     Vector3D normInIndex, normal;
     const PlaneGeometry *planeGeometry = dynamic_cast< const PlaneGeometry * >( worldGeometry );
     if ( planeGeometry != NULL ){
       normal = planeGeometry->GetNormal();
     }else{
       const mitk::AbstractTransformGeometry* abstractGeometry = dynamic_cast< const AbstractTransformGeometry * >(worldGeometry);
       if(abstractGeometry != NULL)
         normal = abstractGeometry->GetPlane()->GetNormal();
       else
         return; //no fitting geometry set
     }
     normal.Normalize();
 
     input->GetTimeSlicedGeometry()->GetGeometry3D( this->GetTimestep() )->WorldToIndex( normal, normInIndex );
 
     dataZSpacing = 1.0 / normInIndex.GetNorm();
 
     localStorage->m_Reslicer->SetOutputDimensionality( 3 );
     localStorage->m_Reslicer->SetOutputSpacingZDirection(dataZSpacing);
     localStorage->m_Reslicer->SetOutputExtentZDirection( -thickSlicesNum, 0+thickSlicesNum );
 
     // Do the reslicing. Modified() is called to make sure that the reslicer is
     // executed even though the input geometry information did not change; this
     // is necessary when the input /em data, but not the /em geometry changes.
     localStorage->m_TSFilter->SetThickSliceMode( thickSlicesMode-1 );
     localStorage->m_TSFilter->SetInput( localStorage->m_Reslicer->GetVtkOutput() );
 
     //vtkFilter=>mitkFilter=>vtkFilter update mechanism will fail without calling manually
     localStorage->m_Reslicer->Modified();
     localStorage->m_Reslicer->Update();
 
     localStorage->m_TSFilter->Modified();
     localStorage->m_TSFilter->Update();
     localStorage->m_ReslicedImage = localStorage->m_TSFilter->GetOutput();
   }
   else
   {
     //this is needed when thick mode was enable bevore. These variable have to be reset to default values
     localStorage->m_Reslicer->SetOutputDimensionality( 2 );
     localStorage->m_Reslicer->SetOutputSpacingZDirection(1.0);
     localStorage->m_Reslicer->SetOutputExtentZDirection( 0, 0 );
 
 
     localStorage->m_Reslicer->Modified();
     //start the pipeline with updating the largest possible, needed if the geometry of the input has changed
     localStorage->m_Reslicer->UpdateLargestPossibleRegion();
     localStorage->m_ReslicedImage = localStorage->m_Reslicer->GetVtkOutput();
   }
 
 
   // Bounds information for reslicing (only reuqired if reference geometry 
   // is present)
   //this used for generating a vtkPLaneSource with the right size
   vtkFloatingPointType sliceBounds[6];
   for ( int i = 0; i < 6; ++i )
   {
     sliceBounds[i] = 0.0;
   }
   localStorage->m_Reslicer->GetClippedPlaneBounds(sliceBounds);
 
   //get the spacing of the slice
   localStorage->m_mmPerPixel = localStorage->m_Reslicer->GetOutputSpacing();
 
 
   //get the number of scalar components to distinguish between different image types
   int numberOfComponents = localStorage->m_ReslicedImage->GetNumberOfScalarComponents();
   //get the binary property
   bool binary = false;
   bool binaryOutline = false;
   datanode->GetBoolProperty( "binary", binary, renderer );
   if(binary) //binary image
   {
     datanode->GetBoolProperty( "outline binary", binaryOutline, renderer );
     if(binaryOutline) //contour rendering
     {
       if ( input->GetPixelType().GetBpe() <= 8 )
       {
         //generate contours/outlines
         localStorage->m_OutlinePolyData = CreateOutlinePolyData(renderer);
 
         float binaryOutlineWidth(1.0);
         if ( datanode->GetFloatProperty( "outline width", binaryOutlineWidth, renderer ) )
         {
           localStorage->m_Actor->GetProperty()->SetLineWidth(binaryOutlineWidth);
         }
       }
       else
       {
         binaryOutline = false;
         this->ApplyLookuptable(renderer);
         MITK_WARN << "Type of all binary images should be (un)signed char. Outline does not work on other pixel types!";
       }
     }
     else //standard binary image
     {
       if(numberOfComponents != 1)
       {
         MITK_ERROR << "Rendering Error: Binary Images with more then 1 component are not supported!";
       }
     }
     this->ApplyLookuptable(renderer);
     //Interpret the values as binary values
     localStorage->m_Texture->MapColorScalarsThroughLookupTableOn();
   }
   else if( numberOfComponents == 1 ) //gray images
   {
     //Interpret the values as gray values
     localStorage->m_Texture->MapColorScalarsThroughLookupTableOn();
 
     this->ApplyLookuptable(renderer);
   }
   else if ( (numberOfComponents == 3) || (numberOfComponents == 4) ) //RBG(A) images
   {
     //Interpret the RGB(A) images values correctly
     localStorage->m_Texture->MapColorScalarsThroughLookupTableOff();
 
     this->ApplyLookuptable(renderer);
     this->ApplyRBGALevelWindow(renderer);
   }
   else
   {
     MITK_ERROR << "2D Reindering Error: Unknown number of components!!! Please report to rendering task force or check your data!";
   }
 
   this->ApplyColor( renderer );
   this->ApplyOpacity( renderer );
   this->TransformActor( renderer );
 
   //connect mapper with the data
   if(binary && binaryOutline) //connect the mapper with the polyData which contains the lines
   {
     //We need the contour for the binary oultine property as actor
     localStorage->m_Mapper->SetInput(localStorage->m_OutlinePolyData);
     localStorage->m_Actor->SetTexture(NULL); //no texture for contours
   }
   else
   { //Connect the mapper with the input texture. This is the standard case.
     //setup the textured plane
     this->GeneratePlane( renderer, sliceBounds );
     //set the plane as input for the mapper
     localStorage->m_Mapper->SetInputConnection(localStorage->m_Plane->GetOutputPort());
     //set the texture for the actor
     localStorage->m_Actor->SetTexture(localStorage->m_Texture);
   }
 
   // We have been modified => save this for next Update()
   localStorage->m_LastUpdateTime.Modified();
 }
 
 void mitk::ImageVtkMapper2D::ApplyColor( mitk::BaseRenderer* renderer )
 {
   LocalStorage *localStorage = this->GetLocalStorage( renderer );
 
   // check for interpolation properties
   bool textureInterpolation = false;
   GetDataNode()->GetBoolProperty( "texture interpolation", textureInterpolation, renderer );
 
   //set the interpolation modus according to the property
   localStorage->m_Texture->SetInterpolate(textureInterpolation);
 
   bool useColor = true;
   this->GetDataNode()->GetBoolProperty( "use color", useColor, renderer );
   if( useColor )
   {
     float rgb[3]= { 1.0f, 1.0f, 1.0f };
 
     // check for color prop and use it for rendering if it exists
     // binary image hovering & binary image selection
     bool hover    = false;
     bool selected = false;
     GetDataNode()->GetBoolProperty("binaryimage.ishovering", hover, renderer);
     GetDataNode()->GetBoolProperty("selected", selected, renderer);
     if(hover && !selected)
     {
       mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
         ("binaryimage.hoveringcolor", renderer));
       if(colorprop.IsNotNull())
       {
         memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
       }
       else
       {
         GetColor( rgb, renderer );
       }
     }
     if(selected)
     {
       mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
         ("binaryimage.selectedcolor", renderer));
       if(colorprop.IsNotNull()) {
         memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
       }
       else
       {
         GetColor( rgb, renderer );
       }
     }
     if(!hover && !selected)
     {
       GetColor( rgb, renderer );
     }
 
     double rgbConv[3] = {(double)rgb[0], (double)rgb[1], (double)rgb[2]}; //conversion to double for VTK
     localStorage->m_Actor->GetProperty()->SetColor(rgbConv);
   }
   else
   {
     //If the user defines a lut, we dont want to use the color and take white instead.
     localStorage->m_Actor->GetProperty()->SetColor(1.0, 1.0, 1.0);
   }
 }
 
 void mitk::ImageVtkMapper2D::ApplyOpacity( mitk::BaseRenderer* renderer )
 {
   LocalStorage* localStorage = this->GetLocalStorage( renderer );
   float opacity = 1.0f;
   // check for opacity prop and use it for rendering if it exists
   GetOpacity( opacity, renderer );
   //set the opacity according to the properties
   localStorage->m_Actor->GetProperty()->SetOpacity(opacity);
 }
 
 void mitk::ImageVtkMapper2D::ApplyLookuptable( mitk::BaseRenderer* renderer )
 {
   bool binary = false;
   bool CTFcanBeApplied = false;
   this->GetDataNode()->GetBoolProperty( "binary", binary, renderer );
   LocalStorage* localStorage = this->GetLocalStorage(renderer);
 
   //default lookuptable
   localStorage->m_Texture->SetLookupTable( localStorage->m_LookupTable );
 
   if(binary)
   {
     //default lookuptable for binary images
     localStorage->m_Texture->GetLookupTable()->SetRange(0.0, 1.0);
   }
   else
   {
     bool useColor = true;
     this->GetDataNode()->GetBoolProperty( "use color", useColor, renderer );
     if((!useColor))
     {
       //BEGIN PROPERTY user-defined lut
       //currently we do not allow a lookuptable if it is a binary image
       // If lookup table use is requested...
       mitk::LookupTableProperty::Pointer LookupTableProp;
       LookupTableProp = dynamic_cast<mitk::LookupTableProperty*>
         (this->GetDataNode()->GetProperty("LookupTable"));
       //...check if there is a lookuptable provided by the user
       if ( LookupTableProp.IsNotNull() )
       {
         // If lookup table use is requested and supplied by the user:
         // only update the lut, when the properties have changed...
         if( LookupTableProp->GetLookupTable()->GetMTime()
           <= this->GetDataNode()->GetPropertyList()->GetMTime() )
         {
           LookupTableProp->GetLookupTable()->ChangeOpacityForAll( LookupTableProp->GetLookupTable()->GetVtkLookupTable()->GetAlpha()*localStorage->m_Actor->GetProperty()->GetOpacity() );
           LookupTableProp->GetLookupTable()->ChangeOpacity(0, 0.0);
         }
         //we use the user-defined lookuptable
         localStorage->m_Texture->SetLookupTable( LookupTableProp->GetLookupTable()->GetVtkLookupTable() );
       }
       else
       {
         CTFcanBeApplied = true;
       }
     }//END PROPERTY user-defined lut
     LevelWindow levelWindow;
     this->GetLevelWindow( levelWindow, renderer );
     //set up the lookuptable with the level window range
     localStorage->m_Texture->GetLookupTable()->SetRange( levelWindow.GetLowerWindowBound(), levelWindow.GetUpperWindowBound() );
   }
   //the color function can be applied if the user does not want to use color
   //and does not provide a lookuptable
   if(CTFcanBeApplied)
   {
     ApplyColorTransferFunction(renderer);
   }
   localStorage->m_Texture->SetInput( localStorage->m_ReslicedImage );
 }
 
 void mitk::ImageVtkMapper2D::ApplyColorTransferFunction(mitk::BaseRenderer* renderer)
 {
   mitk::TransferFunctionProperty::Pointer transferFunctionProperty =
     dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("Image Rendering.Transfer Function",renderer ));
   LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
   if(transferFunctionProperty.IsNotNull())
   {
     localStorage->m_Texture->SetLookupTable(transferFunctionProperty->GetValue()->GetColorTransferFunction());
   }
   else
   {
     MITK_WARN << "Neither a lookuptable nor a transfer function is set and use color is off.";
   }
 }
 
 
 
 void mitk::ImageVtkMapper2D::ApplyRBGALevelWindow( mitk::BaseRenderer* renderer )
 {
   LocalStorage* localStorage = this->GetLocalStorage( renderer );
   //pass the LuT to the RBG filter
   localStorage->m_LevelWindowToRGBFilterObject->SetLookupTable(localStorage->m_Texture->GetLookupTable());
   mitk::LevelWindow opacLevelWindow;
   if( this->GetLevelWindow( opacLevelWindow, renderer, "opaclevelwindow" ) )
   {//pass the opaque level window to the filter
     localStorage->m_LevelWindowToRGBFilterObject->SetMinOpacity(opacLevelWindow.GetLowerWindowBound());
     localStorage->m_LevelWindowToRGBFilterObject->SetMaxOpacity(opacLevelWindow.GetUpperWindowBound());
   }
   else
   {//no opaque level window
     localStorage->m_LevelWindowToRGBFilterObject->SetMinOpacity(0.0);
     localStorage->m_LevelWindowToRGBFilterObject->SetMaxOpacity(255.0);
   }
   localStorage->m_LevelWindowToRGBFilterObject->SetInput(localStorage->m_ReslicedImage);
   //connect the texture with the output of the RGB filter
   localStorage->m_Texture->SetInputConnection(localStorage->m_LevelWindowToRGBFilterObject->GetOutputPort());
 }
 
 void mitk::ImageVtkMapper2D::Update(mitk::BaseRenderer* renderer)
 {
   if ( !this->IsVisible( renderer ) )
   {
     return;
   }
 
   mitk::Image* data  = const_cast<mitk::Image *>( this->GetInput() );
   if ( data == NULL )
   {
     return;
   }
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep( renderer );
 
   // Check if time step is valid
   const TimeSlicedGeometry *dataTimeGeometry = data->GetTimeSlicedGeometry();
   if ( ( dataTimeGeometry == NULL )
     || ( dataTimeGeometry->GetTimeSteps() == 0 )
     || ( !dataTimeGeometry->IsValidTime( this->GetTimestep() ) ) )
   {
     return;
   }
 
   const DataNode *node = this->GetDataNode();
   data->UpdateOutputInformation();
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   //check if something important has changed and we need to rerender
   if ( (localStorage->m_LastUpdateTime < node->GetMTime()) //was the node modified?
     || (localStorage->m_LastUpdateTime < data->GetPipelineMTime()) //Was the data modified?
     || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2DUpdateTime()) //was the geometry modified?
     || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2D()->GetMTime())
     || (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) //was a property modified?
     || (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()) )
   {
     this->GenerateDataForRenderer( renderer );
   }
 
   // since we have checked that nothing important has changed, we can set
   // m_LastUpdateTime to the current time
   localStorage->m_LastUpdateTime.Modified();
 }
 
 void mitk::ImageVtkMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
 
   // Properties common for both images and segmentations
   node->AddProperty( "use color", mitk::BoolProperty::New( true ), renderer, overwrite );
   node->AddProperty( "depthOffset", mitk::FloatProperty::New( 0.0 ), renderer, overwrite );
   node->AddProperty( "outline binary", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "outline width", mitk::FloatProperty::New( 1.0 ), renderer, overwrite );
   if(image->IsRotated()) node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_CUBIC) );
   else node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() );
   node->AddProperty( "texture interpolation", mitk::BoolProperty::New( mitk::DataNodeFactory::m_TextureInterpolationActive ) );  // set to user configurable default value (see global options)
   node->AddProperty( "in plane resample extent by geometry", mitk::BoolProperty::New( false ) );
   node->AddProperty( "bounding box", mitk::BoolProperty::New( false ) );
 
   std::string modality;
   if ( node->GetStringProperty( "dicom.series.Modality", modality ) )
   {
     // modality provided by DICOM or other reader
     if ( modality == "PT") // NOT a typo, PT is the abbreviation for PET used in DICOM
     {
       node->SetProperty( "use color", mitk::BoolProperty::New( false ), renderer );
       node->SetProperty( "opacity", mitk::FloatProperty::New( 0.5 ), renderer );
     }
   }
 
   bool isBinaryImage(false);
   if ( ! node->GetBoolProperty("binary", isBinaryImage) )
   {
 
     // ok, property is not set, use heuristic to determine if this
     // is a binary image
     mitk::Image::Pointer centralSliceImage;
     ScalarType minValue = 0.0;
     ScalarType maxValue = 0.0;
     ScalarType min2ndValue = 0.0;
     ScalarType max2ndValue = 0.0;
     mitk::ImageSliceSelector::Pointer sliceSelector = mitk::ImageSliceSelector::New();
 
     sliceSelector->SetInput(image);
     sliceSelector->SetSliceNr(image->GetDimension(2)/2);
     sliceSelector->SetTimeNr(image->GetDimension(3)/2);
     sliceSelector->SetChannelNr(image->GetDimension(4)/2);
     sliceSelector->Update();
     centralSliceImage = sliceSelector->GetOutput();
     if ( centralSliceImage.IsNotNull() && centralSliceImage->IsInitialized() )
     {
       minValue    = centralSliceImage->GetStatistics()->GetScalarValueMin();
       maxValue    = centralSliceImage->GetStatistics()->GetScalarValueMax();
       min2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMin();
       max2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMax();
     }
     if ( minValue == maxValue )
     {
       // centralSlice is strange, lets look at all data
       minValue    = image->GetStatistics()->GetScalarValueMin();
       maxValue    = image->GetStatistics()->GetScalarValueMaxNoRecompute();
       min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute();
       max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute();
     }
     isBinaryImage = ( maxValue == min2ndValue && minValue == max2ndValue );
   }
 
   // some more properties specific for a binary...
   if (isBinaryImage)
   {
     node->AddProperty( "opacity", mitk::FloatProperty::New(0.3f), renderer, overwrite );
     node->AddProperty( "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binaryimage.selectedcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binaryimage.selectedannotationcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binaryimage.hoveringcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binaryimage.hoveringannotationcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
     node->AddProperty( "binary", mitk::BoolProperty::New( true ), renderer, overwrite );
     node->AddProperty("layer", mitk::IntProperty::New(10), renderer, overwrite);
   }
   else          //...or image type object
   {
     node->AddProperty( "opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite );
     node->AddProperty( "color", ColorProperty::New(1.0,1.0,1.0), renderer, overwrite );
     node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
     node->AddProperty("layer", mitk::IntProperty::New(0), renderer, overwrite);
   }
 
   if(image.IsNotNull() && image->IsInitialized())
   {
     if((overwrite) || (node->GetProperty("levelwindow", renderer)==NULL))
     {
       /* initialize level/window from DICOM tags */
       std::string sLevel;
       std::string sWindow;
-      if (   node->GetStringProperty( "dicom.voilut.WindowCenter", sLevel )
-        && node->GetStringProperty( "dicom.voilut.WindowWidth", sWindow ) )
+      if ( image->GetPropertyList()->GetStringProperty( "dicom.voilut.WindowCenter", sLevel )
+        && image->GetPropertyList()->GetStringProperty( "dicom.voilut.WindowWidth", sWindow ) )
       {
         float level = atof( sLevel.c_str() );
         float window = atof( sWindow.c_str() );
 
         mitk::LevelWindow contrast;
         std::string sSmallestPixelValueInSeries;
         std::string sLargestPixelValueInSeries;
 
-        if (    node->GetStringProperty( "dicom.series.SmallestPixelValueInSeries", sSmallestPixelValueInSeries )
-          && node->GetStringProperty( "dicom.series.LargestPixelValueInSeries", sLargestPixelValueInSeries ) )
+        if ( image->GetPropertyList()->GetStringProperty( "dicom.series.SmallestPixelValueInSeries", sSmallestPixelValueInSeries )
+          && image->GetPropertyList()->GetStringProperty( "dicom.series.LargestPixelValueInSeries", sLargestPixelValueInSeries ) )
         {
           float smallestPixelValueInSeries = atof( sSmallestPixelValueInSeries.c_str() );
           float largestPixelValueInSeries = atof( sLargestPixelValueInSeries.c_str() );
           contrast.SetRangeMinMax( smallestPixelValueInSeries-1, largestPixelValueInSeries+1 ); // why not a little buffer? 
           // might remedy some l/w widget challenges
         }
         else
         {
           contrast.SetAuto( static_cast<mitk::Image*>(node->GetData()), false, true ); // we need this as a fallback
         }
 
         contrast.SetLevelWindow( level, window, true );
         node->SetProperty( "levelwindow", LevelWindowProperty::New( contrast ), renderer );
       }
     }
     if(((overwrite) || (node->GetProperty("opaclevelwindow", renderer)==NULL))
        && (image->GetPixelType().GetPixelTypeId() == itk::ImageIOBase::RGBA)
        && (image->GetPixelType().GetTypeId() == typeid( unsigned char)) )
     {
       mitk::LevelWindow opaclevwin;
       opaclevwin.SetRangeMinMax(0,255);
       opaclevwin.SetWindowBounds(0,255);
       mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(opaclevwin);
       node->SetProperty( "opaclevelwindow", prop, renderer );
     }
     if((overwrite) || (node->GetProperty("LookupTable", renderer)==NULL))
     {
       // add a default rainbow lookup table for color mapping
       mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
       vtkLookupTable* vtkLut = mitkLut->GetVtkLookupTable();
       vtkLut->SetHueRange(0.6667, 0.0);
       vtkLut->SetTableRange(0.0, 20.0);
       vtkLut->Build();
       mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
       mitkLutProp->SetLookupTable(mitkLut);
       node->SetProperty( "LookupTable", mitkLutProp );
     }
   }
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 mitk::ImageVtkMapper2D::LocalStorage* mitk::ImageVtkMapper2D::GetLocalStorage(mitk::BaseRenderer* renderer)
 {
   return m_LSH.GetLocalStorage(renderer);
 }
 
 vtkSmartPointer<vtkPolyData> mitk::ImageVtkMapper2D::CreateOutlinePolyData(mitk::BaseRenderer* renderer ){
   LocalStorage* localStorage = this->GetLocalStorage(renderer);
 
   //get the min and max index values of each direction
   int* extent = localStorage->m_ReslicedImage->GetExtent();
   int xMin = extent[0];
   int xMax = extent[1];
   int yMin = extent[2];
   int yMax = extent[3];
 
   int* dims = localStorage->m_ReslicedImage->GetDimensions(); //dimensions of the image
   int line = dims[0]; //how many pixels per line?
   int x = xMin; //pixel index x
   int y = yMin; //pixel index y
   char* currentPixel;
 
 
   //get the depth for each contour
   float depth = CalculateLayerDepth(renderer);
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New(); //the points to draw
   vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New(); //the lines to connect the points
 
   while (y <= yMax) 
   { 
     currentPixel = static_cast<char*>(localStorage->m_ReslicedImage->GetScalarPointer(x, y, 0));
 
     //if the current pixel value is set to something
     if ((currentPixel) && (*currentPixel != 0)) 
     {
       //check in which direction a line is necessary
       //a line is added if the neighbor of the current pixel has the value 0
       //and if the pixel is located at the edge of the image
 
       //if   vvvvv  not the first line vvvvv
       if (y > yMin && *(currentPixel-line) == 0) 
       { //x direction - bottom edge of the pixel
         //add the 2 points
         vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         //add the line between both points
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       //if   vvvvv  not the last line vvvvv
       if (y < yMax && *(currentPixel+line) == 0) 
       { //x direction - top edge of the pixel
         vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       //if   vvvvv  not the first pixel vvvvv
       if ( (x > xMin || y > yMin) && *(currentPixel-1) == 0) 
       { //y direction - left edge of the pixel
         vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       //if   vvvvv  not the last pixel vvvvv
       if ( (y < yMax || (x < xMax) ) && *(currentPixel+1) == 0) 
       { //y direction - right edge of the pixel
         vtkIdType p1 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       /*  now consider pixels at the edge of the image  */
 
       //if   vvvvv  left edge of image vvvvv
       if (x == xMin) 
       { //draw left edge of the pixel
         vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       //if   vvvvv  right edge of image vvvvv
       if (x == xMax) 
       { //draw right edge of the pixel
         vtkIdType p1 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       //if   vvvvv  bottom edge of image vvvvv
       if (y == yMin) 
       { //draw bottom edge of the pixel
         vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       //if   vvvvv  top edge of image vvvvv
       if (y == yMax) 
       { //draw top edge of the pixel
         vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
     }//end if currentpixel is set
 
     x++;
 
     if (x > xMax) 
     { //reached end of line
       x = xMin;
       y++;
     }
   }//end of while
 
 
   // Create a polydata to store everything in
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   // Add the points to the dataset
   polyData->SetPoints(points);
   // Add the lines to the dataset
   polyData->SetLines(lines);
   return polyData;
 }
 
 void mitk::ImageVtkMapper2D::TransformActor(mitk::BaseRenderer* renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
   //get the transformation matrix of the reslicer in order to render the slice as axial, coronal or saggital
   vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
   vtkSmartPointer<vtkMatrix4x4> matrix = localStorage->m_Reslicer->GetResliceAxes();
   trans->SetMatrix(matrix);
   //transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or saggital)
   localStorage->m_Actor->SetUserTransform(trans);
   //transform the origin to center based coordinates, because MITK is center based.
   localStorage->m_Actor->SetPosition( -0.5*localStorage->m_mmPerPixel[0], -0.5*localStorage->m_mmPerPixel[1], 0.0);
 }
 
 bool mitk::ImageVtkMapper2D::RenderingGeometryIntersectsImage( const Geometry2D* renderingGeometry, SlicedGeometry3D* imageGeometry )
 {
   // if either one of the two geometries is NULL we return true 
   // for safety reasons
   if ( renderingGeometry == NULL || imageGeometry == NULL )
     return true;
 
   // get the distance for the first cornerpoint
   ScalarType initialDistance = renderingGeometry->SignedDistance( imageGeometry->GetCornerPoint( 0 ) );
   for( int i=1; i<8; i++ )
   {
     mitk::Point3D cornerPoint = imageGeometry->GetCornerPoint( i );
 
     // get the distance to the other cornerpoints
     ScalarType distance = renderingGeometry->SignedDistance( cornerPoint );
 
     // if it has not the same signing as the distance of the first point
     if ( initialDistance * distance < 0 )
     {
       // we have an intersection and return true
       return true;
     }
   }
 
   // all distances have the same sign, no intersection and we return false
   return false;
 }
 
 mitk::ImageVtkMapper2D::LocalStorage::LocalStorage()
 {
   //Do as much actions as possible in here to avoid double executions.
   m_Plane = vtkSmartPointer<vtkPlaneSource>::New();
   m_Texture = vtkSmartPointer<vtkTexture>::New();
   m_LookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_Actor = vtkSmartPointer<vtkActor>::New();
   m_Reslicer = mitk::ExtractSliceFilter::New();
   m_TSFilter = vtkSmartPointer<vtkMitkThickSlicesFilter>::New();
   m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
   m_ReslicedImage = vtkSmartPointer<vtkImageData>::New();
   m_EmptyPolyData = vtkSmartPointer<vtkPolyData>::New();
 
   //the following actions are always the same and thus can be performed
   //in the constructor for each image (i.e. the image-corresponding local storage)
   m_TSFilter->ReleaseDataFlagOn();
 
   //built a default lookuptable
   m_LookupTable->SetRampToLinear();
   m_LookupTable->SetSaturationRange( 0.0, 0.0 );
   m_LookupTable->SetHueRange( 0.0, 0.0 );
   m_LookupTable->SetValueRange( 0.0, 1.0 );
   m_LookupTable->Build();
   //map all black values to transparent
   m_LookupTable->SetTableValue(0, 0.0, 0.0, 0.0, 0.0);
 
   //do not repeat the texture (the image)
   m_Texture->RepeatOff();
 
   //set the mapper for the actor
   m_Actor->SetMapper(m_Mapper);
 
   //filter for RGB(A) images
   m_LevelWindowToRGBFilterObject = new vtkMitkApplyLevelWindowToRGBFilter();
 }
diff --git a/Core/Code/Rendering/mitkVtkPropRenderer.cpp b/Core/Code/Rendering/mitkVtkPropRenderer.cpp
index 9b88069173..b37d19fe38 100644
--- a/Core/Code/Rendering/mitkVtkPropRenderer.cpp
+++ b/Core/Code/Rendering/mitkVtkPropRenderer.cpp
@@ -1,936 +1,937 @@
 /*===================================================================
 
 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 "mitkVtkPropRenderer.h"
 
 // MAPPERS
 #include "mitkMapper.h"
 #include "mitkImageVtkMapper2D.h"
 #include "mitkVtkMapper2D.h"
 #include "mitkVtkMapper3D.h"
 #include "mitkGeometry2DDataVtkMapper3D.h"
 #include "mitkPointSetGLMapper2D.h"
 
 #include "mitkImageSliceSelector.h"
 #include "mitkRenderingManager.h"
 #include "mitkGL.h"
 #include "mitkGeometry3D.h"
 #include "mitkDisplayGeometry.h"
 #include "mitkLevelWindow.h"
 #include "mitkCameraController.h"
 #include "mitkVtkInteractorCameraController.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProperties.h"
 #include "mitkSurface.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkVtkInteractorStyle.h"
 
 // VTK
 #include <vtkRenderer.h>
 #include <vtkRendererCollection.h>
 #include <vtkLight.h>
 #include <vtkLightKit.h>
 #include <vtkRenderWindow.h>
 #include <vtkLinearTransform.h>
 #include <vtkCamera.h>
 #include <vtkWorldPointPicker.h>
 #include <vtkPointPicker.h>
 #include <vtkCellPicker.h>
 #include <vtkTextActor.h>
 #include <vtkTextProperty.h>
 #include <vtkProp.h>
 #include <vtkAssemblyPath.h>
 #include <vtkAssemblyNode.h>
 #include <vtkMapper.h>
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
 #include <vtkInteractorStyleTrackballCamera.h>
 
 
 mitk::VtkPropRenderer::VtkPropRenderer( const char* name, vtkRenderWindow * renWin, mitk::RenderingManager* rm )
   : BaseRenderer(name,renWin, rm), 
   m_VtkMapperPresent(false), 
   m_NewRenderer(true),
   m_CameraInitializedForMapperID(0)
 {
   didCount=false;
 
   m_WorldPointPicker = vtkWorldPointPicker::New();
 
   m_PointPicker = vtkPointPicker::New();
   m_PointPicker->SetTolerance( 0.0025 );
 
   m_CellPicker = vtkCellPicker::New();
   m_CellPicker->SetTolerance( 0.0025 );
 
   mitk::Geometry2DDataVtkMapper3D::Pointer geometryMapper = mitk::Geometry2DDataVtkMapper3D::New();
   m_CurrentWorldGeometry2DMapper = geometryMapper;
   m_CurrentWorldGeometry2DNode->SetMapper(2, geometryMapper);
 
   m_LightKit = vtkLightKit::New();
   m_LightKit->AddLightsToRenderer(m_VtkRenderer);
   m_PickingMode = WorldPointPicking;
 
   m_TextRenderer = vtkRenderer::New();
   m_TextRenderer->SetRenderWindow(renWin);
   m_TextRenderer->SetInteractive(0);
   m_TextRenderer->SetErase(0);
 }
 
 /*!
 \brief Destructs the VtkPropRenderer.
 */
 mitk::VtkPropRenderer::~VtkPropRenderer()
 {
   // Workaround for GLDisplayList Bug
   {
     m_MapperID=0;
     checkState();
   }
 
   if (m_LightKit != NULL)
     m_LightKit->Delete();
 
   if (m_VtkRenderer!=NULL)
   {
     m_CameraController = NULL;
 
     m_VtkRenderer->Delete();
 
     m_VtkRenderer = NULL;
   }
   else
     m_CameraController = NULL;
 
   if (m_WorldPointPicker != NULL)
     m_WorldPointPicker->Delete();
   if (m_PointPicker != NULL)
     m_PointPicker->Delete();
   if (m_CellPicker != NULL)
     m_CellPicker->Delete();
   if (m_TextRenderer != NULL)
     m_TextRenderer->Delete();
 }
 
 
 void mitk::VtkPropRenderer::SetDataStorage(  mitk::DataStorage* storage  )
 {
   if ( storage == NULL )
     return;
 
   BaseRenderer::SetDataStorage(storage);
 
   static_cast<mitk::Geometry2DDataVtkMapper3D*>(m_CurrentWorldGeometry2DMapper.GetPointer())->SetDataStorageForTexture( m_DataStorage.GetPointer() );
 
   // Compute the geometry from the current data tree bounds and set it as world geometry
   this->SetWorldGeometryToDataStorageBounds();
 }
 
 
 bool mitk::VtkPropRenderer::SetWorldGeometryToDataStorageBounds()
 {
   if ( m_DataStorage.IsNull() )
     return false;
 
   //initialize world geometry
   mitk::TimeSlicedGeometry::Pointer geometry = m_DataStorage->ComputeVisibleBoundingGeometry3D( NULL, "includeInBoundingBox" );
 
   if ( geometry.IsNull() )
     return false;
 
   this->SetWorldGeometry(geometry);
   //this->GetDisplayGeometry()->SetSizeInDisplayUnits( this->m_TextRenderer->GetRenderWindow()->GetSize()[0], this->m_TextRenderer->GetRenderWindow()->GetSize()[1] );
   this->GetDisplayGeometry()->Fit();
   this->GetVtkRenderer()->ResetCamera();
   this->Modified();
   return true;
 }
 
 
 /*!
 \brief 
 
 Called by the vtkMitkRenderProp in order to start MITK rendering process.
 */
 int mitk::VtkPropRenderer::Render(mitk::VtkPropRenderer::RenderType type)
 {
 
   // Do we have objects to render?
   if ( this->GetEmptyWorldGeometry()) 
     return 0;
 
   if ( m_DataStorage.IsNull())
     return 0;
 
   // Update mappers and prepare mapper queue
   if (type == VtkPropRenderer::Opaque)
     this->PrepareMapperQueue();
   
   //go through the generated list and let the sorted mappers paint
   bool lastVtkBased = true;
   //bool sthVtkBased = false;
   
   for(MappersMapType::iterator it = m_MappersMap.begin(); it != m_MappersMap.end(); it++)
   {
     Mapper * mapper = (*it).second;
     if((mapper->IsVtkBased() == true) )
     {
       //sthVtkBased = true;
       mitk::VtkMapper3D::Pointer vtkMapper = dynamic_cast<mitk::VtkMapper3D*>(mapper);
       if(vtkMapper)
       {
         vtkMapper->GetVtkProp(this)->SetAllocatedRenderTime(5000,GetVtkRenderer()); //B/ ToDo: rendering time calculation
         //vtkMapper->GetVtkProp(this)->PokeMatrix(NULL); //B/ ToDo ??: VtkUserTransform
       }
       if(lastVtkBased == false)
       {
         Disable2DOpenGL();
         lastVtkBased = true;
       }
     }
     else
       if((mapper->IsVtkBased() == false) && (lastVtkBased == true))
       {
       Enable2DOpenGL();
       lastVtkBased = false;
     }
 
     //Workarround for bug GL_TEXTURE_2D (bug #8188)
     GLboolean mode;
     GLenum bit = GL_TEXTURE_2D;
     GLfloat lineWidth;
     glGetFloatv(GL_LINE_WIDTH, &lineWidth);
     glGetBooleanv(bit, &mode);
 
     switch(type)
     {
     case mitk::VtkPropRenderer::Opaque: mapper->MitkRenderOpaqueGeometry(this); break;
     case mitk::VtkPropRenderer::Translucent: mapper->MitkRenderTranslucentGeometry(this); break;
     case mitk::VtkPropRenderer::Overlay:       mapper->MitkRenderOverlay(this); break;
     case mitk::VtkPropRenderer::Volumetric:    mapper->MitkRenderVolumetricGeometry(this); break;
     }
     if(mode)
       glEnable(bit);
     else
       glDisable(bit);
 
     glLineWidth(lineWidth);
     //end Workarround for bug GL_TEXTURE_2D (bug #8188)
 
   }
   
   if (lastVtkBased == false)
     Disable2DOpenGL();
 
   // Render text
   if (type == VtkPropRenderer::Overlay)
   {
     if (m_TextCollection.size() > 0)
     {
       for (TextMapType::iterator it = m_TextCollection.begin(); it != m_TextCollection.end() ; it++)
         m_TextRenderer->AddViewProp((*it).second);
       m_TextRenderer->Render();
     }
   }
   return 1;
 }
 
 /*!
 \brief PrepareMapperQueue iterates the datatree
 
 PrepareMapperQueue iterates the datatree in order to find mappers which shall be rendered. Also, it sortes the mappers wrt to their layer.
 */
 void mitk::VtkPropRenderer::PrepareMapperQueue()
 {
   // variable for counting LOD-enabled mappers
   m_NumberOfVisibleLODEnabledMappers = 0;
 
   // Do we have to update the mappers ?
   if ( m_LastUpdateTime < GetMTime() || m_LastUpdateTime < GetDisplayGeometry()->GetMTime() ) {
     Update();
   }
   else if (m_MapperID>=1 && m_MapperID < 6)
     Update();
 
   // remove all text properties before mappers will add new ones
   m_TextRenderer->RemoveAllViewProps();
 
   for ( unsigned int i=0; i<m_TextCollection.size(); i++ )
   {
     m_TextCollection[i]->Delete();
   }
   m_TextCollection.clear();
 
   // clear priority_queue
   m_MappersMap.clear();
 
   int mapperNo = 0;
 
   //DataStorage
   if( m_DataStorage.IsNull() )
     return;
 
   DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
 
   for (DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin();  it != allObjects->End(); ++it)
   {
     DataNode::Pointer node = it->Value();
     if ( node.IsNull() )
       continue;
     mitk::Mapper::Pointer mapper = node->GetMapper(m_MapperID);
 
     if ( mapper.IsNull() )
       continue;
 
     // The information about LOD-enabled mappers is required by RenderingManager
     if ( mapper->IsLODEnabled( this ) && mapper->IsVisible( this ) )
     {
       ++m_NumberOfVisibleLODEnabledMappers;
     }
     // mapper without a layer property get layer number 1
     int layer = 1;
     node->GetIntProperty("layer", layer, this);
     int nr = (layer<<16) + mapperNo;
     m_MappersMap.insert( std::pair< int, Mapper * >( nr, mapper ) );
     mapperNo++;
   }  
 }
 
 /*!
 \brief 
 
 Enable2DOpenGL() and Disable2DOpenGL() are used to switch between 2D rendering (orthographic projection) and 3D rendering (perspective projection)
 */
 void mitk::VtkPropRenderer::Enable2DOpenGL()
 {
   GLint iViewport[4];  
 
   // Get a copy of the viewport  
   glGetIntegerv( GL_VIEWPORT, iViewport );  
 
   // Save a copy of the projection matrix so that we can restore it  
   // when it's time to do 3D rendering again.  
   glMatrixMode( GL_PROJECTION );  
   glPushMatrix();
   glLoadIdentity();  
 
   // Set up the orthographic projection  
   glOrtho( 
       iViewport[0], iViewport[0]+iViewport[2],
       iViewport[1], iViewport[1]+iViewport[3],
       -1.0, 1.0
       );
   glMatrixMode( GL_MODELVIEW );  
   glPushMatrix();  
   glLoadIdentity();
 
   // Make sure depth testing and lighting are disabled for 2D rendering until  
   // we are finished rendering in 2D  
   glPushAttrib( GL_DEPTH_BUFFER_BIT | GL_LIGHTING_BIT );
   glDisable( GL_DEPTH_TEST );  
   glDisable( GL_LIGHTING );
 }
 
 /*!
 \brief Initialize the VtkPropRenderer
 
 Enable2DOpenGL() and Disable2DOpenGL() are used to switch between 2D rendering (orthographic projection) and 3D rendering (perspective projection)
 */
 void mitk::VtkPropRenderer::Disable2DOpenGL()
 {
   glPopAttrib();
   glMatrixMode( GL_PROJECTION );  
   glPopMatrix();  
   glMatrixMode( GL_MODELVIEW );  
   glPopMatrix(); 
 }
 
 void mitk::VtkPropRenderer::Update(mitk::DataNode* datatreenode)
 {
   if(datatreenode!=NULL)
   {
     mitk::Mapper::Pointer mapper = datatreenode->GetMapper(m_MapperID);
     if(mapper.IsNotNull())
     {
       Mapper2D* mapper2d=dynamic_cast<Mapper2D*>(mapper.GetPointer());
       if(mapper2d != NULL)
       {
         if(GetDisplayGeometry()->IsValid())
         {
           VtkMapper2D* vtkmapper2d=dynamic_cast<VtkMapper2D*>(mapper.GetPointer());
           if(vtkmapper2d != NULL)
           {
             vtkmapper2d->Update(this);
             m_VtkMapperPresent=true;
           }
           else
             mapper2d->Update(this);
         }
       }
       else
       {
         VtkMapper3D* vtkmapper3d=dynamic_cast<VtkMapper3D*>(mapper.GetPointer());
         if(vtkmapper3d != NULL)
         {
           vtkmapper3d->Update(this);
           vtkmapper3d->UpdateVtkTransform(this);
           m_VtkMapperPresent=true;
         }
       }
     }
   }
 }
 
 
 void mitk::VtkPropRenderer::Update()
 {
   if( m_DataStorage.IsNull() )
     return;
 
   m_VtkMapperPresent = false;
   mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetAll();
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
     Update(it->Value());
 
   Modified();
   m_LastUpdateTime = GetMTime();
 }
 
 
 /*!
 \brief
 
 This method is called from the two Constructors
 */
 void mitk::VtkPropRenderer::InitRenderer(vtkRenderWindow* renderWindow)
 {
   BaseRenderer::InitRenderer(renderWindow);
 
   if(renderWindow == NULL)
   {
     m_InitNeeded = false;
     m_ResizeNeeded = false;
     return;
   }
 
   m_InitNeeded = true;
   m_ResizeNeeded = true;
 
   m_LastUpdateTime = 0;
 
 }
 
 
 /*!
 \brief Resize the OpenGL Window
 */
 void mitk::VtkPropRenderer::Resize(int w, int h)
 {
   BaseRenderer::Resize(w, h);
   m_RenderingManager->RequestUpdate(this->GetRenderWindow());
 }
 
 
 void mitk::VtkPropRenderer::InitSize(int w, int h)
 {
   m_RenderWindow->SetSize(w,h);
   Superclass::InitSize(w, h);
   Modified();
   Update();
   if(m_VtkRenderer!=NULL)
   {
     int w=vtkObject::GetGlobalWarningDisplay();
     vtkObject::GlobalWarningDisplayOff();
     m_VtkRenderer->ResetCamera();
     vtkObject::SetGlobalWarningDisplay(w);
   }
 }
 
 
 void mitk::VtkPropRenderer::SetMapperID(const MapperSlotId mapperId)
 {
   if(m_MapperID != mapperId)
     Superclass::SetMapperID(mapperId);
 
   // Workaround for GL Displaylist Bug
   checkState();
 }
 
 
 /*!
 \brief Activates the current renderwindow.
 */
 void mitk::VtkPropRenderer::MakeCurrent()
 {
   if(m_RenderWindow!=NULL)
     m_RenderWindow->MakeCurrent();
 }
 
 
 void mitk::VtkPropRenderer::PickWorldPoint(const mitk::Point2D& displayPoint, mitk::Point3D& worldPoint) const
 {
   if(m_VtkMapperPresent)
   {
     //m_WorldPointPicker->SetTolerance (0.0001);
     switch ( m_PickingMode )
     {
     case (WorldPointPicking) :
       {
         m_WorldPointPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer);
         vtk2itk(m_WorldPointPicker->GetPickPosition(), worldPoint);
         break;
       }
     case (PointPicking) :
       {
         // create a new vtkRenderer
         // give it all necessary information (camera position, etc.)
         // get all surfaces from datastorage, get actors from them
         // add all those actors to the new renderer
         // give this new renderer to pointpicker
         /*
        vtkRenderer* pickingRenderer = vtkRenderer::New();
        pickingRenderer->SetActiveCamera( );
 
        DataStorage* dataStorage = m_DataStorage;
        TNodePredicateDataType<Surface> isSurface;
 
        DataStorage::SetOfObjects::ConstPointer allSurfaces = dataStorage->GetSubset( isSurface );
        MITK_INFO << "in picking: got " << allSurfaces->size() << " surfaces." << std::endl;
 
        for (DataStorage::SetOfObjects::const_iterator iter = allSurfaces->begin();
             iter != allSurfaces->end();
             ++iter)
        {
          const DataNode* currentNode = *iter;
          VtkMapper3D* baseVtkMapper3D = dynamic_cast<VtkMapper3D*>( currentNode->GetMapper( BaseRenderer::Standard3D ) );
          if ( baseVtkMapper3D )
          {
            vtkActor* actor = dynamic_cast<vtkActor*>( baseVtkMapper3D->GetViewProp() );
            if (actor)
            {
              MITK_INFO << "a" << std::flush;
              pickingRenderer->AddActor( actor );
            }
          }
        }
 
        MITK_INFO << ";" << std::endl;
        */
         m_PointPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer);
         vtk2itk(m_PointPicker->GetPickPosition(), worldPoint);
         break;
       }
     }
   }
   else
   {
     Superclass::PickWorldPoint(displayPoint, worldPoint);
   }
 }
 
 mitk::DataNode *
     mitk::VtkPropRenderer::PickObject( const Point2D &displayPosition, Point3D &worldPosition ) const
 {
   if ( m_VtkMapperPresent )
   {
     m_CellPicker->InitializePickList();
 
     // Iterate over all DataStorage objects to determine all vtkProps intended
     // for picking
     DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
     for ( DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin();
     it != allObjects->End();
     ++it )
     {
       DataNode *node = it->Value();
       if ( node == NULL )
         continue;
 
       bool pickable = false;
       node->GetBoolProperty( "pickable", pickable );
       if ( !pickable )
         continue;
 
       VtkMapper3D *mapper = dynamic_cast< VtkMapper3D * >
                             ( node->GetMapper( m_MapperID ) );
       if ( mapper == NULL )
         continue;
 
       vtkProp *prop = mapper->GetVtkProp( (mitk::BaseRenderer *)this );
       if ( prop == NULL )
         continue;
 
       m_CellPicker->AddPickList( prop );
     }  
 
 
     // Do the picking and retrieve the picked vtkProp (if any)
     m_CellPicker->PickFromListOn();
     m_CellPicker->Pick( displayPosition[0], displayPosition[1], 0.0, m_VtkRenderer );
     m_CellPicker->PickFromListOff();
 
     vtk2itk( m_CellPicker->GetPickPosition(), worldPosition );
     vtkProp *prop = m_CellPicker->GetViewProp();
 
     if ( prop == NULL )
     {
       return NULL;
     }
 
     // Iterate over all DataStorage objects to determine if the retrieved
     // vtkProp is owned by any associated mapper.
     for ( DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin();
     it != allObjects->End();
     ++it)
     {
       DataNode::Pointer node = it->Value();
       if ( node.IsNull() )
         continue;
 
       mitk::Mapper::Pointer mapper = node->GetMapper( m_MapperID );
       if ( mapper.IsNull() )
         continue;
 
       if ( mapper->HasVtkProp( prop, const_cast< mitk::VtkPropRenderer * >( this ) ) )
       {
         return node;
       }
     }  
 
     return NULL;
   }
   else
   {
     return Superclass::PickObject( displayPosition, worldPosition ); 
   }
 };
 
 
 
 /*!
 \brief Writes some 2D text as overlay. Function returns an unique int Text_ID for each call, which can be used via the GetTextLabelProperty(int text_id) function
 in order to get a vtkTextProperty. This property enables the setup of font, font size, etc.
 */
-int mitk::VtkPropRenderer::WriteSimpleText(std::string text, double posX, double posY, double color1, double color2, double color3)
+int mitk::VtkPropRenderer::WriteSimpleText(std::string text, double posX, double posY, double color1, double color2, double color3, float opacity)
 {
   if(text.size() > 0)
   {
     vtkTextActor* textActor = vtkTextActor::New();
 
     textActor->SetPosition(posX,posY);
     textActor->SetInput(text.c_str());
     textActor->GetTextProperty()->SetColor(color1, color2, color3); //TODO: Read color from node property
+    textActor->GetTextProperty()->SetOpacity( opacity );
     int text_id = m_TextCollection.size();
     m_TextCollection.insert(TextMapType::value_type(text_id,textActor));
     return text_id;
   }
   return -1;
 }
 
 
 /*!
 \brief Can be used in order to get a vtkTextProperty for a specific text_id. This property enables the setup of font, font size, etc.
 */
 vtkTextProperty* mitk::VtkPropRenderer::GetTextLabelProperty(int text_id)
 {
   return this->m_TextCollection[text_id]->GetTextProperty();
 }
 
 
 void mitk::VtkPropRenderer::InitPathTraversal()
 {
   if (m_DataStorage.IsNotNull())
   {
     m_PickingObjects = m_DataStorage->GetAll();
     m_PickingObjectsIterator = m_PickingObjects->begin();
   }
 }
 
 
 vtkAssemblyPath* mitk::VtkPropRenderer::GetNextPath()
 {
   if (m_DataStorage.IsNull() )
   {
     return NULL;
   }
 
   if ( m_PickingObjectsIterator == m_PickingObjects->end() )
   {
     return NULL;
   }
 
   vtkAssemblyPath* returnPath = vtkAssemblyPath::New();
   //returnPath->Register(NULL);
 
   bool success = false;
 
   while (!success)
   {
     // loop until AddNode can be called successfully
     const DataNode* node = *m_PickingObjectsIterator;
     if (node)
     {
       Mapper* mapper = node->GetMapper( BaseRenderer::Standard3D );
       if (mapper)
       {
         VtkMapper3D* vtkmapper = dynamic_cast<VtkMapper3D*>( mapper );
         if (vtkmapper)
         {
           vtkProp* prop = vtkmapper->GetVtkProp(this);
           if ( prop && prop->GetVisibility() )
           {
             // add to assembly path
             returnPath->AddNode( prop, prop->GetMatrix() );
             success = true;
           }
         }
       }
     }
 
     ++m_PickingObjectsIterator;
 
     if ( m_PickingObjectsIterator == m_PickingObjects->end() ) break;
   }
 
   if ( success )
   {
     return returnPath;
   }
   else
   {
     return NULL;
   }
 }
 
 
 void mitk::VtkPropRenderer::ReleaseGraphicsResources(vtkWindow *renWin)
 {
   if( m_DataStorage.IsNull() )
     return;
 
   DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
   for (DataStorage::SetOfObjects::const_iterator iter = allObjects->begin(); iter != allObjects->end(); ++iter)
   {
     DataNode::Pointer node = *iter;
     if ( node.IsNull() )
       continue;
 
     Mapper::Pointer mapper = node->GetMapper(m_MapperID);
     if(mapper.IsNotNull())
       mapper->ReleaseGraphicsResources(renWin);
   } 
 }
 
 
 const vtkWorldPointPicker *mitk::VtkPropRenderer::GetWorldPointPicker() const
 {
   return m_WorldPointPicker;
 }
 
 
 const vtkPointPicker *mitk::VtkPropRenderer::GetPointPicker() const
 {
   return m_PointPicker;
 }
 
 
 const vtkCellPicker *mitk::VtkPropRenderer::GetCellPicker() const
 {
   return m_CellPicker;
 }
 
 
 mitk::VtkPropRenderer::MappersMapType mitk::VtkPropRenderer::GetMappersMap() const
 {
   return m_MappersMap;
 }
 
 
 // Workaround for GL Displaylist bug
 
 static int glWorkAroundGlobalCount = 0;
 
 bool mitk::VtkPropRenderer::useImmediateModeRendering()
 {
   return glWorkAroundGlobalCount>1;
 }
 
 void mitk::VtkPropRenderer::checkState()
 {
   if (m_MapperID == Standard3D)
   {
     if (!didCount)
     {
       didCount = true;
       glWorkAroundGlobalCount++;
       
       if (glWorkAroundGlobalCount == 2)
       {
         MITK_INFO << "Multiple 3D Renderwindows active...: turning Immediate Rendering ON for legacy mappers";
         //          vtkMapper::GlobalImmediateModeRenderingOn();
       }
       //MITK_INFO << "GLOBAL 3D INCREASE " << glWorkAroundGlobalCount << "\n";
       
     }
   }
   else
   {
     if(didCount)
     {
       didCount=false;
       glWorkAroundGlobalCount--;
       if(glWorkAroundGlobalCount==1)
       {
         MITK_INFO << "Single 3D Renderwindow active...: turning Immediate Rendering OFF for legacy mappers";
         //        vtkMapper::GlobalImmediateModeRenderingOff();
       }
       //MITK_INFO << "GLOBAL 3D DECREASE " << glWorkAroundGlobalCount << "\n";
     }
   }
 }
 
 //### Contains all methods which are neceassry before each VTK Render() call
 void mitk::VtkPropRenderer::PrepareRender()
 {
   if ( this->GetMapperID() != m_CameraInitializedForMapperID )
   {
     Initialize2DvtkCamera(); //Set parallel projection etc.
   }
 
   AdjustCameraToScene(); //Prepare camera for 2D render windows
 }
 
 bool mitk::VtkPropRenderer::Initialize2DvtkCamera()
 {
   if ( this->GetMapperID() == Standard3D )
   {
     //activate parallel projection for 2D
     this->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(false);
     this->GetRenderWindow()->GetInteractor()->SetInteractorStyle( vtkInteractorStyleTrackballCamera::New() );
     m_CameraInitializedForMapperID = Standard3D;
   }
   else if( this->GetMapperID() == Standard2D)
   {
     //activate parallel projection for 2D
     this->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(true);
     //turn the light out in the scene in order to render correct grey values.
     //TODO Implement a property for light in the 2D render windows (in another method)
     this->GetVtkRenderer()->RemoveAllLights();
 
     this->GetRenderWindow()->GetInteractor()->SetInteractorStyle( mitkVtkInteractorStyle::New() );
 
     m_CameraInitializedForMapperID = Standard2D;
   }
   return true;
 }
 
 void mitk::VtkPropRenderer::AdjustCameraToScene(){
   if(this->GetMapperID() == Standard2D)
   {
     const mitk::DisplayGeometry* displayGeometry = this->GetDisplayGeometry();
 
     double objectHeightInMM = this->GetCurrentWorldGeometry2D()->GetExtentInMM(1);//the height of the current object slice in mm
     double displayHeightInMM = displayGeometry->GetSizeInMM()[1]; //the display height in mm (gets smaller when you zoom in)
     double zoomFactor = objectHeightInMM/displayHeightInMM; //displayGeometry->GetScaleFactorMMPerDisplayUnit()
     //determine how much of the object can be displayed
 
     Vector2D displayGeometryOriginInMM = displayGeometry->GetOriginInMM();  //top left of the render window (Origin)
     Vector2D displayGeometryCenterInMM = displayGeometryOriginInMM + displayGeometry->GetSizeInMM()*0.5; //center of the render window: (Origin + Size/2)
 
     //Scale the rendered object:
     //The image is scaled by a single factor, because in an orthographic projection sizes
     //are preserved (so you cannot scale X and Y axis with different parameters). The
     //parameter sets the size of the total display-volume. If you set this to the image
     //height, the image plus a border with the size of the image will be rendered.
     //Therefore, the size is imageHeightInMM / 2.
     this->GetVtkRenderer()->GetActiveCamera()->SetParallelScale(objectHeightInMM*0.5 );
     //zooming with the factor calculated by dividing displayHeight through imegeHeight. The factor is inverse, because the VTK zoom method is working inversely.
     this->GetVtkRenderer()->GetActiveCamera()->Zoom(zoomFactor);
 
     //the center of the view-plane
     double viewPlaneCenter[3];
     viewPlaneCenter[0] = displayGeometryCenterInMM[0];
     viewPlaneCenter[1] = displayGeometryCenterInMM[1];
     viewPlaneCenter[2] = 0.0; //the view-plane is located in the XY-plane with Z=0.0
 
     //define which direction is "up" for the ciamera (like default for vtk (0.0, 1.0, 0.0)
     double cameraUp[3];
     cameraUp[0] = 0.0;
     cameraUp[1] = 1.0;
     cameraUp[2] = 0.0;
 
     //the position of the camera (center[0], center[1], 900000)
     double cameraPosition[3];
     cameraPosition[0] = viewPlaneCenter[0];
     cameraPosition[1] = viewPlaneCenter[1];
     cameraPosition[2] = 900000.0; //Reason for 900000: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
 
     //set the camera corresponding to the textured plane
     vtkSmartPointer<vtkCamera> camera = this->GetVtkRenderer()->GetActiveCamera();
     if (camera)
     {
       camera->SetPosition( cameraPosition ); //set the camera position on the textured plane normal (in our case this is the view plane normal)
       camera->SetFocalPoint( viewPlaneCenter ); //set the focal point to the center of the textured plane
       camera->SetViewUp( cameraUp ); //set the view-up for the camera
       //      double distance = sqrt((cameraPosition[2]-viewPlaneCenter[2])*(cameraPosition[2]-viewPlaneCenter[2]));
       //      camera->SetClippingRange(distance-50, distance+50); //Reason for huge range: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
       camera->SetClippingRange(0.1, 1000000); //Reason for huge range: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
     }
 
     const PlaneGeometry *planeGeometry = dynamic_cast< const PlaneGeometry * >( this->GetCurrentWorldGeometry2D() );
     if ( planeGeometry != NULL )
     {
       //Transform the camera to the current position (transveral, coronal and saggital plane).
       //This is necessary, because the SetUserTransform() method does not manipulate the vtkCamera.
       //(Without not all three planes would be visible).
       vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
       vtkSmartPointer<vtkMatrix4x4> matrix = vtkSmartPointer<vtkMatrix4x4>::New();
       Point3D origin;
       Vector3D right, bottom, normal;
 
       origin = planeGeometry->GetOrigin();
       right  = planeGeometry->GetAxisVector( 0 ); // right = Extent of Image in mm (worldspace)
       bottom = planeGeometry->GetAxisVector( 1 );
       normal = planeGeometry->GetNormal();
 
       right.Normalize();
       bottom.Normalize();
       normal.Normalize();
 
       matrix->SetElement(0, 0, right[0]);
       matrix->SetElement(1, 0, right[1]);
       matrix->SetElement(2, 0, right[2]);
       matrix->SetElement(0, 1, bottom[0]);
       matrix->SetElement(1, 1, bottom[1]);
       matrix->SetElement(2, 1, bottom[2]);
       matrix->SetElement(0, 2, normal[0]);
       matrix->SetElement(1, 2, normal[1]);
       matrix->SetElement(2, 2, normal[2]);
       matrix->SetElement(0, 3, origin[0]);
       matrix->SetElement(1, 3, origin[1]);
       matrix->SetElement(2, 3, origin[2]);
       matrix->SetElement(3, 0, 0.0);
       matrix->SetElement(3, 1, 0.0);
       matrix->SetElement(3, 2, 0.0);
       matrix->SetElement(3, 3, 1.0);
 
       trans->SetMatrix(matrix);
       //Transform the camera to the current position (transveral, coronal and saggital plane).
       this->GetVtkRenderer()->GetActiveCamera()->ApplyTransform(trans);
     }
   }
 }
diff --git a/Core/Code/Rendering/mitkVtkPropRenderer.h b/Core/Code/Rendering/mitkVtkPropRenderer.h
index f4832f62f5..eb9690e5b5 100644
--- a/Core/Code/Rendering/mitkVtkPropRenderer.h
+++ b/Core/Code/Rendering/mitkVtkPropRenderer.h
@@ -1,240 +1,240 @@
 /*===================================================================
 
 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 MITKVtkPropRenderer_H_HEADER_INCLUDED_C1C29F6D
 #define MITKVtkPropRenderer_H_HEADER_INCLUDED_C1C29F6D
 
 #include <MitkExports.h>
 #include "mitkBaseRenderer.h"
 #include "mitkDataStorage.h"
 #include "mitkRenderingManager.h"
 
 #include <itkCommand.h>
 
 #include <map>
 #include <utility>
 
 class vtkRenderWindow;
 class vtkLight;
 class vtkLightKit;
 class vtkWorldPointPicker;
 class vtkPointPicker;
 class vtkCellPicker;
 class vtkTextActor;
 class vtkTextProperty;
 class vtkAssemblyPath;
 
 
 namespace mitk 
 {
 
 class Mapper;
 
 /*!
 \brief VtkPropRenderer
 
 VtkPropRenderer organizes the MITK rendering process. The MITK rendering process is completely integrated into the VTK rendering pipeline.
 The vtkMitkRenderProp is a custom vtkProp derived class, which implements the rendering interface between MITK and VTK. It redirects render() calls to the VtkPropRenderer, which is responsible for rendering of the datatreenodes.
 VtkPropRenderer replaces the old OpenGLRenderer.
 
 \sa rendering
 \ingroup rendering
 */
 class MITK_CORE_EXPORT VtkPropRenderer : public BaseRenderer
 {
   // Workaround for Displaylistbug
 private:
   bool didCount;
   void checkState();
 
   // Workaround END
 
 public:
 
   mitkClassMacro(VtkPropRenderer,BaseRenderer);
   mitkNewMacro3Param(VtkPropRenderer, const char*, vtkRenderWindow *, mitk::RenderingManager* );
   
   typedef std::map<int,Mapper*> MappersMapType;
 
   // Render - called by vtkMitkRenderProp, returns the number of props rendered
   enum RenderType{Opaque,Translucent,Overlay,Volumetric};
 
   int Render(RenderType type);
 
   /** \brief This methods contains all method neceassary before a VTK Render() call */
   virtual void PrepareRender();
 
   // Active current renderwindow
   virtual void MakeCurrent();
 
   virtual void SetDataStorage( mitk::DataStorage* storage );  ///< set the datastorage that will be used for rendering
 
   virtual void InitRenderer(vtkRenderWindow* renderwindow);
   virtual void Update(mitk::DataNode* datatreenode);
   virtual void SetMapperID(const MapperSlotId mapperId);
 
   // Size
   virtual void InitSize(int w, int h);
   virtual void Resize(int w, int h);
 
   // Picking
   enum PickingMode{ WorldPointPicking, PointPicking };
   itkSetEnumMacro( PickingMode, PickingMode );
   itkGetEnumMacro( PickingMode, PickingMode );
 
   virtual void PickWorldPoint(const Point2D& displayPoint, Point3D& worldPoint) const;
   virtual mitk::DataNode *PickObject( const Point2D &displayPosition, Point3D &worldPosition ) const;
 
   // Simple text rendering method
-  int WriteSimpleText(std::string text, double posX, double posY, double color1 = 0.0, double color2 = 1.0, double color3 = 0.0);
+  int WriteSimpleText(std::string text, double posX, double posY, double color1 = 0.0, double color2 = 1.0, double color3 = 0.0, float opacity = 1.0);
   vtkTextProperty * GetTextLabelProperty(int text_id);
 
   // Initialization / geometry handling
 
   /** This method 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.
    */
   virtual bool SetWorldGeometryToDataStorageBounds();
 
   /**
    * \brief Used by vtkPointPicker/vtkPicker.
    * This will query a list of all objects in MITK and provide every vtk based mapper to the picker.
    */
   void InitPathTraversal();
 
   /**
    * \brief Used by vtkPointPicker/vtkPicker.
    * This will query a list of all objects in MITK and provide every vtk based mapper to the picker.
    */
   vtkAssemblyPath* GetNextPath();
 
   const vtkWorldPointPicker *GetWorldPointPicker() const;
   const vtkPointPicker *GetPointPicker() const;
   const vtkCellPicker *GetCellPicker() const;
 
   /**
   * \brief Release vtk-based graphics resources. Called by
   * vtkMitkRenderProp::ReleaseGraphicsResources.
   */
   virtual void ReleaseGraphicsResources(vtkWindow *renWin);
 
   MappersMapType GetMappersMap() const;
 
   static bool useImmediateModeRendering();
 
 protected:
   VtkPropRenderer( const char* name = "VtkPropRenderer", vtkRenderWindow * renWin = NULL, mitk::RenderingManager* rm = NULL );
   virtual ~VtkPropRenderer();
   virtual void Update();
 
 private:
 
   /** \brief This method sets up the camera on the actor (e.g. an image) of all
   * 2D vtkRenderWindows. The view is centered; zooming and panning of VTK are called inside.
   *
   * \image html ImageMapperdisplayGeometry.png
   *
   * Similar to the textured plane of an image
   * (cf. void mitkImageVtkMapper2D::GeneratePlane(mitk::BaseRenderer* renderer,
   * vtkFloatingPointType planeBounds[6])), the mitkDisplayGeometry defines a view plane (or
   * projection plane). This plane is used to set the camera parameters. The view plane
   * center (VC) is important for camera positioning (cf. the image above).
   *
   * The following figure shows the combination of the textured plane and the view plane.
   *
   * \image html cameraPositioning.png
   *
   * The view plane center (VC) is the center of the textured plane (C) and the focal point
   * (FP) at the same time. The FP defines the direction the camera faces. Since
   * the textured plane is always in the XY-plane and orthographic projection is applied, the
   * distance between camera and plane is theoretically irrelevant (because in the orthographic
   * projection the center of projection is at infinity and the size of objects depends only on
   * a scaling parameter). As a consequence, the direction of projection (DOP) is (0; 0; -1).
   * The camera up vector is always defined as (0; 1; 0).
   *
   * \warning Due to a VTK clipping bug the distance between textured plane and camera is really huge.
   * Otherwise, VTK would clip off some slices. Same applies for the clipping range size.
   *
   * \note The camera position is defined through the mitkDisplayGeometry.
   * This facilitates zooming and panning, because the display
   * geometry changes and the textured plane does not.
   *
   * \image html scaling.png
   *
   * The textured plane is scaled to fill the render window via
   * camera->SetParallelScale( imageHeightInMM / 2). In the orthographic projection all extends,
   * angles and sizes are preserved. Therefore, the image is scaled by one parameter which defines
   * the size of the rendered image. A higher value will result in smaller images. In order to render
   * just the whole image, the scale is set to half of the image height in worldcoordinates
   * (cf. the picture above).
   *
   * For zooming purposes, a factor is computed as follows:
   * factor = image height / display height (in worldcoordinates).
   * When the display geometry gets smaller (zoom in), the factor becomes bigger. When the display
   * geometry gets bigger (zoom out), the factor becomes smaller. The used VTK method
   * camera->Zoom( factor ) also works with an inverse scale.
   */
   void AdjustCameraToScene();
 
   // switch between orthogonal opengl projection (2D rendering via mitk::GLMapper2D) and perspective projection (3D rendering)
   void Enable2DOpenGL();
   void Disable2DOpenGL();
 
   // prepare all mitk::mappers for rendering
   void PrepareMapperQueue();
 
   /** \brief Set parallel projection, remove the interactor and the lights of VTK. */
   bool Initialize2DvtkCamera();
 
   bool m_InitNeeded;
   bool m_ResizeNeeded;
   bool m_VtkMapperPresent;
   bool m_NewRenderer;
   MapperSlotId m_CameraInitializedForMapperID;
 
   // Picking
   vtkWorldPointPicker     * m_WorldPointPicker;
   vtkPointPicker          * m_PointPicker;
   vtkCellPicker           * m_CellPicker;
 
   PickingMode               m_PickingMode;
 
   // Explicit use of SmartPointer to avoid circular #includes
   itk::SmartPointer< mitk::Mapper > m_CurrentWorldGeometry2DMapper;
 
   vtkLightKit* m_LightKit;
 
   // sorted list of mappers
   MappersMapType m_MappersMap;
 
   // rendering of text
   vtkRenderer * m_TextRenderer;
   typedef std::map<unsigned int,vtkTextActor*> TextMapType;
   TextMapType m_TextCollection;
 
   DataStorage::SetOfObjects::ConstPointer m_PickingObjects;
   DataStorage::SetOfObjects::const_iterator m_PickingObjectsIterator;
 };
 
 } // namespace mitk
 
 #endif /* MITKVtkPropRenderer_H_HEADER_INCLUDED_C1C29F6D */
diff --git a/Core/Code/Testing/files.cmake b/Core/Code/Testing/files.cmake
index 9ac6730ccd..5adde09786 100644
--- a/Core/Code/Testing/files.cmake
+++ b/Core/Code/Testing/files.cmake
@@ -1,117 +1,118 @@
 
 # tests with no extra command line parameter
 set(MODULE_TESTS
   mitkAccessByItkTest.cpp
   mitkCoreObjectFactoryTest.cpp
   mitkMaterialTest.cpp
   mitkActionTest.cpp
   mitkEnumerationPropertyTest.cpp
   mitkEventTest.cpp
   mitkFocusManagerTest.cpp
   mitkGenericPropertyTest.cpp
   mitkGeometry3DTest.cpp
   mitkGeometryDataToSurfaceFilterTest.cpp
   mitkGlobalInteractionTest.cpp
   mitkImageDataItemTest.cpp
   #mitkImageMapper2DTest.cpp
   mitkImageGeneratorTest.cpp
   mitkBaseDataTest.cpp
   #mitkImageToItkTest.cpp
   mitkInstantiateAccessFunctionTest.cpp
   mitkInteractorTest.cpp
   mitkITKThreadingTest.cpp
   # mitkLevelWindowManagerTest.cpp
   mitkLevelWindowTest.cpp
   mitkMessageTest.cpp
   #mitkPipelineSmartPointerCorrectnessTest.cpp
   mitkPixelTypeTest.cpp
   mitkPlaneGeometryTest.cpp
   mitkPointSetFileIOTest.cpp
   mitkPointSetTest.cpp
   mitkPointSetWriterTest.cpp
   mitkPointSetReaderTest.cpp
   mitkPointSetInteractorTest.cpp
   mitkPropertyTest.cpp
   mitkPropertyListTest.cpp
   #mitkRegistrationBaseTest.cpp
   #mitkSegmentationInterpolationTest.cpp
   mitkSlicedGeometry3DTest.cpp
   mitkSliceNavigationControllerTest.cpp
   mitkStateMachineTest.cpp
   mitkStateTest.cpp
   mitkSurfaceTest.cpp
   mitkSurfaceToSurfaceFilterTest.cpp
   mitkTimeSlicedGeometryTest.cpp
   mitkTransitionTest.cpp
   mitkUndoControllerTest.cpp
   mitkVtkWidgetRenderingTest.cpp
   mitkVerboseLimitedLinearUndoTest.cpp
   mitkWeakPointerTest.cpp
   mitkTransferFunctionTest.cpp
   #mitkAbstractTransformGeometryTest.cpp
   mitkStepperTest.cpp
   itkTotalVariationDenoisingImageFilterTest.cpp
   mitkRenderingManagerTest.cpp
   vtkMitkThickSlicesFilterTest.cpp
   mitkNodePredicateSourceTest.cpp
   mitkVectorTest.cpp
   mitkClippedSurfaceBoundsCalculatorTest.cpp
   #QmitkRenderingTestHelper.cpp
   mitkExceptionTest.cpp
   mitkExtractSliceFilterTest.cpp
   mitkLogTest.cpp
   mitkImageDimensionConverterTest.cpp
+  mitkLoggingAdapterTest.cpp
 )
 
 # test with image filename as an extra command line parameter
 set(MODULE_IMAGE_TESTS
   mitkPlanePositionManagerTest.cpp
   mitkSurfaceVtkWriterTest.cpp
   #mitkImageSliceSelectorTest.cpp
   mitkImageTimeSelectorTest.cpp
   # mitkVtkPropRendererTest.cpp
   mitkDataNodeFactoryTest.cpp
   #mitkSTLFileReaderTest.cpp
 )
 
 # list of images for which the tests are run
 set(MODULE_TESTIMAGES
  # Pic-Factory no more available in Core, test images now in .nrrd format
   US4DCyl.nrrd
   Pic3D.nrrd
   Pic2DplusT.nrrd
   BallBinary30x30x30.nrrd
   binary.stl
   ball.stl
 )
 
 set(MODULE_CUSTOM_TESTS
     #mitkLabeledImageToSurfaceFilterTest.cpp
     #mitkExternalToolsTest.cpp
     mitkDataStorageTest.cpp
     mitkDataNodeTest.cpp
     mitkDicomSeriesReaderTest.cpp
     mitkDICOMLocaleTest.cpp
     mitkEventMapperTest.cpp
     mitkNodeDependentPointSetInteractorTest.cpp
     mitkStateMachineFactoryTest.cpp
     mitkPointSetLocaleTest.cpp
     mitkImageTest.cpp
     mitkImageWriterTest.cpp
     mitkImageVtkMapper2DTest.cpp
     mitkImageVtkMapper2DLevelWindowTest.cpp
     mitkImageVtkMapper2DOpacityTest.cpp
     mitkImageVtkMapper2DColorTest.cpp
     mitkImageVtkMapper2DSwivelTest.cpp
 )
 
 # Create an artificial module initializing class for
 # the usServiceListenerTest.cpp
 usFunctionGenerateModuleInit(testdriver_init_file
                              NAME ${MODULE_NAME}TestDriver
                              DEPENDS "Mitk"
                              VERSION "0.1.0"
                              EXECUTABLE
                             )
 
 set(TEST_CPP_FILES ${testdriver_init_file} mitkRenderingTestHelper.cpp)
diff --git a/Core/Code/Testing/mitkLogTest.cpp b/Core/Code/Testing/mitkLogTest.cpp
index a553fad353..7f35ab327b 100644
--- a/Core/Code/Testing/mitkLogTest.cpp
+++ b/Core/Code/Testing/mitkLogTest.cpp
@@ -1,235 +1,242 @@
 /*===================================================================
 
 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 "mitkCommon.h"
 #include "mitkTestingMacros.h"
 #include <mitkLog.h>
 #include <mitkVector.h>
 #include <itkMultiThreader.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkStandardFileLocations.h>
 
 
 /** Documentation
   *
   * @brief Objects of this class can start an internal thread by calling the Start() method.
   *        The thread is then logging messages until the method Stop() is called. The class
   *        can be used to test if logging is thread-save by using multiple objects and let 
   *        them log simuntanously.
   */
-class mitkTestLoggingThread
+class mitkTestLoggingThread : public itk::Object
 {
+public:
+
+mitkClassMacro(mitkTestLoggingThread,itk::Object);
+mitkNewMacro2Param(mitkTestLoggingThread,int,itk::MultiThreader::Pointer);
+
 protected:
 
+mitkTestLoggingThread(int number, itk::MultiThreader::Pointer MultiThreader)
+  {
+  ThreadID = number;
+  m_MultiThreader = MultiThreader;
+  }
+
 bool LoggingRunning;
 
 int ThreadID;
 
 itk::MultiThreader::Pointer m_MultiThreader;
 
 void LogMessages()
   {
   
   while(LoggingRunning)
     {
     MITK_INFO << "Test info stream in thread " << ThreadID;
     MITK_WARN << "Test warning stream in thread " << ThreadID;
     MITK_DEBUG << "Test debugging stream in thread " << ThreadID;
     MITK_ERROR << "Test error stream in thread " << ThreadID;
     MITK_FATAL << "Test fatal stream in thread " << ThreadID;
 
     }
   }
 
 
 static ITK_THREAD_RETURN_TYPE ThreadStartTracking(void* pInfoStruct)
   {
   /* extract this pointer from Thread Info structure */
   struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
   if (pInfo == NULL)
   {
     return ITK_THREAD_RETURN_VALUE;
   }
   if (pInfo->UserData == NULL)
   {
     return ITK_THREAD_RETURN_VALUE;
   }
   mitkTestLoggingThread *thisthread = (mitkTestLoggingThread*)pInfo->UserData;
 
   if (thisthread != NULL)
     thisthread->LogMessages();
 
   return ITK_THREAD_RETURN_VALUE;
   }
 
 public:
 
-mitkTestLoggingThread(int number, itk::MultiThreader::Pointer MultiThreader)
-  {
-  ThreadID = number;
-  m_MultiThreader = MultiThreader;
-  }
-
 void Start()
   {
   LoggingRunning = true;
   m_MultiThreader->SpawnThread(this->ThreadStartTracking, this);
 
   }
 
 void Stop()
   {
   LoggingRunning = false;
   }
 
 };
 
 /** Documentation
  *
  *  @brief This class holds static test methods to sturcture the test of the mitk logging mechanism.   
  */
 class mitkLogTestClass
 { 
 
 public:
 
 static void TestSimpleLog()
     {
     bool testSucceded = true;
     try
       {
       MITK_INFO << "Test info stream.";
       MITK_WARN << "Test warning stream.";
       MITK_DEBUG << "Test debugging stream."; //only activated if cmake variable is on!
                                               //so no worries if you see no output for this line
       MITK_ERROR << "Test error stream.";
       MITK_FATAL << "Test fatal stream.";
       }
     catch(mitk::Exception e)
       {
       testSucceded = false;
       }  
     MITK_TEST_CONDITION_REQUIRED(testSucceded,"Test logging streams.");
     }
 
 static void TestObjectInfoLogging()
     {
     bool testSucceded = true;
     try
       {
       int i = 123;
       float f = .32234;
       double d = 123123;
       std::string testString = "testString";
       std::stringstream testStringStream;
       testStringStream << "test" << "String" << "Stream";
       mitk::Point3D testMitkPoint;
       testMitkPoint.Fill(2);
       
       MITK_INFO << i;
       MITK_INFO << f;
       MITK_INFO << d;
       MITK_INFO << testString;
       MITK_INFO << testStringStream;
       MITK_INFO << testMitkPoint;      
       }
     catch(mitk::Exception e)
       {
       testSucceded = false;
       }  
     MITK_TEST_CONDITION_REQUIRED(testSucceded,"Test logging of object information.");
     }
 
+
+
+
 static void TestThreadSaveLog()
     {
     bool testSucceded = true;
-
+    
     try
       {
       //initialize two threads...
-      itk::MultiThreader::Pointer myThreader = itk::MultiThreader::New();
-      mitkTestLoggingThread myThreadClass1 = mitkTestLoggingThread(1,myThreader);
-      mitkTestLoggingThread myThreadClass2 = mitkTestLoggingThread(2,myThreader);
+      itk::MultiThreader::Pointer multiThreader = itk::MultiThreader::New();
+      mitkTestLoggingThread::Pointer myThreadClass1 = mitkTestLoggingThread::New(1,multiThreader);
+      mitkTestLoggingThread::Pointer myThreadClass2 = mitkTestLoggingThread::New(2,multiThreader);
       
       //start them
-      myThreadClass1.Start();
-      myThreadClass2.Start();
+      myThreadClass1->Start();
+      myThreadClass2->Start();
 
       //wait for 500 ms
       itksys::SystemTools::Delay(500);
 
-
       //stop them
-      myThreadClass1.Stop();
-      myThreadClass2.Stop();
+      myThreadClass1->Stop();
+      myThreadClass2->Stop();
 
       //Wait for all threads to end
-      myThreader->TerminateThread(1);
-      myThreader->TerminateThread(2);
+      multiThreader->TerminateThread(1);
+      multiThreader->TerminateThread(2);
       }
     catch(...)
       {
       testSucceded = false;
       }
 
     //if no error occured until now, everything is ok
     MITK_TEST_CONDITION_REQUIRED(testSucceded,"Test logging in different threads.");
     }
 
 static void TestLoggingToFile()
     {
     std::string filename = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory() + "/testlog.log";
     mitk::LoggingBackend::SetLogFile(filename.c_str());
     MITK_INFO << "Test logging to default filename: " << mitk::LoggingBackend::GetLogFile();
     MITK_TEST_CONDITION_REQUIRED(itksys::SystemTools::FileExists(filename.c_str()),"Testing if log file exists.");
     //TODO delete log file?
     }
 
 static void TestAddAndRemoveBackends()
     {
     mbilog::BackendCout myBackend = mbilog::BackendCout();
     mbilog::RegisterBackend(&myBackend);
     MITK_INFO << "Test logging";
     mbilog::UnregisterBackend(&myBackend);
 
     //if no error occured until now, everything is ok
     MITK_TEST_CONDITION_REQUIRED(true,"Test add/remove logging backend.");
     }
 
 static void  TestDefaultBackend()
     {
     //not possible now, because we cannot unregister the mitk logging backend in the moment. If such a method is added to mbilog utility one may add this test.
     }
 
 
 };
 
 int mitkLogTest(int /* argc */, char* /*argv*/[])
 {
   // always start with this!
   MITK_TEST_BEGIN("Log")
 
   MITK_TEST_OUTPUT(<<"TESTING ALL LOGGING OUTPUTS, ERROR MESSAGES ARE ALSO TESTED AND NOT MEANING AN ERROR OCCURED!")
   
   mitkLogTestClass::TestSimpleLog();
   mitkLogTestClass::TestObjectInfoLogging();
   mitkLogTestClass::TestThreadSaveLog();
   mitkLogTestClass::TestLoggingToFile();
   mitkLogTestClass::TestAddAndRemoveBackends();
   
   // always end with this!
   MITK_TEST_END()
 }
diff --git a/Core/Code/Testing/mitkLoggingAdapterTest.cpp b/Core/Code/Testing/mitkLoggingAdapterTest.cpp
new file mode 100644
index 0000000000..7b83cb6da1
--- /dev/null
+++ b/Core/Code/Testing/mitkLoggingAdapterTest.cpp
@@ -0,0 +1,86 @@
+/*===================================================================
+
+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 "mitkTestingMacros.h"
+#include <mitkVtkLoggingAdapter.h>
+#include <mitkItkLoggingAdapter.h>
+#include <mitkCommon.h>
+
+class ItkLoggingTestClass : public itk::Object
+  {
+  public: 
+
+    mitkClassMacro( ItkLoggingTestClass , itk::Object );
+    itkNewMacro( ItkLoggingTestClass );
+
+    void TestItkWarningMessage()
+      {
+      itkWarningMacro("Test ITK Warning message");
+      }
+   
+  };
+
+/** @brief This test tests all logging adapters of MITK. */
+class LoggingAdapterTestClass
+{
+public: 
+  
+  static void TestVtkLoggingWithoutAdapter()
+    {
+    MITK_TEST_OUTPUT(<<"Testing vtk logging without adapter class: a separate window should open and display the logging messages.")
+    vtkOutputWindow::GetInstance()->DisplayText("Test VTK InfoMessage");
+    vtkOutputWindow::GetInstance()->DisplayDebugText("Test Vtk Debug Message");
+    vtkOutputWindow::GetInstance()->DisplayGenericWarningText("Test Vtk Generic Warning Message");
+    vtkOutputWindow::GetInstance()->DisplayWarningText("Test Vtk Warning Message");
+    vtkOutputWindow::GetInstance()->DisplayErrorText("Test Vtk Error Message");
+    MITK_TEST_CONDITION_REQUIRED(true,"Testing if Vtk logging without adapter runs without errors.");
+    }
+  static void TestVtkLoggingWithAdapter()
+    {
+    MITK_TEST_OUTPUT(<<"Testing vtk logging with adapter class: Vtk logging messages should be logged as MITK logging messages.")
+    mitk::VtkLoggingAdapter::Initialize();
+    vtkOutputWindow::GetInstance()->DisplayText("Test Vtk Info Message");
+    vtkOutputWindow::GetInstance()->DisplayDebugText("Test Vtk Debug Message");
+    vtkOutputWindow::GetInstance()->DisplayGenericWarningText("Test Vtk Generic Warning Message");
+    vtkOutputWindow::GetInstance()->DisplayWarningText("Test Vtk Warning Message");
+    vtkOutputWindow::GetInstance()->DisplayErrorText("Test Vtk Error Message");
+    MITK_TEST_CONDITION_REQUIRED(true,"Testing if Vtk logging with MITK logging adapter runs without errors.");
+    }
+
+  static void TestItkLoggingWithoutAdapter()
+    {
+    ItkLoggingTestClass::Pointer myItkLogger = ItkLoggingTestClass::New();
+    myItkLogger->TestItkWarningMessage();
+    }
+
+  static void TestItkLoggingWithAdapter()
+    {
+    mitk::ItkLoggingAdapter::Initialize();
+    ItkLoggingTestClass::Pointer myItkLogger = ItkLoggingTestClass::New();
+    myItkLogger->TestItkWarningMessage();
+    }
+};
+
+int mitkLoggingAdapterTest(int /*argc*/, char* /*argv*/[])
+{
+  MITK_TEST_BEGIN("LoggingAdapters: VTK, ITK");
+  LoggingAdapterTestClass::TestVtkLoggingWithoutAdapter();
+  LoggingAdapterTestClass::TestVtkLoggingWithAdapter();
+  LoggingAdapterTestClass::TestItkLoggingWithoutAdapter();
+  LoggingAdapterTestClass::TestItkLoggingWithAdapter();
+  MITK_TEST_END();
+}
diff --git a/Core/Code/files.cmake b/Core/Code/files.cmake
index ddf02e27e2..f3ee81de50 100644
--- a/Core/Code/files.cmake
+++ b/Core/Code/files.cmake
@@ -1,304 +1,306 @@
 set(H_FILES
   Algorithms/itkImportMitkImageContainer.h
   Algorithms/itkImportMitkImageContainer.txx
   Algorithms/itkLocalVariationImageFilter.h
   Algorithms/itkLocalVariationImageFilter.txx
   Algorithms/itkMITKScalarImageToHistogramGenerator.h
   Algorithms/itkMITKScalarImageToHistogramGenerator.txx
   Algorithms/itkTotalVariationDenoisingImageFilter.h
   Algorithms/itkTotalVariationDenoisingImageFilter.txx
   Algorithms/itkTotalVariationSingleIterationImageFilter.h
   Algorithms/itkTotalVariationSingleIterationImageFilter.txx
   Algorithms/mitkBilateralFilter.h
   Algorithms/mitkBilateralFilter.cpp
   Algorithms/mitkInstantiateAccessFunctions.h
   Algorithms/mitkPixelTypeList.h
   # Preprocessor macros taken from Boost
   Algorithms/mitkPPArithmeticDec.h
   Algorithms/mitkPPArgCount.h
   Algorithms/mitkPPCat.h
   Algorithms/mitkPPConfig.h
   Algorithms/mitkPPControlExprIIf.h
   Algorithms/mitkPPControlIf.h
   Algorithms/mitkPPControlIIf.h
   Algorithms/mitkPPDebugError.h
   Algorithms/mitkPPDetailAutoRec.h
   Algorithms/mitkPPDetailDMCAutoRec.h
   Algorithms/mitkPPExpand.h
   Algorithms/mitkPPFacilitiesEmpty.h
   Algorithms/mitkPPFacilitiesExpand.h
   Algorithms/mitkPPLogicalBool.h
   Algorithms/mitkPPRepetitionDetailDMCFor.h
   Algorithms/mitkPPRepetitionDetailEDGFor.h
   Algorithms/mitkPPRepetitionDetailFor.h
   Algorithms/mitkPPRepetitionDetailMSVCFor.h
   Algorithms/mitkPPRepetitionFor.h
   Algorithms/mitkPPSeqElem.h
   Algorithms/mitkPPSeqForEach.h
   Algorithms/mitkPPSeqForEachProduct.h
   Algorithms/mitkPPSeq.h
   Algorithms/mitkPPSeqEnum.h
   Algorithms/mitkPPSeqSize.h
   Algorithms/mitkPPSeqToTuple.h
   Algorithms/mitkPPStringize.h
   Algorithms/mitkPPTupleEat.h
   Algorithms/mitkPPTupleElem.h
   Algorithms/mitkPPTupleRem.h
   Algorithms/mitkClippedSurfaceBoundsCalculator.h
   Algorithms/mitkExtractSliceFilter.h
   Algorithms/mitkConvert2Dto3DImageFilter.h 
   DataManagement/mitkImageAccessByItk.h
   DataManagement/mitkImageCast.h
   DataManagement/mitkITKImageImport.h
   DataManagement/mitkITKImageImport.txx
   DataManagement/mitkImageToItk.h
   DataManagement/mitkImageToItk.txx
   
   Interfaces/mitkIDataNodeReader.h
 
   IO/mitkPixelTypeTraits.h
   
   Interactions/mitkEventMapperAddOn.h
   
   Common/mitkExceptionMacro.h
   Common/mitkTestingMacros.h
    
 )
 
 set(CPP_FILES
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkBaseProcess.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkCoreActivator.cpp
   Controllers/mitkFocusManager.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.cpp
   Controllers/mitkSlicesRotator.cpp
   Controllers/mitkSlicesSwiveller.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkInteractorCameraController.cpp
   Controllers/mitkVtkLayerController.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataStorage.cpp
   #DataManagement/mitkDataTree.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataNodeFactory.cpp
   #DataManagement/mitkDataTreeStorage.cpp
   DataManagement/mitkDisplayGeometry.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkGeometry2D.cpp
   DataManagement/mitkGeometry2DData.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkLandmarkBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModeOperation.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStateTransitionOperation.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTimeSlicedGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkVector.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkShaderProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkMaterial.cpp
   Interactions/mitkAction.cpp
   Interactions/mitkAffineInteractor.cpp
   Interactions/mitkCoordinateSupplier.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkDisplayInteractor.cpp
   Interactions/mitkDisplayPositionEvent.cpp
   Interactions/mitkDisplayVectorInteractor.cpp
   Interactions/mitkDisplayVectorInteractorLevelWindow.cpp
   Interactions/mitkDisplayVectorInteractorScroll.cpp
   Interactions/mitkEvent.cpp
   Interactions/mitkEventDescription.cpp
   Interactions/mitkEventMapper.cpp
   Interactions/mitkGlobalInteraction.cpp
   Interactions/mitkInteractor.cpp
   Interactions/mitkMouseModeSwitcher.cpp
   Interactions/mitkMouseMovePointSetInteractor.cpp
   Interactions/mitkMoveSurfaceInteractor.cpp
   Interactions/mitkNodeDepententPointSetInteractor.cpp
   Interactions/mitkPointSetInteractor.cpp
   Interactions/mitkPositionEvent.cpp
   Interactions/mitkPositionTracker.cpp
   Interactions/mitkState.cpp
   Interactions/mitkStateEvent.cpp
   Interactions/mitkStateMachine.cpp
   Interactions/mitkStateMachineFactory.cpp
   Interactions/mitkTransition.cpp
   Interactions/mitkWheelEvent.cpp
   Interactions/mitkKeyEvent.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkCrosshairPositionEvent.cpp
   IO/mitkBaseDataIOFactory.cpp
   IO/mitkCoreDataNodeReader.cpp
   IO/mitkDicomSeriesReader.cpp
   IO/mitkFileReader.cpp
   IO/mitkFileSeriesReader.cpp
   IO/mitkFileWriter.cpp
   #IO/mitkIpPicGet.c
   IO/mitkImageGenerator.cpp
   IO/mitkImageWriter.cpp
   IO/mitkImageWriterFactory.cpp
   IO/mitkItkImageFileIOFactory.cpp
   IO/mitkItkImageFileReader.cpp
+  IO/mitkItkLoggingAdapter.cpp
   IO/mitkItkPictureWrite.cpp
   IO/mitkIOUtil.cpp
   IO/mitkLookupTableProperty.cpp
   IO/mitkOperation.cpp
   #IO/mitkPicFileIOFactory.cpp
   #IO/mitkPicFileReader.cpp
   #IO/mitkPicFileWriter.cpp
   #IO/mitkPicHelper.cpp
   #IO/mitkPicVolumeTimeSeriesIOFactory.cpp
   #IO/mitkPicVolumeTimeSeriesReader.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetIOFactory.cpp
   IO/mitkPointSetReader.cpp
   IO/mitkPointSetWriter.cpp
   IO/mitkPointSetWriterFactory.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSTLFileIOFactory.cpp
   IO/mitkSTLFileReader.cpp
   IO/mitkSurfaceVtkWriter.cpp
   IO/mitkSurfaceVtkWriterFactory.cpp
+  IO/mitkVtkLoggingAdapter.cpp
   IO/mitkVtiFileIOFactory.cpp
   IO/mitkVtiFileReader.cpp
   IO/mitkVtkImageIOFactory.cpp
   IO/mitkVtkImageReader.cpp
   IO/mitkVtkSurfaceIOFactory.cpp
   IO/mitkVtkSurfaceReader.cpp
   IO/vtkPointSetXMLParser.cpp
   IO/mitkLog.cpp
   Rendering/mitkBaseRenderer.cpp
   Rendering/mitkVtkMapper2D.cpp
   Rendering/mitkVtkMapper3D.cpp
   Rendering/mitkRenderWindowFrame.cpp
   Rendering/mitkGeometry2DDataMapper2D.cpp
   Rendering/mitkGeometry2DDataVtkMapper3D.cpp
   Rendering/mitkGLMapper2D.cpp
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkManufacturerLogo.cpp
   Rendering/mitkMapper2D.cpp
   Rendering/mitkMapper3D.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkPointSetGLMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkPolyDataGLMapper2D.cpp
   Rendering/mitkSurfaceGLMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVolumeDataVtkMapper3D.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkShaderRepository.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkMitkApplyLevelWindowToRGBFilter.cpp
 
   Common/mitkException.cpp
   Common/mitkCommon.h
   Common/mitkCoreObjectFactoryBase.cpp
   Common/mitkCoreObjectFactory.cpp
 )
 
 list(APPEND CPP_FILES ${CppMicroServices_SOURCES})
diff --git a/Documentation/Doxygen/Modules/Modules.dox b/Documentation/Doxygen/Modules/Modules.dox
index 57ee480242..67cd78f73e 100644
--- a/Documentation/Doxygen/Modules/Modules.dox
+++ b/Documentation/Doxygen/Modules/Modules.dox
@@ -1,123 +1,123 @@
 /**
   \defgroup Core Core Classes
   
   \brief This category includes classes of the MITK Core library.
 */
 
 /**
   \defgroup Data Data Classes
   \ingroup DataManagement
 
   \brief This subcategory includes the data classes, e.g., for images (mitk::Image), 
   surfaces (mitk::Surface), vessel-trees (mitk::VesselTreeData), etc. 
 
   Data access classes are only included, if there is no equivalent in itk (see 
   \ref ProcessAndAdaptorClasses "Process and Adaptor Classes" below).
 */
 
 /**
   \defgroup IO IO Classes
   \ingroup DataManagement
 
   \brief This subcategory includes the IO classes to read or write data objects.
 */
 
 /**
   \defgroup DataStorage Data Storage Classes
   \ingroup DataManagement
 
   \brief This subcategory includes the classes to store and retrieve objects from the mitk::DataStorage
 */
 
 /**
   \defgroup ProcessAdaptor Process and Adaptor Classes
   \ingroup Core
   \anchor ProcessAndAdaptorClasses
 
   \brief This category includes process (algorithm) classes developed specifically for mitk and 
   (mainly) adaptor classes for the integration of algorithms from other toolkits 
   (currently vtk, itk).
 
   The itk adaptor classes are also useful for data access to mitk data objects.
 */
 
 /**
   \defgroup Process Process Classes
   \ingroup ProcessAdaptor
 
   \brief This subcategory includes process (algorithm) classes developed specifically for mitk.
 */
 
 /**
   \defgroup InteractionUndo Interaction and Undo Classes
   \ingroup Core
 
   \brief This category includes classes that support the developer to create 
   software that allows the user to interact with the data. 
   
   This includes complex interactions that have multiple states (e.g., moving a handle of an 
   active contour vs changing its local elasicity) and a concept to realize an undo/redo-mechanism.
      
   A detailed description of the rationale for these classes can be found in
   \ref InteractionPage.
 */
 
 /**
   \defgroup Interaction Interaction Classes
   \ingroup InteractionUndo
 
   \brief This subcategory includes interaction classes (subclasses of mitk::StateMachine) that change
   the data according to the input of the user. 
   
   For undo-support, the change is done by sending an OperationEvent to the respective 
   data object, which changes itself accordingly.
    
   A detailed description of the rationale for these classes can be found in
   \ref InteractionPage.
 */
 
 /**
   \defgroup Undo Undo Classes
   \ingroup InteractionUndo
 
   \brief This subcategory includes the undo/redo-specific classes. 
   
   For undo-support, the change is done by sending an OperationEvent to the respective data object, 
   which changes itself accordingly.
   
   A detailed description of the rationale for these classes can be found in
   \ref InteractionPage.
 */
  
 /**
-  \defgroup ToolManagerEtAl Classes related to the Segmentation bundle
+  \defgroup ToolManagerEtAl Classes related to the Segmentation plugin
 
-  \brief A couple of classes related to the Segmentation bundle. See also
+  \brief A couple of classes related to the Segmentation plugin. See also
   \ref QmitkSegmentationTechnicalPage
 */
 
 /**
   \defgroup Registration Registration
 
   \brief A couple of classes related to registration.
 */
 
 /**
   \defgroup RigidRegistration Classes related to rigid registration
   \ingroup Registration
   
   \brief A couple of classes related to rigid registration.
 */
 
 /**
   \defgroup PointBasedRegistration Classes related to point based registration
   \ingroup Registration
   
   \brief A couple of classes related to point based registration.
 */
 
 /**
   \defgroup MITKPlugins MITK Plugins
   
   \brief This group includes all MITK Plugins
 */
diff --git a/Documentation/Doxygen/UserManual/Applications.dox b/Documentation/Doxygen/UserManual/Applications.dox
index 65f1b1e6c6..2a6b7db404 100644
--- a/Documentation/Doxygen/UserManual/Applications.dox
+++ b/Documentation/Doxygen/UserManual/Applications.dox
@@ -1,30 +1,30 @@
 /**
 \page ApplicationsPage Using MITK and Applications
 
 Available sections:
   - \ref ApplicationsPageUsingMITK
   - \ref ApplicationsPageApplications
   - \ref ApplicationsPageApplicationsList
 
 \section ApplicationsPageUsingMITK Using MITK
 
-Many of the applications created with the use of MITK share common basic functionalities. Due to this, there is one manual which explains the basic usage of MITK. For more information on the use of the advanced features of an application please take a look the \ref ApplicationsPageApplicationsList , whereas if you are interested in a certain view further information can be found in \ref ModuleListPage .
+Many of the applications created with the use of MITK share common basic functionalities. Due to this, there is one manual which explains the basic usage of MITK. For more information on the use of the advanced features of an application please take a look the \ref ApplicationsPageApplicationsList , whereas if you are interested in a certain view further information can be found in \ref PluginListPage .
 
 The basic usage information on MITK can be found in \subpage MITKUserManualPage .
 
 \section ApplicationsPageApplications What are Applications?
 
 Applications are executables, which contain a certain configuration of views and perspectives. Usually they are aimed at a selective audience or solving a particular problem. As such they focus on certain capabilities of MITK, while ignoring others. The main reason for this is to supply the users of the application with the power of MITK for solving their tasks, without daunting them with an overwhelming number of menus and options. At the same time, this allows, together with the use of perspectives, the creation of sleek and elegant workflows, which are easily comprehensible.
 
 A typical example of this would be an application which contains only views related to the analysis of the human brain (particular question) or one which contains only what is necessary for displaying medical data in the classroom (specific audience).
   
 \section ApplicationsPageApplicationsList List of Applications
 
 If you are interested in using a specific application, currently developed by the MITK team you might want to take a look first at the \ref MITKUserManualPage . Further information on any application can be found here:
 <ul>
-  <li> \subpage org_extapplication
+  <li> \subpage org_mitkworkbench
   <li> \subpage org_dti_atlas_application
-  <li> \subpage org_diffusionapplication
+  <li> \subpage org_mitk_gui_qt_diffusionimagingapp
 </ul>
 
 */
\ No newline at end of file
diff --git a/Documentation/Doxygen/UserManual/MITKModuleManualsList.dox b/Documentation/Doxygen/UserManual/MITKModuleManualsList.dox
new file mode 100644
index 0000000000..63000a2782
--- /dev/null
+++ b/Documentation/Doxygen/UserManual/MITKModuleManualsList.dox
@@ -0,0 +1,17 @@
+/**
+\page MITKModuleManualsListPage MITK Module Manuals
+
+\section MITKModuleManualsListPageOverview Overview
+
+The modules are shared libraries that provide functionality that can be used by developers.
+
+\section MITKModuleManualsListPageModuleManualList List of Module Manuals
+
+  \li \subpage IGTGeneralModulePage
+
+\section MITKModuleManualsListPageAdditionalInformation Additional Information on Certain Modules
+
+  \li \ref PlanarPropertiesPage
+  \li \subpage DiffusionImagingPropertiesPage
+
+*/
diff --git a/Documentation/Doxygen/UserManual/MITKPluginManualsList.dox b/Documentation/Doxygen/UserManual/MITKPluginManualsList.dox
new file mode 100644
index 0000000000..26c53b8a28
--- /dev/null
+++ b/Documentation/Doxygen/UserManual/MITKPluginManualsList.dox
@@ -0,0 +1,37 @@
+/**
+\page PluginListPage MITK Plugin Manuals
+
+\section PluginListPageOverview Overview
+
+The plugins and bundles provide much of the extended functionality of MITK. Each encapsulates a solution to a problem and associated features. This way one can easily assemble the necessary capabilites for a workflow without adding a lot of bloat, by combining plugins as needed.
+
+The distinction between developer and end user use is for convenience only and mainly distinguishes which group a plugin is primarily aimed at.
+
+\section PluginListPageEndUserPluginList List of Plugins for End User Use
+
+  \li \subpage org_mitk_views_basicimageprocessing
+  \li \subpage org_mitk_views_datamanager
+  \li \subpage org_mitk_gui_qt_diffusionimaging
+  \li \subpage org_mitk_views_imagecropper
+  \li \subpage org_mitk_views_imagenavigator
+  \li \subpage org_mitk_gui_qt_measurementtoolbox
+  \li \subpage org_mitk_views_moviemaker
+  \li \subpage org_mitk_views_meshdecimation
+  \li \subpage org_mitk_views_pointsetinteraction
+  \li \subpage org_mitk_gui_qt_registration
+  \li \subpage org_mitk_views_segmentation
+  \li \subpage org_mitk_views_volumevisualization
+  \li \subpage org_mitk_gui_qt_dicom
+  \li \subpage org_mitk_gui_qt_ultrasound
+
+\section PluginListPageDevPluginList List of Plugins for Developer Use and Examples
+
+  \li \subpage org_surfacematerialeditor
+  \li \subpage org_toftutorial
+  \li \subpage org_mitk_gui_qt_examples
+  \li \subpage org_mitkexamplesopencv
+  \li \ref org_mitk_gui_qt_igtexample
+  \li \ref org_mitk_gui_qt_igttracking
+
+
+*/
diff --git a/Documentation/Doxygen/UserManual/ModuleList.dox b/Documentation/Doxygen/UserManual/ModuleList.dox
deleted file mode 100644
index 7e7c4e61f1..0000000000
--- a/Documentation/Doxygen/UserManual/ModuleList.dox
+++ /dev/null
@@ -1,34 +0,0 @@
-/**
-\page ModuleListPage MITK Modules
-
-\section ModuleListPageOverview Overview
-
-The modules and bundles provide much of the extended functionality of MITK. Each encapsulates a solution to a problem and associated features. This way one can easily assemble the necessary capabilites for a workflow without adding a lot of bloat, by combining modules as needed.
-
-The distinction between developer and end user use is for convenience only and mainly distinguishes which group a module is primarily aimed at.
-
-\section ModuleListPageEndUserModuleList List of Modules for End User Use
-
-  \li \subpage org_basicimageprocessing
-  \li \subpage org_datamanager
-  \li \subpage org_diffusion
-  \li \subpage IGTGeneralModulePage
-  \li \subpage org_imagecropper
-  \li \subpage org_imagenavigator
-  \li \subpage org_measurementtoolbox
-  \li \subpage org_moviemaker
-  \li \subpage org_meshdecimation
-  \li \subpage org_pointsetinteraction
-  \li \subpage RegistrationModuleOverviewPage
-  \li \subpage org_segment
-  \li \subpage org_volvis
-  
-\section ModuleListPageDevModuleList List of Modules for Developer Use and Examples
-
-  \li \subpage org_surfacematerialeditor
-  \li \subpage org_toftutorial
-  \li \subpage org_mitkexamples
-  \li \subpage org_mitkexamplesopencv
-
-  
-*/
diff --git a/Documentation/MITKDoxygenLayout.xml b/Documentation/MITKDoxygenLayout.xml
new file mode 100644
index 0000000000..19afb000f9
--- /dev/null
+++ b/Documentation/MITKDoxygenLayout.xml
@@ -0,0 +1,188 @@
+<doxygenlayout version="1.0">
+  <!-- Navigation index tabs for HTML output -->
+  <navindex>
+    <tab type="mainpage" visible="yes" title=""/>
+    <tab type="pages" visible="yes" title="" intro=""/>
+    <tab type="modules" visible="yes" title="MITK API Documentation" intro="The following documentation is available for the MITK API"/>
+    <tab type="namespaces" visible="yes" title="">
+      <tab type="namespacelist" visible="yes" title="" intro=""/>
+      <tab type="namespacemembers" visible="yes" title="" intro=""/>
+    </tab>
+    <tab type="classes" visible="yes" title="">
+      <tab type="classlist" visible="yes" title="" intro=""/>
+      <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
+      <tab type="hierarchy" visible="yes" title="" intro=""/>
+      <tab type="classmembers" visible="yes" title="" intro=""/>
+    </tab>
+    <tab type="files" visible="yes" title="">
+      <tab type="filelist" visible="yes" title="" intro=""/>
+      <tab type="globals" visible="yes" title="" intro=""/>
+    </tab>
+    <tab type="dirs" visible="yes" title="" intro=""/>
+    <tab type="examples" visible="yes" title="" intro=""/>
+  </navindex>
+
+  <!-- Layout definition for a class page -->
+  <class>
+    <briefdescription visible="yes"/>
+    <includes visible="$SHOW_INCLUDE_FILES"/>
+    <inheritancegraph visible="$CLASS_GRAPH"/>
+    <collaborationgraph visible="$COLLABORATION_GRAPH"/>
+    <allmemberslink visible="yes"/>
+    <memberdecl>
+      <nestedclasses visible="yes" title=""/>
+      <publictypes title=""/>
+      <publicslots title=""/>
+      <signals title=""/>
+      <publicmethods title=""/>
+      <publicstaticmethods title=""/>
+      <publicattributes title=""/>
+      <publicstaticattributes title=""/>
+      <protectedtypes title=""/>
+      <protectedslots title=""/>
+      <protectedmethods title=""/>
+      <protectedstaticmethods title=""/>
+      <protectedattributes title=""/>
+      <protectedstaticattributes title=""/>
+      <packagetypes title=""/>
+      <packagemethods title=""/>
+      <packagestaticmethods title=""/>
+      <packageattributes title=""/>
+      <packagestaticattributes title=""/>
+      <properties title=""/>
+      <events title=""/>
+      <privatetypes title=""/>
+      <privateslots title=""/>
+      <privatemethods title=""/>
+      <privatestaticmethods title=""/>
+      <privateattributes title=""/>
+      <privatestaticattributes title=""/>
+      <friends title=""/>
+      <related title="" subtitle=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <inlineclasses title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <constructors title=""/>
+      <functions title=""/>
+      <related title=""/>
+      <variables title=""/>
+      <properties title=""/>
+      <events title=""/>
+    </memberdef>
+    <usedfiles visible="$SHOW_USED_FILES"/>
+    <authorsection visible="yes"/>
+  </class>
+
+  <!-- Layout definition for a namespace page -->
+  <namespace>
+    <briefdescription visible="yes"/>
+    <memberdecl>
+      <nestednamespaces visible="yes" title=""/>
+      <classes visible="yes" title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <inlineclasses title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+    </memberdef>
+    <authorsection visible="yes"/>
+  </namespace>
+
+  <!-- Layout definition for a file page -->
+  <file>
+    <briefdescription visible="yes"/>
+    <includes visible="$SHOW_INCLUDE_FILES"/>
+    <includegraph visible="$INCLUDE_GRAPH"/>
+    <includedbygraph visible="$INCLUDED_BY_GRAPH"/>
+    <sourcelink visible="yes"/>
+    <memberdecl>
+      <classes visible="yes" title=""/>
+      <namespaces visible="yes" title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <inlineclasses title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+    </memberdef>
+    <authorsection/>
+  </file>
+
+  <!-- Layout definition for a group page -->
+  <group>
+    <briefdescription visible="yes"/>
+    <groupgraph visible="$GROUP_GRAPHS"/>
+    <memberdecl>
+      <nestedgroups visible="yes" title=""/>
+      <dirs visible="yes" title=""/>
+      <files visible="yes" title=""/>
+      <namespaces visible="yes" title=""/>
+      <classes visible="yes" title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <enumvalues title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <signals title=""/>
+      <publicslots title=""/>
+      <protectedslots title=""/>
+      <privateslots title=""/>
+      <events title=""/>
+      <properties title=""/>
+      <friends title=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <pagedocs/>
+      <inlineclasses title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <enumvalues title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <signals title=""/>
+      <publicslots title=""/>
+      <protectedslots title=""/>
+      <privateslots title=""/>
+      <events title=""/>
+      <properties title=""/>
+      <friends title=""/>
+    </memberdef>
+    <authorsection visible="yes"/>
+  </group>
+
+  <!-- Layout definition for a directory page -->
+  <directory>
+    <briefdescription visible="yes"/>
+    <directorygraph visible="yes"/>
+    <memberdecl>
+      <dirs visible="yes"/>
+      <files visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+  </directory>
+</doxygenlayout>
diff --git a/Documentation/doxygen.conf.in b/Documentation/doxygen.conf.in
index f6eb26cfe3..42076c5282 100644
--- a/Documentation/doxygen.conf.in
+++ b/Documentation/doxygen.conf.in
@@ -1,1912 +1,1914 @@
 # Doxyfile 1.8.0
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
 #
 # All text after a hash (#) is considered a comment and will be ignored.
 # The format is:
 #       TAG = value [value, ...]
 # For lists items can also be appended using:
 #       TAG += value [value, ...]
 # Values that contain spaces should be placed between quotes (" ").
 
 #---------------------------------------------------------------------------
 # Project related configuration options
 #---------------------------------------------------------------------------
 
 # This tag specifies the encoding used for all characters in the config file
 # that follow. The default is UTF-8 which is also the encoding used for all
 # text before the first occurrence of this tag. Doxygen uses libiconv (or the
 # iconv built into libc) for the transcoding. See
 # http://www.gnu.org/software/libiconv for the list of possible encodings.
 
 DOXYFILE_ENCODING      = UTF-8
 
 # The PROJECT_NAME tag is a single word (or sequence of words) that should
 # identify the project. Note that if you do not use Doxywizard you need
 # to put quotes around the project name if it contains spaces.
 
 PROJECT_NAME           = MITK
 
 # The PROJECT_NUMBER tag can be used to enter a project or revision number.
 # This could be handy for archiving the generated documentation or
 # if some version control system is used.
 
 PROJECT_NUMBER         = @MITK_VERSION_STRING@
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer
 # a quick idea about the purpose of the project. Keep the description short.
 
 PROJECT_BRIEF          = "Medical Imaging Interaction Toolkit"
 
 # With the PROJECT_LOGO tag one can specify an logo or icon that is
 # included in the documentation. The maximum height of the logo should not
 # exceed 55 pixels and the maximum width should not exceed 200 pixels.
 # Doxygen will copy the logo to the output directory.
 
 PROJECT_LOGO           =
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
 # base path where the generated documentation will be put.
 # If a relative path is entered, it will be relative to the location
 # where doxygen was started. If left blank the current directory will be used.
 
 OUTPUT_DIRECTORY       = @MITK_DOXYGEN_OUTPUT_DIR@
 
 # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
 # 4096 sub-directories (in 2 levels) under the output directory of each output
 # format and will distribute the generated files over these directories.
 # Enabling this option can be useful when feeding doxygen a huge amount of
 # source files, where putting all generated files in the same directory would
 # otherwise cause performance problems for the file system.
 
 CREATE_SUBDIRS         = NO
 
 # The OUTPUT_LANGUAGE tag is used to specify the language in which all
 # documentation generated by doxygen is written. Doxygen will use this
 # information to generate all constant output in the proper language.
 # The default language is English, other supported languages are:
 # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
 # Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
 # Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
 # messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
 # Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
 # Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
 
 OUTPUT_LANGUAGE        = English
 
 # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
 # include brief member descriptions after the members that are listed in
 # the file and class documentation (similar to JavaDoc).
 # Set to NO to disable this.
 
 BRIEF_MEMBER_DESC      = YES
 
 # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
 # the brief description of a member or function before the detailed description.
 # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
 # brief descriptions will be completely suppressed.
 
 REPEAT_BRIEF           = YES
 
 # This tag implements a quasi-intelligent brief description abbreviator
 # that is used to form the text in various listings. Each string
 # in this list, if found as the leading text of the brief description, will be
 # stripped from the text and the result after processing the whole list, is
 # used as the annotated text. Otherwise, the brief description is used as-is.
 # If left blank, the following values are used ("$name" is automatically
 # replaced with the name of the entity): "The $name class" "The $name widget"
 # "The $name file" "is" "provides" "specifies" "contains"
 # "represents" "a" "an" "the"
 
 ABBREVIATE_BRIEF       =
 
 # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
 # Doxygen will generate a detailed section even if there is only a brief
 # description.
 
 ALWAYS_DETAILED_SEC    = NO
 
 # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
 # inherited members of a class in the documentation of that class as if those
 # members were ordinary class members. Constructors, destructors and assignment
 # operators of the base classes will not be shown.
 
 INLINE_INHERITED_MEMB  = NO
 
 # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
 # path before files name in the file list and in the header files. If set
 # to NO the shortest path that makes the file name unique will be used.
 
 FULL_PATH_NAMES        = NO
 
 # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
 # can be used to strip a user-defined part of the path. Stripping is
 # only done if one of the specified strings matches the left-hand part of
 # the path. The tag can be used to show relative paths in the file list.
 # If left blank the directory from which doxygen is run is used as the
 # path to strip.
 
 STRIP_FROM_PATH        =
 
 # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
 # the path mentioned in the documentation of a class, which tells
 # the reader which header file to include in order to use a class.
 # If left blank only the name of the header file containing the class
 # definition is used. Otherwise one should specify the include paths that
 # are normally passed to the compiler using the -I flag.
 
 STRIP_FROM_INC_PATH    =
 
 # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
 # (but less readable) file names. This can be useful if your file system
 # doesn't support long names like on DOS, Mac, or CD-ROM.
 
 SHORT_NAMES            = NO
 
 # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
 # will interpret the first line (until the first dot) of a JavaDoc-style
 # comment as the brief description. If set to NO, the JavaDoc
 # comments will behave just like regular Qt-style comments
 # (thus requiring an explicit @brief command for a brief description.)
 
 JAVADOC_AUTOBRIEF      = NO
 
 # If the QT_AUTOBRIEF tag is set to YES then Doxygen will
 # interpret the first line (until the first dot) of a Qt-style
 # comment as the brief description. If set to NO, the comments
 # will behave just like regular Qt-style comments (thus requiring
 # an explicit \brief command for a brief description.)
 
 QT_AUTOBRIEF           = NO
 
 # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
 # treat a multi-line C++ special comment block (i.e. a block of //! or ///
 # comments) as a brief description. This used to be the default behaviour.
 # The new default is to treat a multi-line C++ comment block as a detailed
 # description. Set this tag to YES if you prefer the old behaviour instead.
 
 MULTILINE_CPP_IS_BRIEF = NO
 
 # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
 # member inherits the documentation from any documented member that it
 # re-implements.
 
 INHERIT_DOCS           = YES
 
 # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
 # a new page for each member. If set to NO, the documentation of a member will
 # be part of the file/class/namespace that contains it.
 
 SEPARATE_MEMBER_PAGES  = NO
 
 # The TAB_SIZE tag can be used to set the number of spaces in a tab.
 # Doxygen uses this value to replace tabs by spaces in code fragments.
 
 TAB_SIZE               = 8
 
 # This tag can be used to specify a number of aliases that acts
 # as commands in the documentation. An alias has the form "name=value".
 # For example adding "sideeffect=\par Side Effects:\n" will allow you to
 # put the command \sideeffect (or @sideeffect) in the documentation, which
 # will result in a user-defined paragraph with heading "Side Effects:".
 # You can put \n's in the value part of an alias to insert newlines.
 
 ALIASES                = "FIXME=\par Fix Me's:\n" \
                          "BlueBerry=\if BLUEBERRY" \
                          "endBlueBerry=\endif" \
                          "bundlemainpage{1}=\page \1" \
-                         "embmainpage{1}=\page \1"
+                         "embmainpage{1}=\page \1" \
+                         "deprecatedSince{1}=\xrefitem deprecatedSince\1 \" Deprecated as of \1\" \"Functions deprecated as of \1\" "
 
 # This tag can be used to specify a number of word-keyword mappings (TCL only).
 # A mapping has the form "name=value". For example adding
 # "class=itcl::class" will allow you to use the command class in the
 # itcl::class meaning.
 
 TCL_SUBST              =
 
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
 # sources only. Doxygen will then generate output that is more tailored for C.
 # For instance, some of the names that are used will be different. The list
 # of all members will be omitted, etc.
 
 OPTIMIZE_OUTPUT_FOR_C  = NO
 
 # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
 # sources only. Doxygen will then generate output that is more tailored for
 # Java. For instance, namespaces will be presented as packages, qualified
 # scopes will look different, etc.
 
 OPTIMIZE_OUTPUT_JAVA   = NO
 
 # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
 # sources only. Doxygen will then generate output that is more tailored for
 # Fortran.
 
 OPTIMIZE_FOR_FORTRAN   = NO
 
 # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
 # sources. Doxygen will then generate output that is tailored for
 # VHDL.
 
 OPTIMIZE_OUTPUT_VHDL   = NO
 
 # Doxygen selects the parser to use depending on the extension of the files it
 # parses. With this tag you can assign which parser to use for a given extension.
 # Doxygen has a built-in mapping, but you can override or extend it using this
 # tag. The format is ext=language, where ext is a file extension, and language
 # is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
 # C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
 # doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
 # (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
 # you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
 
 EXTENSION_MAPPING      =
 
 # If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
 # comments according to the Markdown format, which allows for more readable
 # documentation. See http://daringfireball.net/projects/markdown/ for details.
 # The output of markdown processing is further processed by doxygen, so you
 # can mix doxygen, HTML, and XML commands with Markdown formatting.
 # Disable only in case of backward compatibilities issues.
 
 MARKDOWN_SUPPORT       = YES
 
 # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
 # to include (a tag file for) the STL sources as input, then you should
 # set this tag to YES in order to let doxygen match functions declarations and
 # definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
 # func(std::string) {}). This also makes the inheritance and collaboration
 # diagrams that involve STL classes more complete and accurate.
 
 BUILTIN_STL_SUPPORT    = YES
 
 # If you use Microsoft's C++/CLI language, you should set this option to YES to
 # enable parsing support.
 
 CPP_CLI_SUPPORT        = NO
 
 # Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
 # Doxygen will parse them like normal C++ but will assume all classes use public
 # instead of private inheritance when no explicit protection keyword is present.
 
 SIP_SUPPORT            = NO
 
 # For Microsoft's IDL there are propget and propput attributes to indicate getter
 # and setter methods for a property. Setting this option to YES (the default)
 # will make doxygen replace the get and set methods by a property in the
 # documentation. This will only work if the methods are indeed getting or
 # setting a simple type. If this is not the case, or you want to show the
 # methods anyway, you should set this option to NO.
 
 IDL_PROPERTY_SUPPORT   = YES
 
 # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
 # tag is set to YES, then doxygen will reuse the documentation of the first
 # member in the group (if any) for the other members of the group. By default
 # all members of a group must be documented explicitly.
 
 DISTRIBUTE_GROUP_DOC   = NO
 
 # Set the SUBGROUPING tag to YES (the default) to allow class member groups of
 # the same type (for instance a group of public functions) to be put as a
 # subgroup of that type (e.g. under the Public Functions section). Set it to
 # NO to prevent subgrouping. Alternatively, this can be done per class using
 # the \nosubgrouping command.
 
 SUBGROUPING            = YES
 
 # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
 # unions are shown inside the group in which they are included (e.g. using
 # @ingroup) instead of on a separate page (for HTML and Man pages) or
 # section (for LaTeX and RTF).
 
 INLINE_GROUPED_CLASSES = NO
 
 # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
 # unions with only public data fields will be shown inline in the documentation
 # of the scope in which they are defined (i.e. file, namespace, or group
 # documentation), provided this scope is documented. If set to NO (the default),
 # structs, classes, and unions are shown on a separate page (for HTML and Man
 # pages) or section (for LaTeX and RTF).
 
 INLINE_SIMPLE_STRUCTS  = NO
 
 # When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
 # is documented as struct, union, or enum with the name of the typedef. So
 # typedef struct TypeS {} TypeT, will appear in the documentation as a struct
 # with name TypeT. When disabled the typedef will appear as a member of a file,
 # namespace, or class. And the struct will be named TypeS. This can typically
 # be useful for C code in case the coding convention dictates that all compound
 # types are typedef'ed and only the typedef is referenced, never the tag name.
 
 TYPEDEF_HIDES_STRUCT   = NO
 
 # The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
 # determine which symbols to keep in memory and which to flush to disk.
 # When the cache is full, less often used symbols will be written to disk.
 # For small to medium size projects (<1000 input files) the default value is
 # probably good enough. For larger projects a too small cache size can cause
 # doxygen to be busy swapping symbols to and from disk most of the time
 # causing a significant performance penalty.
 # If the system has enough physical memory increasing the cache will improve the
 # performance by keeping more symbols in memory. Note that the value works on
 # a logarithmic scale so increasing the size by one will roughly double the
 # memory usage. The cache size is given by this formula:
 # 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
 # corresponding to a cache size of 2^16 = 65536 symbols.
 
 SYMBOL_CACHE_SIZE      = 0
 
 # Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
 # set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
 # their name and scope. Since this can be an expensive process and often the
 # same symbol appear multiple times in the code, doxygen keeps a cache of
 # pre-resolved symbols. If the cache is too small doxygen will become slower.
 # If the cache is too large, memory is wasted. The cache size is given by this
 # formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
 # corresponding to a cache size of 2^16 = 65536 symbols.
 
 LOOKUP_CACHE_SIZE      = 0
 
 #---------------------------------------------------------------------------
 # Build related configuration options
 #---------------------------------------------------------------------------
 
 # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
 # documentation are documented, even if no documentation was available.
 # Private class members and static file members will be hidden unless
 # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
 
 EXTRACT_ALL            = YES
 
 # If the EXTRACT_PRIVATE tag is set to YES all private members of a class
 # will be included in the documentation.
 
 EXTRACT_PRIVATE        = NO
 
 # If the EXTRACT_PACKAGE tag is set to YES all members with package or internal scope will be included in the documentation.
 
 EXTRACT_PACKAGE        = NO
 
 # If the EXTRACT_STATIC tag is set to YES all static members of a file
 # will be included in the documentation.
 
 EXTRACT_STATIC         = YES
 
 # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
 # defined locally in source files will be included in the documentation.
 # If set to NO only classes defined in header files are included.
 
 EXTRACT_LOCAL_CLASSES  = @MITK_DOXYGEN_INTERNAL_DOCS@
 
 # This flag is only useful for Objective-C code. When set to YES local
 # methods, which are defined in the implementation section but not in
 # the interface are included in the documentation.
 # If set to NO (the default) only methods in the interface are included.
 
 EXTRACT_LOCAL_METHODS  = NO
 
 # If this flag is set to YES, the members of anonymous namespaces will be
 # extracted and appear in the documentation as a namespace called
 # 'anonymous_namespace{file}', where file will be replaced with the base
 # name of the file that contains the anonymous namespace. By default
 # anonymous namespaces are hidden.
 
 EXTRACT_ANON_NSPACES   = NO
 
 # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
 # undocumented members of documented classes, files or namespaces.
 # If set to NO (the default) these members will be included in the
 # various overviews, but no documentation section is generated.
 # This option has no effect if EXTRACT_ALL is enabled.
 
 HIDE_UNDOC_MEMBERS     = NO
 
 # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
 # undocumented classes that are normally visible in the class hierarchy.
 # If set to NO (the default) these classes will be included in the various
 # overviews. This option has no effect if EXTRACT_ALL is enabled.
 
 HIDE_UNDOC_CLASSES     = NO
 
 # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
 # friend (class|struct|union) declarations.
 # If set to NO (the default) these declarations will be included in the
 # documentation.
 
 HIDE_FRIEND_COMPOUNDS  = @MITK_DOXYGEN_HIDE_FRIEND_COMPOUNDS@
 
 # If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
 # documentation blocks found inside the body of a function.
 # If set to NO (the default) these blocks will be appended to the
 # function's detailed documentation block.
 
 HIDE_IN_BODY_DOCS      = NO
 
 # The INTERNAL_DOCS tag determines if documentation
 # that is typed after a \internal command is included. If the tag is set
 # to NO (the default) then the documentation will be excluded.
 # Set it to YES to include the internal documentation.
 
 INTERNAL_DOCS          = @MITK_DOXYGEN_INTERNAL_DOCS@
 
 # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
 # file names in lower-case letters. If set to YES upper-case letters are also
 # allowed. This is useful if you have classes or files whose names only differ
 # in case and if your file system supports case sensitive file names. Windows
 # and Mac users are advised to set this option to NO.
 
 CASE_SENSE_NAMES       = YES
 
 # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
 # will show members with their full class and namespace scopes in the
 # documentation. If set to YES the scope will be hidden.
 
 HIDE_SCOPE_NAMES       = NO
 
 # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
 # will put a list of the files that are included by a file in the documentation
 # of that file.
 
 SHOW_INCLUDE_FILES     = YES
 
 # If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
 # will list include files with double quotes in the documentation
 # rather than with sharp brackets.
 
 FORCE_LOCAL_INCLUDES   = NO
 
 # If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
 # is inserted in the documentation for inline members.
 
 INLINE_INFO            = YES
 
 # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
 # will sort the (detailed) documentation of file and class members
 # alphabetically by member name. If set to NO the members will appear in
 # declaration order.
 
 SORT_MEMBER_DOCS       = YES
 
 # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
 # brief documentation of file, namespace and class members alphabetically
 # by member name. If set to NO (the default) the members will appear in
 # declaration order.
 
 SORT_BRIEF_DOCS        = NO
 
 # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
 # will sort the (brief and detailed) documentation of class members so that
 # constructors and destructors are listed first. If set to NO (the default)
 # the constructors will appear in the respective orders defined by
 # SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
 # This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
 # and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
 
 SORT_MEMBERS_CTORS_1ST = NO
 
 # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
 # hierarchy of group names into alphabetical order. If set to NO (the default)
 # the group names will appear in their defined order.
 
 SORT_GROUP_NAMES       = NO
 
 # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
 # sorted by fully-qualified names, including namespaces. If set to
 # NO (the default), the class list will be sorted only by class name,
 # not including the namespace part.
 # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
 # Note: This option applies only to the class list, not to the
 # alphabetical list.
 
 SORT_BY_SCOPE_NAME     = YES
 
 # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
 # do proper type resolution of all parameters of a function it will reject a
 # match between the prototype and the implementation of a member function even
 # if there is only one candidate or it is obvious which candidate to choose
 # by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
 # will still accept a match between prototype and implementation in such cases.
 
 STRICT_PROTO_MATCHING  = NO
 
 # The GENERATE_TODOLIST tag can be used to enable (YES) or
 # disable (NO) the todo list. This list is created by putting \todo
 # commands in the documentation.
 
 GENERATE_TODOLIST      = @MITK_DOXYGEN_GENERATE_TODOLIST@
 
 # The GENERATE_TESTLIST tag can be used to enable (YES) or
 # disable (NO) the test list. This list is created by putting \test
 # commands in the documentation.
 
 GENERATE_TESTLIST      = YES
 
 # The GENERATE_BUGLIST tag can be used to enable (YES) or
 # disable (NO) the bug list. This list is created by putting \bug
 # commands in the documentation.
 
 GENERATE_BUGLIST       = @MITK_DOXYGEN_GENERATE_BUGLIST@
 
 # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
 # disable (NO) the deprecated list. This list is created by putting
 # \deprecated commands in the documentation.
 
 GENERATE_DEPRECATEDLIST= @MITK_DOXYGEN_GENERATE_DEPRECATEDLIST@
 
 # The ENABLED_SECTIONS tag can be used to enable conditional
 # documentation sections, marked by \if sectionname ... \endif.
 
 ENABLED_SECTIONS       = @MITK_DOXYGEN_ENABLED_SECTIONS@
 
 # The MAX_INITIALIZER_LINES tag determines the maximum number of lines
 # the initial value of a variable or macro consists of for it to appear in
 # the documentation. If the initializer consists of more lines than specified
 # here it will be hidden. Use a value of 0 to hide initializers completely.
 # The appearance of the initializer of individual variables and macros in the
 # documentation can be controlled using \showinitializer or \hideinitializer
 # command in the documentation regardless of this setting.
 
 MAX_INITIALIZER_LINES  = 0
 
 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated
 # at the bottom of the documentation of classes and structs. If set to YES the
 # list will mention the files that were used to generate the documentation.
 
 SHOW_USED_FILES        = YES
 
 # If the sources in your project are distributed over multiple directories
 # then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
 # in the documentation. The default is NO.
 
 SHOW_DIRECTORIES       = NO
 
 # Set the SHOW_FILES tag to NO to disable the generation of the Files page.
 # This will remove the Files entry from the Quick Index and from the
 # Folder Tree View (if specified). The default is YES.
 
 SHOW_FILES             = YES
 
 # Set the SHOW_NAMESPACES tag to NO to disable the generation of the
 # Namespaces page.
 # This will remove the Namespaces entry from the Quick Index
 # and from the Folder Tree View (if specified). The default is YES.
 
 SHOW_NAMESPACES        = YES
 
 # The FILE_VERSION_FILTER tag can be used to specify a program or script that
 # doxygen should invoke to get the current version for each file (typically from
 # the version control system). Doxygen will invoke the program by executing (via
 # popen()) the command <command> <input-file>, where <command> is the value of
 # the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
 # provided by doxygen. Whatever the program writes to standard output
 # is used as the file version. See the manual for examples.
 
 FILE_VERSION_FILTER    =
 
 # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
 # by doxygen. The layout file controls the global structure of the generated
 # output files in an output format independent way. The create the layout file
 # that represents doxygen's defaults, run doxygen with the -l option.
 # You can optionally specify a file name after the option, if omitted
 # DoxygenLayout.xml will be used as the name of the layout file.
 
-LAYOUT_FILE            =
+LAYOUT_FILE            = @MITK_SOURCE_DIR@/Documentation/MITKDoxygenLayout.xml
 
 # The CITE_BIB_FILES tag can be used to specify one or more bib files
 # containing the references data. This must be a list of .bib files. The
 # .bib extension is automatically appended if omitted. Using this command
 # requires the bibtex tool to be installed. See also
 # http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
 # of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
 # feature you need bibtex and perl available in the search path.
 
 CITE_BIB_FILES         =
 
 #---------------------------------------------------------------------------
 # configuration options related to warning and progress messages
 #---------------------------------------------------------------------------
 
 # The QUIET tag can be used to turn on/off the messages that are generated
 # by doxygen. Possible values are YES and NO. If left blank NO is used.
 
 QUIET                  = NO
 
 # The WARNINGS tag can be used to turn on/off the warning messages that are
 # generated by doxygen. Possible values are YES and NO. If left blank
 # NO is used.
 
 WARNINGS               = YES
 
 # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
 # for undocumented members. If EXTRACT_ALL is set to YES then this flag will
 # automatically be disabled.
 
 WARN_IF_UNDOCUMENTED   = YES
 
 # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
 # potential errors in the documentation, such as not documenting some
 # parameters in a documented function, or documenting parameters that
 # don't exist or using markup commands wrongly.
 
 WARN_IF_DOC_ERROR      = YES
 
 # The WARN_NO_PARAMDOC option can be enabled to get warnings for
 # functions that are documented, but have no documentation for their parameters
 # or return value. If set to NO (the default) doxygen will only warn about
 # wrong or incomplete parameter documentation, but not about the absence of
 # documentation.
 
 WARN_NO_PARAMDOC       = NO
 
 # The WARN_FORMAT tag determines the format of the warning messages that
 # doxygen can produce. The string should contain the $file, $line, and $text
 # tags, which will be replaced by the file and line number from which the
 # warning originated and the warning text. Optionally the format may contain
 # $version, which will be replaced by the version of the file (if it could
 # be obtained via FILE_VERSION_FILTER)
 
 WARN_FORMAT            = "$file:$line: $text"
 
 # The WARN_LOGFILE tag can be used to specify a file to which warning
 # and error messages should be written. If left blank the output is written
 # to stderr.
 
 WARN_LOGFILE           =
 
 #---------------------------------------------------------------------------
 # configuration options related to the input files
 #---------------------------------------------------------------------------
 
 # The INPUT tag can be used to specify the files and/or directories that contain
 # documented source files. You may enter file names like "myfile.cpp" or
 # directories like "/usr/src/myproject". Separate the files or directories
 # with spaces.
 
 INPUT                  = @MITK_SOURCE_DIR@ \
                          @MITK_BINARY_DIR@ \
                          @MITK_DOXYGEN_ADDITIONAL_INPUT_DIRS@
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
 # also the default input encoding. Doxygen uses libiconv (or the iconv built
 # into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
 # the list of possible encodings.
 
 INPUT_ENCODING         = UTF-8
 
 # If the value of the INPUT tag contains directories, you can use the
 # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
 # and *.h) to filter out the source-files in the directories. If left
 # blank the following patterns are tested:
 # *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
 # *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
 # *.f90 *.f *.for *.vhd *.vhdl
 
 FILE_PATTERNS          = *.h \
                          *.cpp \
                          *.dox \
                          *.md \
                          *.txx \
                          *.tpp \
                          *.cxx \
                          *.cmake
 
 # The RECURSIVE tag can be used to turn specify whether or not subdirectories
 # should be searched for input files as well. Possible values are YES and NO.
 # If left blank NO is used.
 
 RECURSIVE              = YES
 
 # The EXCLUDE tag can be used to specify files and/or directories that should be
 # excluded from the INPUT source files. This way you can easily exclude a
 # subdirectory from a directory tree whose root is specified with the INPUT tag.
 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
 EXCLUDE                = @MITK_SOURCE_DIR@/Utilities/ann/ \
                          @MITK_SOURCE_DIR@/Utilities/glew/ \
                          @MITK_SOURCE_DIR@/Utilities/ipFunc/ \
                          @MITK_SOURCE_DIR@/Utilities/ipSegmentation/ \
                          @MITK_SOURCE_DIR@/Utilities/KWStyle/ \
                          @MITK_SOURCE_DIR@/Utilities/pic2vtk/ \
                          @MITK_SOURCE_DIR@/Utilities/Poco/ \
                          @MITK_SOURCE_DIR@/Utilities/qtsingleapplication/ \
                          @MITK_SOURCE_DIR@/Utilities/qwt/ \
                          @MITK_SOURCE_DIR@/Utilities/qxt/ \
                          @MITK_SOURCE_DIR@/Utilities/tinyxml/ \
                          @MITK_SOURCE_DIR@/Utilities/vecmath/ \
                          @MITK_SOURCE_DIR@/Applications/PluginGenerator/ \
                          @MITK_SOURCE_DIR@/BlueBerry/ \
                          @MITK_SOURCE_DIR@/Core/Code/CppMicroServices/README.md \
                          @MITK_SOURCE_DIR@/Core/Code/CppMicroServices/documentation/snippets/ \
                          @MITK_SOURCE_DIR@/Core/Code/CppMicroServices/documentation/doxygen/standalone/ \
                          @MITK_SOURCE_DIR@/Core/Code/CppMicroServices/test/ \
                          @MITK_SOURCE_DIR@/Deprecated/ \
                          @MITK_SOURCE_DIR@/Build/ \
                          @MITK_SOURCE_DIR@/CMake/PackageDepends \
                          @MITK_SOURCE_DIR@/CMake/QBundleTemplate \
                          @MITK_SOURCE_DIR@/CMakeExternals \
                          @MITK_SOURCE_DIR@/Modules/QmitkExt/vtkQtChartHeaders/ \
                          @MITK_BINARY_DIR@/PT/ \
                          @MITK_BINARY_DIR@/GP/ \
                          @MITK_BINARY_DIR@/Core/Code/CppMicroServices/ \
                          @MITK_DOXYGEN_ADDITIONAL_EXCLUDE_DIRS@
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded
 # from the input.
 
 EXCLUDE_SYMLINKS       = NO
 
 # If the value of the INPUT tag contains directories, you can use the
 # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
 # certain files from those directories. Note that the wildcards are matched
 # against the file with absolute path, so to exclude all test directories
 # for example use the pattern */test/*
 
 EXCLUDE_PATTERNS       = moc_* \
                          Register* \
                          */files.cmake \
                          */.git/* \
                          *_p.h \
                          *Private.* \
                          */Snippets/* \
                          */snippets/* \
                          */testing/* \
                          */Testing/* \
                          @MITK_BINARY_DIR@/*.cmake \
                          @MITK_DOXYGEN_EXCLUDE_PATTERNS@
 
 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
 # (namespaces, classes, functions, etc.) that should be excluded from the
 # output. The symbol name can be a fully qualified name, a word, or if the
 # wildcard * is used, a substring. Examples: ANamespace, AClass,
 # AClass::ANamespace, ANamespace::*Test
 
 EXCLUDE_SYMBOLS        =
 
 # The EXAMPLE_PATH tag can be used to specify one or more files or
 # directories that contain example code fragments that are included (see
 # the \include command).
 
 EXAMPLE_PATH           = @MITK_SOURCE_DIR@/Examples/ \
                          @MITK_SOURCE_DIR@/Examples/Tutorial/ \
                          @MITK_SOURCE_DIR@/Examples/QtFreeRender/ \
                          @MITK_SOURCE_DIR@/Core/Code/ \
                          @MITK_SOURCE_DIR@/Core/Code/CppMicroServices/Documentation/Snippets/ \
                          @MITK_DOXYGEN_OUTPUT_DIR@/html/extension-points/html/ \
                          @MITK_SOURCE_DIR@/Documentation/Snippets/ \
                          @MITK_SOURCE_DIR@/Documentation/Doxygen/ExampleCode/
 
 # If the value of the EXAMPLE_PATH tag contains directories, you can use the
 # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
 # and *.h) to filter out the source-files in the directories. If left
 # blank all files are included.
 
 EXAMPLE_PATTERNS       =
 
 # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
 # searched for input files to be used with the \include or \dontinclude
 # commands irrespective of the value of the RECURSIVE tag.
 # Possible values are YES and NO. If left blank NO is used.
 
 EXAMPLE_RECURSIVE      = YES
 
 # The IMAGE_PATH tag can be used to specify one or more files or
 # directories that contain image that are included in the documentation (see
 # the \image command).
 
 IMAGE_PATH             = @MITK_SOURCE_DIR@/Documentation/Doxygen/ \
                          @MITK_SOURCE_DIR@/Documentation/Doxygen/Modules/ \
                          @MITK_SOURCE_DIR@/Documentation/Doxygen/Tutorial/ \
                          @MITK_SOURCE_DIR@
 
 # The INPUT_FILTER tag can be used to specify a program that doxygen should
 # invoke to filter for each input file. Doxygen will invoke the filter program
 # by executing (via popen()) the command <filter> <input-file>, where <filter>
 # is the value of the INPUT_FILTER tag, and <input-file> is the name of an
 # input file. Doxygen will then use the output that the filter program writes
 # to standard output.
 # If FILTER_PATTERNS is specified, this tag will be
 # ignored.
 
 INPUT_FILTER           =
 
 # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
 # basis.
 # Doxygen will compare the file name with each pattern and apply the
 # filter if there is a match.
 # The filters are a list of the form:
 # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
 # info on how filters are used. If FILTER_PATTERNS is empty or if
 # non of the patterns match the file name, INPUT_FILTER is applied.
 
 FILTER_PATTERNS        = *.cmake=@CMakeDoxygenFilter_EXECUTABLE@
 
 # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
 # INPUT_FILTER) will be used to filter the input files when producing source
 # files to browse (i.e. when SOURCE_BROWSER is set to YES).
 
 FILTER_SOURCE_FILES    = NO
 
 # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
 # pattern. A pattern will override the setting for FILTER_PATTERN (if any)
 # and it is also possible to disable source filtering for a specific pattern
 # using *.ext= (so without naming a filter). This option only has effect when
 # FILTER_SOURCE_FILES is enabled.
 
 FILTER_SOURCE_PATTERNS =
 
 #---------------------------------------------------------------------------
 # configuration options related to source browsing
 #---------------------------------------------------------------------------
 
 # If the SOURCE_BROWSER tag is set to YES then a list of source files will
 # be generated. Documented entities will be cross-referenced with these sources.
 # Note: To get rid of all source code in the generated output, make sure also
 # VERBATIM_HEADERS is set to NO.
 
 SOURCE_BROWSER         = YES
 
 # Setting the INLINE_SOURCES tag to YES will include the body
 # of functions and classes directly in the documentation.
 
 INLINE_SOURCES         = NO
 
 # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
 # doxygen to hide any special comment blocks from generated source code
 # fragments. Normal C and C++ comments will always remain visible.
 
 STRIP_CODE_COMMENTS    = YES
 
 # If the REFERENCED_BY_RELATION tag is set to YES
 # then for each documented function all documented
 # functions referencing it will be listed.
 
 REFERENCED_BY_RELATION = YES
 
 # If the REFERENCES_RELATION tag is set to YES
 # then for each documented function all documented entities
 # called/used by that function will be listed.
 
 REFERENCES_RELATION    = YES
 
 # If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
 # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
 # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
 # link to the source code.
 # Otherwise they will link to the documentation.
 
 REFERENCES_LINK_SOURCE = YES
 
 # If the USE_HTAGS tag is set to YES then the references to source code
 # will point to the HTML generated by the htags(1) tool instead of doxygen
 # built-in source browser. The htags tool is part of GNU's global source
 # tagging system (see http://www.gnu.org/software/global/global.html). You
 # will need version 4.8.6 or higher.
 
 USE_HTAGS              = NO
 
 # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
 # will generate a verbatim copy of the header file for each class for
 # which an include is specified. Set to NO to disable this.
 
 VERBATIM_HEADERS       = YES
 
 #---------------------------------------------------------------------------
 # configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
 
 # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
 # of all compounds will be generated. Enable this if the project
 # contains a lot of classes, structs, unions or interfaces.
 
 ALPHABETICAL_INDEX     = YES
 
 # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
 # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
 # in which this list will be split (can be a number in the range [1..20])
 
 COLS_IN_ALPHA_INDEX    = 3
 
 # In case all classes in a project start with a common prefix, all
 # classes will be put under the same header in the alphabetical index.
 # The IGNORE_PREFIX tag can be used to specify one or more prefixes that
 # should be ignored while generating the index headers.
 
 IGNORE_PREFIX          =
 
 #---------------------------------------------------------------------------
 # configuration options related to the HTML output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_HTML tag is set to YES (the default) Doxygen will
 # generate HTML output.
 
 GENERATE_HTML          = YES
 
 # The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `html' will be used as the default path.
 
 HTML_OUTPUT            = html
 
 # The HTML_FILE_EXTENSION tag can be used to specify the file extension for
 # each generated HTML page (for example: .htm,.php,.asp). If it is left blank
 # doxygen will generate files with .html extension.
 
 HTML_FILE_EXTENSION    = .html
 
 # The HTML_HEADER tag can be used to specify a personal HTML header for
 # each generated HTML page. If it is left blank doxygen will generate a
 # standard header. Note that when using a custom header you are responsible
 #  for the proper inclusion of any scripts and style sheets that doxygen
 # needs, which is dependent on the configuration options used.
 # It is advised to generate a default header using "doxygen -w html
 # header.html footer.html stylesheet.css YourConfigFile" and then modify
 # that header. Note that the header is subject to change so you typically
 # have to redo this when upgrading to a newer version of doxygen or when
 # changing the value of configuration settings such as GENERATE_TREEVIEW!
 
 HTML_HEADER            =
 
 # The HTML_FOOTER tag can be used to specify a personal HTML footer for
 # each generated HTML page. If it is left blank doxygen will generate a
 # standard footer.
 
 HTML_FOOTER            =
 
 # The HTML_STYLESHEET tag can be used to specify a user-defined cascading
 # style sheet that is used by each HTML page. It can be used to
 # fine-tune the look of the HTML output. If the tag is left blank doxygen
 # will generate a default style sheet. Note that doxygen will try to copy
 # the style sheet file to the HTML output directory, so don't put your own
 # style sheet in the HTML output directory as well, or it will be erased!
 
 HTML_STYLESHEET        = @MITK_DOXYGEN_STYLESHEET@
 
 # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
 # other source files which should be copied to the HTML output directory. Note
 # that these files will be copied to the base HTML output directory. Use the
 # $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
 # files. In the HTML_STYLESHEET file, use the file name only. Also note that
 # the files will be copied as-is; there are no commands or markers available.
 
 HTML_EXTRA_FILES       =
 
 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
 # Doxygen will adjust the colors in the style sheet and background images
 # according to this color. Hue is specified as an angle on a colorwheel,
 # see http://en.wikipedia.org/wiki/Hue for more information.
 # For instance the value 0 represents red, 60 is yellow, 120 is green,
 # 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
 # The allowed range is 0 to 359.
 
 HTML_COLORSTYLE_HUE    = 220
 
 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
 # the colors in the HTML output. For a value of 0 the output will use
 # grayscales only. A value of 255 will produce the most vivid colors.
 
 HTML_COLORSTYLE_SAT    = 100
 
 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
 # the luminance component of the colors in the HTML output. Values below
 # 100 gradually make the output lighter, whereas values above 100 make
 # the output darker. The value divided by 100 is the actual gamma applied,
 # so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
 # and 100 does not change the gamma.
 
 HTML_COLORSTYLE_GAMMA  = 80
 
 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
 # page will contain the date and time when the page was generated. Setting
 # this to NO can help when comparing the output of multiple runs.
 
 HTML_TIMESTAMP         = YES
 
 # If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
 # files or namespaces will be aligned in HTML using tables. If set to
 # NO a bullet list will be used.
 
 HTML_ALIGN_MEMBERS     = YES
 
 # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
 # documentation will contain sections that can be hidden and shown after the
 # page has loaded. For this to work a browser that supports
 # JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
 # Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
 
 HTML_DYNAMIC_SECTIONS  = @MITK_DOXYGEN_HTML_DYNAMIC_SECTIONS@
 
 # If the GENERATE_DOCSET tag is set to YES, additional index files
 # will be generated that can be used as input for Apple's Xcode 3
 # integrated development environment, introduced with OSX 10.5 (Leopard).
 # To create a documentation set, doxygen will generate a Makefile in the
 # HTML output directory. Running make will produce the docset in that
 # directory and running "make install" will install the docset in
 # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
 # it at startup.
 # See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
 # for more information.
 
 GENERATE_DOCSET        = NO
 
 # When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
 # feed. A documentation feed provides an umbrella under which multiple
 # documentation sets from a single provider (such as a company or product suite)
 # can be grouped.
 
 DOCSET_FEEDNAME        = "Doxygen generated docs"
 
 # When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
 # should uniquely identify the documentation set bundle. This should be a
 # reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
 # will append .docset to the name.
 
 DOCSET_BUNDLE_ID       = org.doxygen.Project
 
 # When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
 # the documentation publisher. This should be a reverse domain-name style
 # string, e.g. com.mycompany.MyDocSet.documentation.
 
 DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
 
 # The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
 
 DOCSET_PUBLISHER_NAME  = Publisher
 
 # If the GENERATE_HTMLHELP tag is set to YES, additional index files
 # will be generated that can be used as input for tools like the
 # Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
 # of the generated HTML documentation.
 
 GENERATE_HTMLHELP      = NO
 
 # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
 # be used to specify the file name of the resulting .chm file. You
 # can add a path in front of the file if the result should not be
 # written to the html output directory.
 
 CHM_FILE               =
 
 # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
 # be used to specify the location (absolute path including file name) of
 # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
 # the HTML help compiler on the generated index.hhp.
 
 HHC_LOCATION           =
 
 # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
 # controls if a separate .chi index file is generated (YES) or that
 # it should be included in the master .chm file (NO).
 
 GENERATE_CHI           = NO
 
 # If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
 # is used to encode HtmlHelp index (hhk), content (hhc) and project file
 # content.
 
 CHM_INDEX_ENCODING     =
 
 # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
 # controls whether a binary table of contents is generated (YES) or a
 # normal table of contents (NO) in the .chm file.
 
 BINARY_TOC             = NO
 
 # The TOC_EXPAND flag can be set to YES to add extra items for group members
 # to the contents of the HTML help documentation and to the tree view.
 
 TOC_EXPAND             = NO
 
 # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
 # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
 # that can be used as input for Qt's qhelpgenerator to generate a
 # Qt Compressed Help (.qch) of the generated HTML documentation.
 
 GENERATE_QHP           = @MITK_DOXYGEN_GENERATE_QHP@
 
 # If the QHG_LOCATION tag is specified, the QCH_FILE tag can
 # be used to specify the file name of the resulting .qch file.
 # The path specified is relative to the HTML output folder.
 
 QCH_FILE               = @MITK_DOXYGEN_QCH_FILE@
 
 # The QHP_NAMESPACE tag specifies the namespace to use when generating
 # Qt Help Project output. For more information please see
 # http://doc.trolltech.com/qthelpproject.html#namespace
 
 QHP_NAMESPACE          = "org.mitk"
 
 # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
 # Qt Help Project output. For more information please see
 # http://doc.trolltech.com/qthelpproject.html#virtual-folders
 
 QHP_VIRTUAL_FOLDER     = MITK
 
 # If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
 # add. For more information please see
 # http://doc.trolltech.com/qthelpproject.html#custom-filters
 
 QHP_CUST_FILTER_NAME   =
 
 # The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
 # custom filter to add. For more information please see
 # <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
 # Qt Help Project / Custom Filters</a>.
 
 QHP_CUST_FILTER_ATTRS  =
 
 # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
 # project's
 # filter section matches.
 # <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
 # Qt Help Project / Filter Attributes</a>.
 
 QHP_SECT_FILTER_ATTRS  =
 
 # If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
 # be used to specify the location of Qt's qhelpgenerator.
 # If non-empty doxygen will try to run qhelpgenerator on the generated
 # .qhp file.
 
 QHG_LOCATION           = @QT_HELPGENERATOR_EXECUTABLE@
 
 # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
 #  will be generated, which together with the HTML files, form an Eclipse help
 # plugin. To install this plugin and make it available under the help contents
 # menu in Eclipse, the contents of the directory containing the HTML and XML
 # files needs to be copied into the plugins directory of eclipse. The name of
 # the directory within the plugins directory should be the same as
 # the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
 # the help appears.
 
 GENERATE_ECLIPSEHELP   = NO
 
 # A unique identifier for the eclipse help plugin. When installing the plugin
 # the directory name containing the HTML and XML files should also have
 # this name.
 
 ECLIPSE_DOC_ID         = org.doxygen.Project
 
 # The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
 # at top of each HTML page. The value NO (the default) enables the index and
 # the value YES disables it. Since the tabs have the same information as the
 # navigation tree you can set this option to NO if you already set
 # GENERATE_TREEVIEW to YES.
 
 DISABLE_INDEX          = NO
 
 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
 # structure should be generated to display hierarchical information.
 # If the tag value is set to YES, a side panel will be generated
 # containing a tree-like index structure (just like the one that
 # is generated for HTML Help). For this to work a browser that supports
 # JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
 # Windows users are probably better off using the HTML help feature.
 # Since the tree basically has the same information as the tab index you
 # could consider to set DISABLE_INDEX to NO when enabling this option.
 
 GENERATE_TREEVIEW      = YES
 
 # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
 # (range [0,1..20]) that doxygen will group on one line in the generated HTML
 # documentation. Note that a value of 0 will completely suppress the enum
 # values from appearing in the overview section.
 
 ENUM_VALUES_PER_LINE   = 4
 
 # By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories,
 # and Class Hierarchy pages using a tree view instead of an ordered list.
 
 USE_INLINE_TREES       = NO
 
 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
 # used to set the initial width (in pixels) of the frame in which the tree
 # is shown.
 
 TREEVIEW_WIDTH         = 300
 
 # When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
 # links to external symbols imported via tag files in a separate window.
 
 EXT_LINKS_IN_WINDOW    = NO
 
 # Use this tag to change the font size of Latex formulas included
 # as images in the HTML documentation. The default is 10. Note that
 # when you change the font size after a successful doxygen run you need
 # to manually remove any form_*.png images from the HTML output directory
 # to force them to be regenerated.
 
 FORMULA_FONTSIZE       = 10
 
 # Use the FORMULA_TRANPARENT tag to determine whether or not the images
 # generated for formulas are transparent PNGs. Transparent PNGs are
 # not supported properly for IE 6.0, but are supported on all modern browsers.
 # Note that when changing this option you need to delete any form_*.png files
 # in the HTML output before the changes have effect.
 
 FORMULA_TRANSPARENT    = YES
 
 # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
 # (see http://www.mathjax.org) which uses client side Javascript for the
 # rendering instead of using prerendered bitmaps. Use this if you do not
 # have LaTeX installed or if you want to formulas look prettier in the HTML
 # output. When enabled you may also need to install MathJax separately and
 # configure the path to it using the MATHJAX_RELPATH option.
 
 USE_MATHJAX            = NO
 
 # When MathJax is enabled you need to specify the location relative to the
 # HTML output directory using the MATHJAX_RELPATH option. The destination
 # directory should contain the MathJax.js script. For instance, if the mathjax
 # directory is located at the same level as the HTML output directory, then
 # MATHJAX_RELPATH should be ../mathjax. The default value points to
 # the MathJax Content Delivery Network so you can quickly see the result without
 # installing MathJax.
 # However, it is strongly recommended to install a local
 # copy of MathJax from http://www.mathjax.org before deployment.
 
 MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
 
 # The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
 # names that should be enabled during MathJax rendering.
 
 MATHJAX_EXTENSIONS     =
 
 # When the SEARCHENGINE tag is enabled doxygen will generate a search box
 # for the HTML output. The underlying search engine uses javascript
 # and DHTML and should work on any modern browser. Note that when using
 # HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
 # (GENERATE_DOCSET) there is already a search function so this one should
 # typically be disabled. For large projects the javascript based search engine
 # can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
 
 SEARCHENGINE           = YES
 
 # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
 # implemented using a PHP enabled web server instead of at the web client
 # using Javascript. Doxygen will generate the search PHP script and index
 # file to put on the web server. The advantage of the server
 # based approach is that it scales better to large projects and allows
 # full text search. The disadvantages are that it is more difficult to setup
 # and does not have live searching capabilities.
 
 SERVER_BASED_SEARCH    = NO
 
 #---------------------------------------------------------------------------
 # configuration options related to the LaTeX output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
 # generate Latex output.
 
 GENERATE_LATEX         = NO
 
 # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `latex' will be used as the default path.
 
 LATEX_OUTPUT           = latex
 
 # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
 # invoked. If left blank `latex' will be used as the default command name.
 # Note that when enabling USE_PDFLATEX this option is only used for
 # generating bitmaps for formulas in the HTML output, but not in the
 # Makefile that is written to the output directory.
 
 LATEX_CMD_NAME         = latex
 
 # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
 # generate index for LaTeX. If left blank `makeindex' will be used as the
 # default command name.
 
 MAKEINDEX_CMD_NAME     = makeindex
 
 # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
 # LaTeX documents. This may be useful for small projects and may help to
 # save some trees in general.
 
 COMPACT_LATEX          = NO
 
 # The PAPER_TYPE tag can be used to set the paper type that is used
 # by the printer. Possible values are: a4, letter, legal and
 # executive. If left blank a4wide will be used.
 
 PAPER_TYPE             = a4wide
 
 # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
 # packages that should be included in the LaTeX output.
 
 EXTRA_PACKAGES         = amssymb
 
 # The LATEX_HEADER tag can be used to specify a personal LaTeX header for
 # the generated latex document. The header should contain everything until
 # the first chapter. If it is left blank doxygen will generate a
 # standard header. Notice: only use this tag if you know what you are doing!
 
 LATEX_HEADER           =
 
 # The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
 # the generated latex document. The footer should contain everything after
 # the last chapter. If it is left blank doxygen will generate a
 # standard footer. Notice: only use this tag if you know what you are doing!
 
 LATEX_FOOTER           =
 
 # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
 # is prepared for conversion to pdf (using ps2pdf). The pdf file will
 # contain links (just like the HTML output) instead of page references
 # This makes the output suitable for online browsing using a pdf viewer.
 
 PDF_HYPERLINKS         = NO
 
 # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
 # plain latex in the generated Makefile. Set this option to YES to get a
 # higher quality PDF documentation.
 
 USE_PDFLATEX           = NO
 
 # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
 # command to the generated LaTeX files. This will instruct LaTeX to keep
 # running if errors occur, instead of asking the user for help.
 # This option is also used when generating formulas in HTML.
 
 LATEX_BATCHMODE        = NO
 
 # If LATEX_HIDE_INDICES is set to YES then doxygen will not
 # include the index chapters (such as File Index, Compound Index, etc.)
 # in the output.
 
 LATEX_HIDE_INDICES     = NO
 
 # If LATEX_SOURCE_CODE is set to YES then doxygen will include
 # source code with syntax highlighting in the LaTeX output.
 # Note that which sources are shown also depends on other settings
 # such as SOURCE_BROWSER.
 
 LATEX_SOURCE_CODE      = NO
 
 # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
 # bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
 # http://en.wikipedia.org/wiki/BibTeX for more info.
 
 LATEX_BIB_STYLE        = plain
 
 #---------------------------------------------------------------------------
 # configuration options related to the RTF output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
 # The RTF output is optimized for Word 97 and may not look very pretty with
 # other RTF readers or editors.
 
 GENERATE_RTF           = NO
 
 # The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `rtf' will be used as the default path.
 
 RTF_OUTPUT             = rtf
 
 # If the COMPACT_RTF tag is set to YES Doxygen generates more compact
 # RTF documents. This may be useful for small projects and may help to
 # save some trees in general.
 
 COMPACT_RTF            = NO
 
 # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
 # will contain hyperlink fields. The RTF file will
 # contain links (just like the HTML output) instead of page references.
 # This makes the output suitable for online browsing using WORD or other
 # programs which support those fields.
 # Note: wordpad (write) and others do not support links.
 
 RTF_HYPERLINKS         = NO
 
 # Load style sheet definitions from file. Syntax is similar to doxygen's
 # config file, i.e. a series of assignments. You only have to provide
 # replacements, missing definitions are set to their default value.
 
 RTF_STYLESHEET_FILE    =
 
 # Set optional variables used in the generation of an rtf document.
 # Syntax is similar to doxygen's config file.
 
 RTF_EXTENSIONS_FILE    =
 
 #---------------------------------------------------------------------------
 # configuration options related to the man page output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_MAN tag is set to YES (the default) Doxygen will
 # generate man pages
 
 GENERATE_MAN           = NO
 
 # The MAN_OUTPUT tag is used to specify where the man pages will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `man' will be used as the default path.
 
 MAN_OUTPUT             = man
 
 # The MAN_EXTENSION tag determines the extension that is added to
 # the generated man pages (default is the subroutine's section .3)
 
 MAN_EXTENSION          = .3
 
 # If the MAN_LINKS tag is set to YES and Doxygen generates man output,
 # then it will generate one additional man file for each entity
 # documented in the real man page(s). These additional files
 # only source the real man page, but without them the man command
 # would be unable to find the correct page. The default is NO.
 
 MAN_LINKS              = NO
 
 #---------------------------------------------------------------------------
 # configuration options related to the XML output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_XML tag is set to YES Doxygen will
 # generate an XML file that captures the structure of
 # the code including all documentation.
 
 GENERATE_XML           = NO
 
 # The XML_OUTPUT tag is used to specify where the XML pages will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `xml' will be used as the default path.
 
 XML_OUTPUT             = xml
 
 # The XML_SCHEMA tag can be used to specify an XML schema,
 # which can be used by a validating XML parser to check the
 # syntax of the XML files.
 
 XML_SCHEMA             =
 
 # The XML_DTD tag can be used to specify an XML DTD,
 # which can be used by a validating XML parser to check the
 # syntax of the XML files.
 
 XML_DTD                =
 
 # If the XML_PROGRAMLISTING tag is set to YES Doxygen will
 # dump the program listings (including syntax highlighting
 # and cross-referencing information) to the XML output. Note that
 # enabling this will significantly increase the size of the XML output.
 
 XML_PROGRAMLISTING     = YES
 
 #---------------------------------------------------------------------------
 # configuration options for the AutoGen Definitions output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
 # generate an AutoGen Definitions (see autogen.sf.net) file
 # that captures the structure of the code including all
 # documentation. Note that this feature is still experimental
 # and incomplete at the moment.
 
 GENERATE_AUTOGEN_DEF   = NO
 
 #---------------------------------------------------------------------------
 # configuration options related to the Perl module output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_PERLMOD tag is set to YES Doxygen will
 # generate a Perl module file that captures the structure of
 # the code including all documentation. Note that this
 # feature is still experimental and incomplete at the
 # moment.
 
 GENERATE_PERLMOD       = NO
 
 # If the PERLMOD_LATEX tag is set to YES Doxygen will generate
 # the necessary Makefile rules, Perl scripts and LaTeX code to be able
 # to generate PDF and DVI output from the Perl module output.
 
 PERLMOD_LATEX          = NO
 
 # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
 # nicely formatted so it can be parsed by a human reader.
 # This is useful
 # if you want to understand what is going on.
 # On the other hand, if this
 # tag is set to NO the size of the Perl module output will be much smaller
 # and Perl will parse it just the same.
 
 PERLMOD_PRETTY         = YES
 
 # The names of the make variables in the generated doxyrules.make file
 # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
 # This is useful so different doxyrules.make files included by the same
 # Makefile don't overwrite each other's variables.
 
 PERLMOD_MAKEVAR_PREFIX =
 
 #---------------------------------------------------------------------------
 # Configuration options related to the preprocessor
 #---------------------------------------------------------------------------
 
 # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
 # evaluate all C-preprocessor directives found in the sources and include
 # files.
 
 ENABLE_PREPROCESSING   = YES
 
 # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
 # names in the source code. If set to NO (the default) only conditional
 # compilation will be performed. Macro expansion can be done in a controlled
 # way by setting EXPAND_ONLY_PREDEF to YES.
 
 MACRO_EXPANSION        = YES
 
 # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
 # then the macro expansion is limited to the macros specified with the
 # PREDEFINED and EXPAND_AS_DEFINED tags.
 
 EXPAND_ONLY_PREDEF     = NO
 
 # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
 # pointed to by INCLUDE_PATH will be searched when a #include is found.
 
 SEARCH_INCLUDES        = YES
 
 # The INCLUDE_PATH tag can be used to specify one or more directories that
 # contain include files that are not input files but should be processed by
 # the preprocessor.
 
 INCLUDE_PATH           =
 
 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
 # patterns (like *.h and *.hpp) to filter out the header-files in the
 # directories. If left blank, the patterns specified with FILE_PATTERNS will
 # be used.
 
 INCLUDE_FILE_PATTERNS  =
 
 # The PREDEFINED tag can be used to specify one or more macro names that
 # are defined before the preprocessor is started (similar to the -D option of
 # gcc). The argument of the tag is a list of macros of the form: name
 # or name=definition (no spaces). If the definition and the = are
 # omitted =1 is assumed. To prevent a macro definition from being
 # undefined via #undef or recursively expanded use the := operator
 # instead of the = operator.
 
 PREDEFINED             = itkNotUsed(x)= \
                          "itkSetMacro(name,type)=                   virtual void Set##name (type _arg);" \
                          "itkGetMacro(name,type)=                   virtual type Get##name ();" \
                          "itkGetConstMacro(name,type)=                   virtual type Get##name () const;" \
                          "itkSetStringMacro(name)=                   virtual void Set##name (const char* _arg);" \
                          "itkGetStringMacro(name)=                   virtual const char* Get##name () const;" \
                          "itkSetClampMacro(name,type,min,max)=                   virtual void Set##name (type _arg);" \
                          "itkSetObjectMacro(name,type)=                   virtual void Set##name (type* _arg);" \
                          "itkGetObjectMacro(name,type)=                   virtual type* Get##name ();" \
                          "itkSetConstObjectMacro(name,type)=                   virtual void Set##name ( const type* _arg);" \
                          "itkGetConstObjectMacro(name,type)=                   virtual const type* Get##name ();" \
                          "itkGetConstReferenceMacro(name,type)=                   virtual const type& Get##name ();" \
                          "itkGetConstReferenceObjectMacro(name,type)=                   virtual const type::Pointer& Get##name () const;" \
                          "itkBooleanMacro(name)=                   virtual void name##On ();                   virtual void name##Off ();" \
                          "itkSetVector2Macro(name,type)=                   virtual void Set##name (type _arg1, type _arg2)                   virtual void Set##name (type _arg[2]);" \
                          "itkGetVector2Macro(name,type)=                   virtual type* Get##name () const;                   virtual void Get##name (type& _arg1, type& _arg2) const;                   virtual void Get##name (type _arg[2]) const;" \
                          "itkSetVector3Macro(name,type)=                   virtual void Set##name (type _arg1, type _arg2, type _arg3)                   virtual void Set##name (type _arg[3]);" \
                          "itkGetVector3Macro(name,type)=                   virtual type* Get##name () const;                   virtual void Get##name (type& _arg1, type& _arg2, type& _arg3) const;                   virtual void Get##name (type _arg[3]) const;" \
                          "itkSetVector4Macro(name,type)=                   virtual void Set##name (type _arg1, type _arg2, type _arg3, type _arg4)                   virtual void Set##name (type _arg[4]);" \
                          "itkGetVector4Macro(name,type)=                   virtual type* Get##name () const;                   virtual void Get##name (type& _arg1, type& _arg2, type& _arg3, type& _arg4) const;                   virtual void Get##name (type _arg[4]) const;" \
                          "itkSetVector6Macro(name,type)=                   virtual void Set##name (type _arg1, type _arg2, type _arg3, type _arg4, type _arg5, type _arg6)                   virtual void Set##name (type _arg[6]);" \
                          "itkGetVector6Macro(name,type)=                   virtual type* Get##name () const;                   virtual void Get##name (type& _arg1, type& _arg2, type& _arg3, type& _arg4, type& _arg5, type& _arg6) const;                   virtual void Get##name (type _arg[6]) const;" \
                          "itkSetVectorMacro(name,type,count)=                   virtual void Set##name(type data[]);" \
                          "itkGetVectorMacro(name,type,count)=                   virtual type* Get##name () const;" \
                          "itkNewMacro(type)=                   static Pointer New();" \
                          "itkTypeMacro(thisClass,superclass)=                   virtual const char *GetClassName() const;" \
                          "itkConceptMacro(name,concept)=                   enum { name = 0 };" \
                          "ITK_NUMERIC_LIMITS=                   std::numeric_limits" \
                          "ITK_TYPENAME=                   typename" \
                          "FEM_ABSTRACT_CLASS(thisClass,parentClass)=                   public:                                                                   /** Standard Self typedef.*/                                          typedef thisClass Self;                                                 /** Standard Superclass typedef. */                                   typedef parentClass Superclass;                                         /** Pointer or SmartPointer to an object. */                            typedef Self* Pointer;                                                  /** Const pointer or SmartPointer to an object. */                      typedef const Self* ConstPointer;                                     private:" \
                          "FEM_CLASS(thisClass,parentClass)=                   FEM_ABSTRACT_CLASS(thisClass,parentClass)                               public:                                                                   /** Create a new object from the existing one  */                       virtual Baseclass::Pointer Clone() const;                               /** Class ID for FEM object factory */                                  static const int CLID;                                                  /** Virtual function to access the class ID */                          virtual int ClassID() const                                               { return CLID; }                                                      /** Object creation in an itk compatible way */                         static Self::Pointer New()                                                { return new Self(); }                                              private:" \
                          FREEVERSION \
                          ERROR_CHECKING \
                          HAS_TIFF \
                          HAS_JPEG \
                          HAS_NETLIB \
                          HAS_PNG \
                          HAS_ZLIB \
                          HAS_GLUT \
                          HAS_QT \
                          VCL_USE_NATIVE_STL=1 \
                          VCL_USE_NATIVE_COMPLEX=1 \
                          VCL_HAS_BOOL=1 \
                          VXL_BIG_ENDIAN=1 \
                          VXL_LITTLE_ENDIAN=0 \
                          VNL_DLL_DATA= \
                          size_t=vcl_size_t \
                          "US_PREPEND_NAMESPACE(x)=mitk::x" \
                          "US_BEGIN_NAMESPACE= namespace mitk {" \
                          "US_END_NAMESPACE=}" \
                          "US_BASECLASS_NAME=itk::LightObject" \
-                         US_EXPORT=
+                         US_EXPORT= \
+                         "DEPRECATED(func)=func"
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
 # this tag can be used to specify a list of macro names that should be expanded.
 # The macro definition that is found in the sources will be used.
 # Use the PREDEFINED tag if you want to use a different macro definition that
 # overrules the definition found in the source code.
 
 EXPAND_AS_DEFINED      =
 
 # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
 # doxygen's preprocessor will remove all references to function-like macros
 # that are alone on a line, have an all uppercase name, and do not end with a
 # semicolon, because these will confuse the parser if not removed.
 
 SKIP_FUNCTION_MACROS   = YES
 
 #---------------------------------------------------------------------------
 # Configuration::additions related to external references
 #---------------------------------------------------------------------------
 
 # The TAGFILES option can be used to specify one or more tagfiles. For each
 # tag file the location of the external documentation should be added. The
 # format of a tag file without this location is as follows:
 #
 # TAGFILES = file1 file2 ...
 # Adding location for the tag files is done as follows:
 #
 # TAGFILES = file1=loc1 "file2 = loc2" ...
 # where "loc1" and "loc2" can be relative or absolute paths
 # or URLs. Note that each tag file must have a unique name (where the name does
 # NOT include the path). If a tag file is not located in the directory in which
 # doxygen is run, you must also specify the path to the tagfile here.
 
 TAGFILES               = @BLUEBERRY_DOXYGEN_TAGFILE@
 
 # When a file name is specified after GENERATE_TAGFILE, doxygen will create
 # a tag file that is based on the input files it reads.
 
 GENERATE_TAGFILE       = @MITK_DOXYGEN_TAGFILE_NAME@
 
 # If the ALLEXTERNALS tag is set to YES all external classes will be listed
 # in the class index. If set to NO only the inherited external classes
 # will be listed.
 
 ALLEXTERNALS           = NO
 
 # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
 # in the modules index. If set to NO, only the current project's groups will
 # be listed.
 
 EXTERNAL_GROUPS        = NO
 
 # The PERL_PATH should be the absolute path and name of the perl script
 # interpreter (i.e. the result of `which perl').
 
 PERL_PATH              = /usr/bin/perl
 
 #---------------------------------------------------------------------------
 # Configuration options related to the dot tool
 #---------------------------------------------------------------------------
 
 # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
 # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
 # or super classes. Setting the tag to NO turns the diagrams off. Note that
 # this option also works with HAVE_DOT disabled, but it is recommended to
 # install and use dot, since it yields more powerful graphs.
 
 CLASS_DIAGRAMS         = YES
 
 # You can define message sequence charts within doxygen comments using the \msc
 # command. Doxygen will then run the mscgen tool (see
 # http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
 # documentation. The MSCGEN_PATH tag allows you to specify the directory where
 # the mscgen tool resides. If left empty the tool is assumed to be found in the
 # default search path.
 
 MSCGEN_PATH            =
 
 # If set to YES, the inheritance and collaboration graphs will hide
 # inheritance and usage relations if the target is undocumented
 # or is not a class.
 
 HIDE_UNDOC_RELATIONS   = YES
 
 # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
 # available from the path. This tool is part of Graphviz, a graph visualization
 # toolkit from AT&T and Lucent Bell Labs. The other options in this section
 # have no effect if this option is set to NO (the default)
 
 HAVE_DOT               = @HAVE_DOT@
 
 # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
 # allowed to run in parallel. When set to 0 (the default) doxygen will
 # base this on the number of processors available in the system. You can set it
 # explicitly to a value larger than 0 to get control over the balance
 # between CPU load and processing speed.
 
 DOT_NUM_THREADS        = @MITK_DOXYGEN_DOT_NUM_THREADS@
 
 # By default doxygen will use the Helvetica font for all dot files that
 # doxygen generates. When you want a differently looking font you can specify
 # the font name using DOT_FONTNAME. You need to make sure dot is able to find
 # the font, which can be done by putting it in a standard location or by setting
 # the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
 # directory containing the font.
 
 DOT_FONTNAME           = FreeSans.ttf
 
 # The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
 # The default size is 10pt.
 
 DOT_FONTSIZE           = 10
 
 # By default doxygen will tell dot to use the Helvetica font.
 # If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
 # set the path where dot can find it.
 
 DOT_FONTPATH           =
 
 # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
 # will generate a graph for each documented class showing the direct and
 # indirect inheritance relations. Setting this tag to YES will force the
 # CLASS_DIAGRAMS tag to NO.
 
 CLASS_GRAPH            = YES
 
 # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
 # will generate a graph for each documented class showing the direct and
 # indirect implementation dependencies (inheritance, containment, and
 # class references variables) of the class with other documented classes.
 
 COLLABORATION_GRAPH    = YES
 
 # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
 # will generate a graph for groups, showing the direct groups dependencies
 
 GROUP_GRAPHS           = YES
 
 # If the UML_LOOK tag is set to YES doxygen will generate inheritance and
 # collaboration diagrams in a style similar to the OMG's Unified Modeling
 # Language.
 
 UML_LOOK               = @MITK_DOXYGEN_UML_LOOK@
 
 # If the UML_LOOK tag is enabled, the fields and methods are shown inside
 # the class node. If there are many fields or methods and many nodes the
 # graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
 # threshold limits the number of items for each type to make the size more
 # managable. Set this to 0 for no limit. Note that the threshold may be
 # exceeded by 50% before the limit is enforced.
 
 UML_LIMIT_NUM_FIELDS   = 10
 
 # If set to YES, the inheritance and collaboration graphs will show the
 # relations between templates and their instances.
 
 TEMPLATE_RELATIONS     = YES
 
 # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
 # tags are set to YES then doxygen will generate a graph for each documented
 # file showing the direct and indirect include dependencies of the file with
 # other documented files.
 
 INCLUDE_GRAPH          = NO
 
 # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
 # HAVE_DOT tags are set to YES then doxygen will generate a graph for each
 # documented header file showing the documented files that directly or
 # indirectly include this file.
 
 INCLUDED_BY_GRAPH      = NO
 
 # If the CALL_GRAPH and HAVE_DOT options are set to YES then
 # doxygen will generate a call dependency graph for every global function
 # or class method. Note that enabling this option will significantly increase
 # the time of a run. So in most cases it will be better to enable call graphs
 # for selected functions only using the \callgraph command.
 
 CALL_GRAPH             = NO
 
 # If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
 # doxygen will generate a caller dependency graph for every global function
 # or class method. Note that enabling this option will significantly increase
 # the time of a run. So in most cases it will be better to enable caller
 # graphs for selected functions only using the \callergraph command.
 
 CALLER_GRAPH           = NO
 
 # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
 # will generate a graphical hierarchy of all classes instead of a textual one.
 
 GRAPHICAL_HIERARCHY    = NO
 
 # If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
 # then doxygen will show the dependencies a directory has on other directories
 # in a graphical way. The dependency relations are determined by the #include
 # relations between the files in the directories.
 
 DIRECTORY_GRAPH        = YES
 
 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
 # generated by dot. Possible values are svg, png, jpg, or gif.
 # If left blank png will be used. If you choose svg you need to set
 # HTML_FILE_EXTENSION to xhtml in order to make the SVG files
 # visible in IE 9+ (other browsers do not have this requirement).
 
 DOT_IMAGE_FORMAT       = png
 
 # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
 # enable generation of interactive SVG images that allow zooming and panning.
 # Note that this requires a modern browser other than Internet Explorer.
 # Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
 # need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
 # visible. Older versions of IE do not have SVG support.
 
 INTERACTIVE_SVG        = NO
 
 # The tag DOT_PATH can be used to specify the path where the dot tool can be
 # found. If left blank, it is assumed the dot tool can be found in the path.
 
 DOT_PATH               = @DOXYGEN_DOT_PATH@
 
 # The DOTFILE_DIRS tag can be used to specify one or more directories that
 # contain dot files that are included in the documentation (see the
 # \dotfile command).
 
 DOTFILE_DIRS           =
 
 # The MSCFILE_DIRS tag can be used to specify one or more directories that
 # contain msc files that are included in the documentation (see the
 # \mscfile command).
 
 MSCFILE_DIRS           =
 
 # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
 # nodes that will be shown in the graph. If the number of nodes in a graph
 # becomes larger than this value, doxygen will truncate the graph, which is
 # visualized by representing a node as a red box. Note that doxygen if the
 # number of direct children of the root node in a graph is already larger than
 # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
 # that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
 
 DOT_GRAPH_MAX_NODES    = 50
 
 # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
 # graphs generated by dot. A depth value of 3 means that only nodes reachable
 # from the root by following a path via at most 3 edges will be shown. Nodes
 # that lay further from the root node will be omitted. Note that setting this
 # option to 1 or 2 may greatly reduce the computation time needed for large
 # code bases. Also note that the size of a graph can be further restricted by
 # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
 
 MAX_DOT_GRAPH_DEPTH    = 0
 
 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
 # background. This is disabled by default, because dot on Windows does not
 # seem to support this out of the box. Warning: Depending on the platform used,
 # enabling this option may lead to badly anti-aliased labels on the edges of
 # a graph (i.e. they become hard to read).
 
 DOT_TRANSPARENT        = NO
 
 # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
 # files in one run (i.e. multiple -o and -T options on the command line). This
 # makes dot run faster, but since only newer versions of dot (>1.8.10)
 # support this, this feature is disabled by default.
 
 DOT_MULTI_TARGETS      = NO
 
 # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
 # generate a legend page explaining the meaning of the various boxes and
 # arrows in the dot generated graphs.
 
 GENERATE_LEGEND        = YES
 
 # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
 # remove the intermediate dot files that are used to generate
 # the various graphs.
 
 DOT_CLEANUP            = YES
diff --git a/LICENSE.txt b/LICENSE.txt
index 8761edc246..6497b058db 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,29 +1,36 @@
-Copyright (c) 2003-2012 German Cancer Research Center, Division of Medical
-and Biological Informatics
+Copyright (c) 2003-2012 German Cancer Research Center,
+Division of Medical and Biological Informatics
 All rights reserved.
 
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
+Redistribution and use in source and binary forms, with or
+without modification, are permitted provided that the
+following conditions are met:
 
- * Redistributions of source code must retain the above copyright notice,
-   this list of conditions and the following disclaimer.
+ * Redistributions of source code must retain the above
+   copyright notice, this list of conditions and the
+   following disclaimer.
 
- * Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
+ * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the
+   following disclaimer in the documentation and/or other
+   materials provided with the distribution.
 
- * Neither the name of the German Cancer Research Center, nor the names of 
-   its contributors may be used to endorse or promote products derived from 
-   this software without specific prior written permission.
+ * Neither the name of the German Cancer Research Center,
+   nor the names of its contributors may be used to endorse
+   or promote products derived from this software without
+   specific prior written permission.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
diff --git a/Modules/IGT/CMakeLists.txt b/Modules/IGT/CMakeLists.txt
index 7067c79cd6..a874c8e69b 100644
--- a/Modules/IGT/CMakeLists.txt
+++ b/Modules/IGT/CMakeLists.txt
@@ -1,46 +1,48 @@
 include(MITKIGTHardware.cmake)
 
 if(MITK_USE_MICRON_TRACKER)
   set(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_MICRON_TRACKER_INCLUDE_DIR})
   set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_MICRON_TRACKER_LIB})
 endif(MITK_USE_MICRON_TRACKER)
 
 if(MITK_USE_MICROBIRD_TRACKER)
   set(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_USE_MICROBIRD_TRACKER_INCLUDE_DIR})
   set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_USE_MICROBIRD_TRACKER_LIB})
 endif(MITK_USE_MICROBIRD_TRACKER)
 
 MITK_CREATE_MODULE(MitkIGT
   SUBPROJECTS MITK-IGT
   INCLUDE_DIRS IGTFilters IGTTrackingDevices IGTToolManagement IGTExceptionHandling
   INTERNAL_INCLUDE_DIRS ${INCLUDE_DIRS_INTERNAL}
   DEPENDS Mitk tinyxml SceneSerialization
   ADDITIONAL_LIBS "${ADDITIONAL_LIBS}"
 )
 
-MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/ClaronMicron.stl )
-MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/IntuitiveDaVinci.stl )
-MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIAurora.stl )
-MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIAurora_Dome.stl )
-MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIAuroraCompactFG_Dome.stl )
-MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIAuroraPlanarFG_Dome.stl )
-MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIAuroraTabletopFG_Dome.stl )
-MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIAuroraTabletopFG_Prototype_Dome.stl )
-MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIPolaris.stl )
-MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIPolarisVicra.stl )
-MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/StandardVolume.stl )
+if(MitkIGT_IS_ENABLED)
+  MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/ClaronMicron.stl )
+  MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/IntuitiveDaVinci.stl )
+  MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIAurora.stl )
+  MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIAurora_Dome.stl )
+  MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIAuroraCompactFG_Dome.stl )
+  MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIAuroraPlanarFG_Dome.stl )
+  MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIAuroraTabletopFG_Dome.stl )
+  MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIAuroraTabletopFG_Prototype_Dome.stl )
+  MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIPolaris.stl )
+  MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/NDIPolarisVicra.stl )
+  MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/IGTTrackingDevices/TrackingVolumeData/StandardVolume.stl )
+endif()
 
 MITK_CHECK_MODULE(_RESULT MitkIGT)
 if(_RESULT)
   message(STATUS "IGTTutorialStep1 won't be built. Missing: ${_RESULT}")
 else(_RESULT)
 ## create IGT config
 configure_file(mitkIGTConfig.h.in ${PROJECT_BINARY_DIR}/mitkIGTConfig.h @ONLY)
 
 # add test programm for serial communication classADD_EXECUTABLE(SerialCommunicationTest IGTTrackingDevices/mitkSerialCommunicationTest.cpp)target_link_libraries(SerialCommunicationTest mitkIGT Mitk tinyxml PocoXML)
 
 add_subdirectory(IGTTutorial)
 
 add_subdirectory(Testing)
 endif(_RESULT)
 
diff --git a/Modules/MitkExt/Controllers/mitkToolManager.cpp b/Modules/MitkExt/Controllers/mitkToolManager.cpp
index a1304cba73..30854299e1 100644
--- a/Modules/MitkExt/Controllers/mitkToolManager.cpp
+++ b/Modules/MitkExt/Controllers/mitkToolManager.cpp
@@ -1,513 +1,528 @@
 /*===================================================================
 
 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 "mitkToolManager.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkCoreObjectFactory.h"
 
 #include <itkObjectFactoryBase.h>
 #include <itkCommand.h>
 
 #include <list>
 
 mitk::ToolManager::ToolManager(DataStorage* storage)
 :m_ActiveTool(NULL),
  m_ActiveToolID(-1),
  m_RegisteredClients(0),
  m_DataStorage(storage)
 {
   CoreObjectFactory::GetInstance(); // to make sure a CoreObjectFactory was instantiated (and in turn, possible tools are registered) - bug 1029
 
   // get a list of all known mitk::Tools
   std::list<itk::LightObject::Pointer> thingsThatClaimToBeATool = itk::ObjectFactoryBase::CreateAllInstance("mitkTool");
 
   // remember these tools
   for ( std::list<itk::LightObject::Pointer>::iterator iter = thingsThatClaimToBeATool.begin();
     iter != thingsThatClaimToBeATool.end();
     ++iter )
   {
     if ( Tool* tool = dynamic_cast<Tool*>( iter->GetPointer() ) )
     {
       tool->SetToolManager(this); // important to call right after instantiation
       tool->ErrorMessage += MessageDelegate1<mitk::ToolManager, std::string>( this, &ToolManager::OnToolErrorMessage );
       tool->GeneralMessage += MessageDelegate1<mitk::ToolManager, std::string>( this, &ToolManager::OnGeneralToolMessage );
       m_Tools.push_back( tool );
     }
   }
 
   //ActivateTool(0); // first one is default
 }
 
 mitk::ToolManager::~ToolManager()
 {
   for (DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
     (*dataIter)->RemoveObserver(m_WorkingDataObserverTags[(*dataIter)]);
 
+  if(this->GetDataStorage() != NULL)
+    this->GetDataStorage()->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<ToolManager, const mitk::DataNode*>
+        ( this, &ToolManager::OnNodeRemoved ));
+
   if (m_ActiveTool)
   {
     m_ActiveTool->Deactivated();
     GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
 
     m_ActiveTool = NULL;
     m_ActiveToolID = -1; // no tool active
 
     ActiveToolChanged.Send();
+
   }
   for ( NodeTagMapType::iterator observerTagMapIter = m_ReferenceDataObserverTags.begin(); observerTagMapIter != m_ReferenceDataObserverTags.end(); ++observerTagMapIter )
   {
     observerTagMapIter->first->RemoveObserver( observerTagMapIter->second );
   }
 }
 
 void mitk::ToolManager::OnToolErrorMessage(std::string s)
 {
   this->ToolErrorMessage(s);
 }
 
 void mitk::ToolManager::OnGeneralToolMessage(std::string s)
 {
   this->GeneralToolMessage(s);
 }
 
 
 const mitk::ToolManager::ToolVectorTypeConst mitk::ToolManager::GetTools()
 {
   ToolVectorTypeConst resultList;
 
   for ( ToolVectorType::iterator iter = m_Tools.begin();
     iter != m_Tools.end();
     ++iter )
   {
     resultList.push_back( iter->GetPointer() );
   }
 
   return resultList;
 }
 
 mitk::Tool* mitk::ToolManager::GetToolById(int id)
 {
   try
   {
     return m_Tools.at(id);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 bool mitk::ToolManager::ActivateTool(int id)
 {
 
   if(this->GetDataStorage())
     {
       this->GetDataStorage()->RemoveNodeEvent.AddListener( mitk::MessageDelegate1<ToolManager, const mitk::DataNode*>
         ( this, &ToolManager::OnNodeRemoved ) );
     }
 
   //MITK_INFO << "ToolManager::ActivateTool("<<id<<")"<<std::endl;
   //if( GetToolById(id) == NULL ) return false; // NO, invalid IDs are actually used here. Parameter -1 or anything that does not exists will deactivate all tools!
 
+  //If a tool is deactivated set the event notification policy of the global interaction to multiple again
+  if (id == -1)
+    GlobalInteraction::GetInstance()->SetEventNotificationPolicy(GlobalInteraction::INFORM_MULTIPLE);
+
   if ( GetToolById( id ) == m_ActiveTool ) return true; // no change needed
 
   static int nextTool = -1;
   nextTool = id;
   //MITK_INFO << "ToolManager::ActivateTool("<<id<<"): nextTool = "<<nextTool<<std::endl;
 
   static bool inActivateTool = false;
   if (inActivateTool)
   {
     //MITK_INFO << "ToolManager::ActivateTool("<<id<<"): already inside ActivateTool somehow, returning now "<<std::endl;
     return true;
   }
   inActivateTool = true;
 
   while ( nextTool != m_ActiveToolID )
   {
     //MITK_INFO <<"ToolManager::ActivateTool: nextTool = " << nextTool << " (active tool = " << m_ActiveToolID<<")"<<std::endl;
     if (m_ActiveTool)
     {
       m_ActiveTool->Deactivated();
       GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
     }
 
     m_ActiveTool = GetToolById( nextTool );
     m_ActiveToolID = m_ActiveTool ? nextTool : -1; // current ID if tool is valid, otherwise -1
 
     ActiveToolChanged.Send();
 
     if (m_ActiveTool)
     {
       if (m_RegisteredClients > 0)
       {
         m_ActiveTool->Activated();
         GlobalInteraction::GetInstance()->AddListener( m_ActiveTool );
+        //If a tool is activated set event notification policy to one
+        GlobalInteraction::GetInstance()->SetEventNotificationPolicy(GlobalInteraction::INFORM_ONE);
       }
     }
   }
 
   inActivateTool = false;
   return (m_ActiveTool != NULL);
 }
 
 void mitk::ToolManager::SetReferenceData(DataVectorType data)
 {
   if (data != m_ReferenceData)
   {
     // remove observers from old nodes
     for ( DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
     {
       NodeTagMapType::iterator searchIter = m_ReferenceDataObserverTags.find( *dataIter );
       if ( searchIter != m_ReferenceDataObserverTags.end() )
       {
         //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
         (*dataIter)->RemoveObserver( searchIter->second );
       }
     }
 
     m_ReferenceData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_ReferenceDataObserverTags.clear();
     for ( DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
     {
       
 
       //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheReferenceDataDeleted );
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheReferenceDataDeletedConst );
       m_ReferenceDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
     }
 
     ReferenceDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::OnOneOfTheReferenceDataDeletedConst(const itk::Object* caller, const itk::EventObject& e)
 {
   OnOneOfTheReferenceDataDeleted( const_cast<itk::Object*>(caller), e );
 }
 
 void mitk::ToolManager::OnOneOfTheReferenceDataDeleted(itk::Object* caller, const itk::EventObject& itkNotUsed(e))
 {
   //MITK_INFO << "Deleted: " << (void*)caller << " Removing from reference data list." << std::endl;
   DataVectorType v;
 
   for (DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
   {
     //MITK_INFO << " In list: " << (void*)(*dataIter);
     if ( (void*)(*dataIter) != (void*)caller )
     {
       v.push_back( *dataIter );
       //MITK_INFO << " kept" << std::endl;
     }
     else
     {
       //MITK_INFO << " removed" << std::endl;
       m_ReferenceDataObserverTags.erase( *dataIter ); // no tag to remove anymore
     }
   }
   this->SetReferenceData( v );
 }
 
 void mitk::ToolManager::SetReferenceData(DataNode* data)
 {
   //MITK_INFO << "ToolManager::SetReferenceData(" << (void*)data << ")" << std::endl;
   DataVectorType v;
   if (data)
   {
     v.push_back(data);
   }
   SetReferenceData(v);
 }
 
 void mitk::ToolManager::SetWorkingData(DataVectorType data)
 {
   if ( data != m_WorkingData )
   {
     // remove observers from old nodes
     for ( DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
     {
       NodeTagMapType::iterator searchIter = m_WorkingDataObserverTags.find( *dataIter );
       if ( searchIter != m_WorkingDataObserverTags.end() )
       {
         //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
         (*dataIter)->RemoveObserver( searchIter->second );
       }
     }
 
     m_WorkingData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_WorkingDataObserverTags.clear();
     for ( DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
     {
       //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheWorkingDataDeleted );
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheWorkingDataDeletedConst );
       m_WorkingDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
     }
 
     WorkingDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::OnOneOfTheWorkingDataDeletedConst(const itk::Object* caller, const itk::EventObject& e)
 {
   OnOneOfTheWorkingDataDeleted( const_cast<itk::Object*>(caller), e );
 }
 
 void mitk::ToolManager::OnOneOfTheWorkingDataDeleted(itk::Object* caller, const itk::EventObject& itkNotUsed(e))
 {
   //MITK_INFO << "Deleted: " << (void*)caller << " Removing from reference data list." << std::endl;
   DataVectorType v;
 
   for (DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
   {
     //MITK_INFO << " In list: " << (void*)(*dataIter);
     if ( (void*)(*dataIter) != (void*)caller )
     {
       v.push_back( *dataIter );
       //MITK_INFO << " kept" << std::endl;
     }
     else
     {
       //MITK_INFO << " removed" << std::endl;
       m_WorkingDataObserverTags.erase( *dataIter ); // no tag to remove anymore
     }
   }
   this->SetWorkingData( v );
 }
 
 
 void mitk::ToolManager::SetWorkingData(DataNode* data)
 {
   DataVectorType v;
 
   if (data) // don't allow for NULL nodes
   {
     v.push_back(data);
   }
 
   SetWorkingData(v);
 }
 
 void mitk::ToolManager::SetRoiData(DataVectorType data)
 {
   if (data != m_RoiData)
   {
     // remove observers from old nodes
     for ( DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
     {
       NodeTagMapType::iterator searchIter = m_RoiDataObserverTags.find( *dataIter );
       if ( searchIter != m_RoiDataObserverTags.end() )
       {
         //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
         (*dataIter)->RemoveObserver( searchIter->second );
       }
     }
 
     m_RoiData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_RoiDataObserverTags.clear();
     for ( DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
     {
       //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheRoiDataDeleted );
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheRoiDataDeletedConst );
       m_RoiDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
     }
     RoiDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::SetRoiData(DataNode* data)
 {
   DataVectorType v;
 
   if(data)
   {
     v.push_back(data);
   }
   this->SetRoiData(v);
 }
 
 void mitk::ToolManager::OnOneOfTheRoiDataDeletedConst(const itk::Object* caller, const itk::EventObject& e)
 {
   OnOneOfTheRoiDataDeleted( const_cast<itk::Object*>(caller), e );
 }
 
 void mitk::ToolManager::OnOneOfTheRoiDataDeleted(itk::Object* caller, const itk::EventObject& itkNotUsed(e))
 {
   //MITK_INFO << "Deleted: " << (void*)caller << " Removing from roi data list." << std::endl;
   DataVectorType v;
 
   for (DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
   {
     //MITK_INFO << " In list: " << (void*)(*dataIter);
     if ( (void*)(*dataIter) != (void*)caller )
     {
       v.push_back( *dataIter );
       //MITK_INFO << " kept" << std::endl;
     }
     else
     {
       //MITK_INFO << " removed" << std::endl;
       m_RoiDataObserverTags.erase( *dataIter ); // no tag to remove anymore
     }
   }
   this->SetRoiData( v );
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetReferenceData()
 {
   return m_ReferenceData;
 }
 
 mitk::DataNode* mitk::ToolManager::GetReferenceData(int idx)
 {
   try
   {
     return m_ReferenceData.at(idx);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetWorkingData()
 {
   return m_WorkingData;
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetRoiData()
 {
   return m_RoiData;
 }
 
 mitk::DataNode* mitk::ToolManager::GetRoiData(int idx)
 {
   try
   {
     return m_RoiData.at(idx);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 mitk::DataStorage* mitk::ToolManager::GetDataStorage()
 {
   if ( m_DataStorage.IsNotNull() )
   {
     return m_DataStorage;
   }
   else
   {
     return NULL;
   }
 }
 
 void mitk::ToolManager::SetDataStorage(DataStorage& storage)
 {
   m_DataStorage = &storage;
 }
 
 
 
 mitk::DataNode* mitk::ToolManager::GetWorkingData(int idx)
 {
   try
   {
     return m_WorkingData.at(idx);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 int mitk::ToolManager::GetActiveToolID()
 {
   return m_ActiveToolID;
 }
 
 mitk::Tool* mitk::ToolManager::GetActiveTool()
 {
   return m_ActiveTool;
 }
 
 void mitk::ToolManager::RegisterClient()
 {
   if ( m_RegisteredClients < 1 )
   {
     if ( m_ActiveTool )
     {
       m_ActiveTool->Activated();
       GlobalInteraction::GetInstance()->AddListener( m_ActiveTool );
     }
   }
   ++m_RegisteredClients;
 }
 
 void mitk::ToolManager::UnregisterClient()
 {
   if ( m_RegisteredClients < 1) return;
 
   --m_RegisteredClients;
   if ( m_RegisteredClients < 1 )
   {
     if ( m_ActiveTool )
     {
       m_ActiveTool->Deactivated();
       GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
     }
   }
 }
 
 int mitk::ToolManager::GetToolID( const Tool* tool )
 {
   int id(0);
   for ( ToolVectorType::iterator iter = m_Tools.begin();
     iter != m_Tools.end();
     ++iter, ++id )
   {
     if ( tool == iter->GetPointer() )
     {
       return id;
     }
   }
   return -1;
 }
 
 
 void mitk::ToolManager::OnNodeRemoved(const mitk::DataNode* node)
 {
-  //check all storage vectors
-  OnOneOfTheReferenceDataDeleted(const_cast<mitk::DataNode*>(node), itk::DeleteEvent());
-  OnOneOfTheRoiDataDeleted(const_cast<mitk::DataNode*>(node),itk::DeleteEvent());
-  OnOneOfTheWorkingDataDeleted(const_cast<mitk::DataNode*>(node),itk::DeleteEvent());
+  //check if the data of the node is typeof Image
+  /*if(dynamic_cast<mitk::Image*>(node->GetData()))
+  {*/
+    //check all storage vectors
+    OnOneOfTheReferenceDataDeleted(const_cast<mitk::DataNode*>(node), itk::DeleteEvent());
+    OnOneOfTheRoiDataDeleted(const_cast<mitk::DataNode*>(node),itk::DeleteEvent());
+    OnOneOfTheWorkingDataDeleted(const_cast<mitk::DataNode*>(node),itk::DeleteEvent());
+  //}
 }
 
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
index 68766b321f..aeb95dcd04 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
@@ -1,690 +1,734 @@
 /*===================================================================
 
 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 "mitkPlanarFigureMapper2D.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkGL.h"
 #include "mitkVtkPropRenderer.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // offset which moves the planarfigures on top of the other content
 // the crosshair is rendered into the z = 1 layer. 
 static const float PLANAR_OFFSET = 0.5f;
 
 mitk::PlanarFigureMapper2D::PlanarFigureMapper2D()
 {
   this->InitializeDefaultPlanarFigureProperties();
 }
 
 
 mitk::PlanarFigureMapper2D::~PlanarFigureMapper2D()
 {
 }
 
 
 void mitk::PlanarFigureMapper2D::Paint( mitk::BaseRenderer *renderer )
 {
   if ( !this->IsVisible( renderer ) ) 
   {
     return;
   }
 
   // Get PlanarFigure from input
   mitk::PlanarFigure *planarFigure = const_cast< mitk::PlanarFigure * >(
     static_cast< const mitk::PlanarFigure * >( this->GetData() ) );
 
   // Check if PlanarFigure has already been placed; otherwise, do nothing
   if ( !planarFigure->IsPlaced() )
   {
     return;
   }
 
   // Get 2D geometry frame of PlanarFigure
   mitk::Geometry2D *planarFigureGeometry2D = 
     dynamic_cast< Geometry2D * >( planarFigure->GetGeometry( 0 ) );
   if ( planarFigureGeometry2D == NULL )
   {
     MITK_ERROR << "PlanarFigure does not have valid Geometry2D!";
     return;
   }
 
   // Get current world 2D geometry from renderer
   const mitk::Geometry2D *rendererGeometry2D = renderer->GetCurrentWorldGeometry2D();
 
   // If the PlanarFigure geometry is a plane geometry, check if current
   // world plane is parallel to and within the planar figure geometry bounds
   // (otherwise, display nothing)
   mitk::PlaneGeometry *planarFigurePlaneGeometry = 
     dynamic_cast< PlaneGeometry * >( planarFigureGeometry2D );
   const mitk::PlaneGeometry *rendererPlaneGeometry = 
     dynamic_cast< const PlaneGeometry * >( rendererGeometry2D );
 
   if ( (planarFigurePlaneGeometry != NULL) && (rendererPlaneGeometry != NULL) )
   {
     double planeThickness = planarFigurePlaneGeometry->GetExtentInMM( 2 );
     if ( !planarFigurePlaneGeometry->IsParallel( rendererPlaneGeometry )
       || !(planarFigurePlaneGeometry->DistanceFromPlane( 
       rendererPlaneGeometry ) < planeThickness / 3.0) )
     {
       // Planes are not parallel or renderer plane is not within PlanarFigure
       // geometry bounds --> exit
       return;
     }
   }
   else
   {
     // Plane is not valid (curved reformations are not possible yet)
     return;
   }
 
 
   // Get display geometry
   mitk::DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
   assert( displayGeometry != NULL );
 
 
   // Apply visual appearance properties from the PropertyList
   this->ApplyProperties( renderer );
 
   // Enable line antialiasing
   glEnable( GL_LINE_SMOOTH );
   glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
   glEnable(GL_DEPTH_TEST);
   
   // Get properties from node (if present)
   const mitk::DataNode* node=this->GetDataNode();
   this->InitializePlanarFigurePropertiesFromDataNode( node );
 
   PlanarFigureDisplayMode lineDisplayMode = PF_DEFAULT;
 
   if ( m_IsSelected )
   {
     lineDisplayMode = PF_SELECTED;
   }
   else if ( m_IsHovering )
   {
     lineDisplayMode = PF_HOVER;
   }
 
   mitk::Point2D firstPoint; firstPoint[0] = 0; firstPoint[1] = 1;
 
   if ( m_DrawOutline )
   {
     // Draw the outline for all polylines if requested
     this->DrawMainLines( planarFigure,
       m_OutlineColor[lineDisplayMode],
       m_OutlineOpacity[lineDisplayMode],
       m_DrawShadow,
       m_OutlineWidth,
       m_ShadowWidthFactor,
       firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
     // Draw the outline for all helper objects if requested
     this->DrawHelperLines( planarFigure,
       m_OutlineColor[lineDisplayMode],
       m_OutlineOpacity[lineDisplayMode],
       m_DrawShadow,
       m_OutlineWidth,
       m_ShadowWidthFactor,
       firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
   }
 
 
   // Draw the main line for all polylines
   this->DrawMainLines( planarFigure,
     m_LineColor[lineDisplayMode],
     m_LineOpacity[lineDisplayMode],
     m_DrawShadow,
     m_LineWidth,
     m_ShadowWidthFactor,
     firstPoint,
     planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
   double annotationOffset = 0.0;
 
+  //Get Global Opacity
+  float globalOpacity = 1.0;
+  node->GetFloatProperty("opacity", globalOpacity);
+
   // draw name near the first point (if present)
   std::string name = node->GetName();
   if ( m_DrawName && !name.empty() )
   {
     mitk::VtkPropRenderer* openGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
     if ( openGLrenderer )
     {
       openGLrenderer->WriteSimpleText( name,
         firstPoint[0] + 6.0, firstPoint[1] + 4.0,
         0,
         0,
-        0); //this is a shadow 
+        0,
+        globalOpacity ); //this is a shadow
       openGLrenderer->WriteSimpleText( name,
         firstPoint[0] + 5.0, firstPoint[1] + 5.0,
         m_LineColor[lineDisplayMode][0],
         m_LineColor[lineDisplayMode][1],
-        m_LineColor[lineDisplayMode][2] );
+        m_LineColor[lineDisplayMode][2],
+        globalOpacity );
     
       // If drawing is successful, add approximate height to annotation offset
       annotationOffset -= 15.0;
     }
   }
 
   // draw feature quantities (if requested) new the first point
   if ( m_DrawQuantities )
   {
     std::stringstream quantityString;
     quantityString.setf( ios::fixed, ios::floatfield );
     quantityString.precision( 1 );
 
     bool firstActiveFeature = true;
     for ( unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i )
     {     
       if( planarFigure->IsFeatureActive(i) && planarFigure->IsFeatureVisible( i ) )
       {
         if ( ! firstActiveFeature ) 
         {
           quantityString << " x ";
         }
         quantityString << planarFigure->GetQuantity( i ) << " ";
         quantityString << planarFigure->GetFeatureUnit( i );
         firstActiveFeature = false;
       }
     }
 
     mitk::VtkPropRenderer* openGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
     if ( openGLrenderer )
     {
       openGLrenderer->WriteSimpleText( quantityString.str().c_str(), 
         firstPoint[0] + 6.0, firstPoint[1] + 4.0 + annotationOffset,
         0,
         0,
-        0); //this is a shadow 
+        0,
+        globalOpacity ); //this is a shadow
 
       openGLrenderer->WriteSimpleText( quantityString.str().c_str(),
         firstPoint[0] + 5.0, firstPoint[1] + 5.0 + annotationOffset,
         m_LineColor[lineDisplayMode][0],
         m_LineColor[lineDisplayMode][1],
-        m_LineColor[lineDisplayMode][2] );
+        m_LineColor[lineDisplayMode][2],
+        globalOpacity );
 
       // If drawing is successful, add approximate height to annotation offset
       annotationOffset -= 15.0;
     }
   }
 
 
   // Draw helper objects
   this->DrawHelperLines( planarFigure,
     m_HelperlineColor[lineDisplayMode],
     m_HelperlineOpacity[lineDisplayMode],
     m_DrawShadow,
     m_LineWidth,
     m_ShadowWidthFactor,
     firstPoint,
     planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
 
   if ( m_DrawControlPoints )
   {
     // Draw markers at control points (selected control point will be colored)
     for ( unsigned int i = 0; i < planarFigure->GetNumberOfControlPoints(); ++i )
     {
 
       bool isEditable = true;
       m_DataNode->GetBoolProperty( "planarfigure.iseditable", isEditable );
 
       PlanarFigureDisplayMode pointDisplayMode = PF_DEFAULT;
 
       // Only if planar figure is marked as editable: display markers (control points) in a
       // different style if mouse is over them or they are selected
       if ( isEditable )
       {
         if ( i == (unsigned int) planarFigure->GetSelectedControlPoint() )
         {
           pointDisplayMode = PF_SELECTED;
         }
         else if ( m_IsHovering )
         {
           pointDisplayMode = PF_HOVER;
         }
       }
 
       this->DrawMarker( planarFigure->GetControlPoint( i ),
         m_MarkerlineColor[pointDisplayMode],
         m_MarkerlineOpacity[pointDisplayMode],
         m_MarkerColor[pointDisplayMode],
         m_MarkerOpacity[pointDisplayMode],
         m_LineWidth,
         m_ControlPointShape,
         planarFigureGeometry2D, 
         rendererGeometry2D, 
         displayGeometry );
     }
 
     if ( planarFigure->IsPreviewControlPointVisible() )
     {
       this->DrawMarker( planarFigure->GetPreviewControlPoint(),
         m_MarkerlineColor[PF_HOVER],
         m_MarkerlineOpacity[PF_HOVER],
         m_MarkerColor[PF_HOVER],
         m_MarkerOpacity[PF_HOVER],
         m_LineWidth,
         m_ControlPointShape,
         planarFigureGeometry2D, 
         rendererGeometry2D, 
         displayGeometry 
         );
     }
   }
 
   glLineWidth( 1.0f );
 }
 
 
 void mitk::PlanarFigureMapper2D::PaintPolyLine(
   mitk::PlanarFigure::PolyLineType vertices,  
   bool closed,
   float* color, 
   float opacity, 
   float lineWidth, 
   Point2D& firstPoint, 
   const Geometry2D* planarFigureGeometry2D, 
   const Geometry2D* rendererGeometry2D, 
   const DisplayGeometry* displayGeometry)
 {
   glColor4f( color[0], color[1], color[2], opacity );
   glLineWidth(lineWidth);
 
   if ( closed )
   {
     glBegin( GL_LINE_LOOP );
   }
   else 
   {
     glBegin( GL_LINE_STRIP );
   }
 
   for ( PlanarFigure::PolyLineType::iterator iter = vertices.begin(); iter!=vertices.end(); iter++ )
   {
     // Draw this 2D point as OpenGL vertex
     mitk::Point2D displayPoint;
     this->TransformObjectToDisplay( iter->Point, displayPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
     if(iter == vertices.begin())
       firstPoint = displayPoint;
 
     glVertex3f( displayPoint[0], displayPoint[1], PLANAR_OFFSET );
   }
 
   glEnd();
 }
 
 
 void mitk::PlanarFigureMapper2D::DrawMainLines( 
   mitk::PlanarFigure* figure, 
   float* color, 
   float opacity, 
   bool drawShadow,
   float lineWidth, 
   float shadowWidthFactor,
   Point2D& firstPoint,
   const Geometry2D* planarFigureGeometry2D, 
   const Geometry2D* rendererGeometry2D, 
   const DisplayGeometry* displayGeometry)
 {
   for ( unsigned short loop = 0; loop < figure->GetPolyLinesSize(); ++loop )
   {
     PlanarFigure::PolyLineType polyline = figure->GetPolyLine(loop);
 
     if ( drawShadow )
     {
       float* shadow = new float[3];
       shadow[0] = 0;
       shadow[1] = 0;
       shadow[2] = 0;
 
+      //set shadow opacity
+      float shadowOpacity = 0.0f;
+      if( opacity > 0.2f )
+        shadowOpacity = opacity - 0.2f;
+
       this->PaintPolyLine( polyline, 
         figure->IsClosed(),    
-        shadow, 0.8, lineWidth*shadowWidthFactor, firstPoint,
+        shadow, shadowOpacity, lineWidth*shadowWidthFactor, firstPoint,
         planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
       delete shadow;
     }
 
     this->PaintPolyLine( polyline, 
       figure->IsClosed(),    
       color, opacity, lineWidth, firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
   }
 }
 
 void mitk::PlanarFigureMapper2D::DrawHelperLines(
   mitk::PlanarFigure* figure,
   float* color, 
   float opacity, 
   bool drawShadow,
   float lineWidth,
   float shadowWidthFactor,
   Point2D& firstPoint,
   const Geometry2D* planarFigureGeometry2D, 
   const Geometry2D* rendererGeometry2D, 
   const DisplayGeometry* displayGeometry)
 {
   // Draw helper objects
   for ( unsigned int loop = 0; loop < figure->GetHelperPolyLinesSize(); ++loop )
   {
     const mitk::PlanarFigure::PolyLineType helperPolyLine = figure->GetHelperPolyLine(loop,
       displayGeometry->GetScaleFactorMMPerDisplayUnit(),
       displayGeometry->GetDisplayHeight() );
 
     // Check if the current helper objects is to be painted
     if ( !figure->IsHelperToBePainted( loop ) )
     {
       continue;
     }
 
     // check if shadow shall be painted around the figure
     if ( drawShadow )
     {
       float* shadow = new float[3];
       shadow[0] = 0;
       shadow[1] = 0;
       shadow[2] = 0;
 
+      //set shadow opacity
+      float shadowOpacity = 0.0f;
+      if( opacity > 0.2f )
+        shadowOpacity = opacity - 0.2f;
+
       // paint shadow by painting the figure twice
       // one in black with a slightly broader line-width ...
       this->PaintPolyLine( helperPolyLine, false,
-        shadow, 0.8, lineWidth*shadowWidthFactor, firstPoint,
+        shadow, shadowOpacity, lineWidth*shadowWidthFactor, firstPoint,
         planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
       delete shadow;
     }
 
     // ... and once normally above the shadow.
     this->PaintPolyLine( helperPolyLine, false,
       color, opacity, lineWidth, firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
   }
 }
 
 
 
 void mitk::PlanarFigureMapper2D::TransformObjectToDisplay(
   const mitk::Point2D &point2D,
   mitk::Point2D &displayPoint,
   const mitk::Geometry2D *objectGeometry,
   const mitk::Geometry2D *rendererGeometry,
   const mitk::DisplayGeometry *displayGeometry )
 {
   mitk::Point3D point3D;
 
   // Map circle point from local 2D geometry into 3D world space
   objectGeometry->Map( point2D, point3D );
 
   // Project 3D world point onto display geometry
   rendererGeometry->Map( point3D, displayPoint );
   displayGeometry->WorldToDisplay( displayPoint, displayPoint );
 }
 
 
 void mitk::PlanarFigureMapper2D::DrawMarker(
   const mitk::Point2D &point,
   float* lineColor,
   float lineOpacity,
   float* markerColor,
   float markerOpacity,
   float lineWidth,
   PlanarFigureControlPointStyleProperty::Shape shape,
   const mitk::Geometry2D *objectGeometry,
   const mitk::Geometry2D *rendererGeometry,
   const mitk::DisplayGeometry *displayGeometry )
 {
   mitk::Point2D displayPoint;
 
   if ( markerOpacity == 0 && lineOpacity == 0 )
     return;
 
   this->TransformObjectToDisplay(
     point, displayPoint,
     objectGeometry, rendererGeometry, displayGeometry );
 
   glColor4f( markerColor[0], markerColor[1], markerColor[2], markerOpacity );
   glLineWidth( lineWidth );
 
   switch ( shape )
   {
   case PlanarFigureControlPointStyleProperty::Square:
   default:
     // Paint filled square
 
     // Disable line antialiasing (does not look nice for squares)
     glDisable( GL_LINE_SMOOTH );
 
     glRectf(
       displayPoint[0] - 4, displayPoint[1] - 4, 
       displayPoint[0] + 4, displayPoint[1] + 4 );
 
     // Paint outline
     glColor4f( lineColor[0], lineColor[1], lineColor[2], lineOpacity );
     glBegin( GL_LINE_LOOP );
     glVertex3f( displayPoint[0] - 4, displayPoint[1] - 4, PLANAR_OFFSET );
     glVertex3f( displayPoint[0] - 4, displayPoint[1] + 4, PLANAR_OFFSET );
     glVertex3f( displayPoint[0] + 4, displayPoint[1] + 4, PLANAR_OFFSET );
     glVertex3f( displayPoint[0] + 4, displayPoint[1] - 4, PLANAR_OFFSET );
     glEnd();
     break;
 
   case PlanarFigureControlPointStyleProperty::Circle:
     // Paint filled circle
     glBegin( GL_POLYGON );
     float radius = 4.0;
     for ( int angle = 0; angle < 8; ++angle )
     {
       float angleRad = angle * (float) 3.14159 / 4.0;
       float x = displayPoint[0] + radius * (float)cos( angleRad );
       float y = displayPoint[1] + radius * (float)sin( angleRad );
       glVertex3f(x, y, PLANAR_OFFSET);
     }
     glEnd();
 
     // Paint outline
     glColor4f( lineColor[0], lineColor[1], lineColor[2], lineOpacity );
     glBegin( GL_LINE_LOOP );
     for ( int angle = 0; angle < 8; ++angle )
     {
       float angleRad = angle * (float) 3.14159 / 4.0;
       float x = displayPoint[0] + radius * (float)cos( angleRad );
       float y = displayPoint[1] + radius * (float)sin( angleRad );
       glVertex3f(x, y, PLANAR_OFFSET);
     }
     glEnd();
     break;
 
   } // end switch
 }
 
 
 void mitk::PlanarFigureMapper2D::InitializeDefaultPlanarFigureProperties()
 {
   m_IsSelected = false;
   m_IsHovering = false;
   m_DrawOutline = false;
   m_DrawQuantities = false;
   m_DrawShadow = false;
   m_DrawControlPoints = false;
   m_DrawName = true;
 
   m_ShadowWidthFactor = 1.2;
   m_LineWidth = 1.0;
   m_OutlineWidth = 4.0;
   m_HelperlineWidth = 2.0;
 
   m_ControlPointShape = PlanarFigureControlPointStyleProperty::Square;
 
   this->SetColorProperty( m_LineColor, PF_DEFAULT, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_LineOpacity, PF_DEFAULT, 1.0 );
   this->SetColorProperty( m_OutlineColor, PF_DEFAULT, 0.0, 0.0, 1.0 );
   this->SetFloatProperty( m_OutlineOpacity, PF_DEFAULT, 1.0 );
   this->SetColorProperty( m_HelperlineColor, PF_DEFAULT, 0.4, 0.8, 0.2 );
   this->SetFloatProperty( m_HelperlineOpacity, PF_DEFAULT, 0.4 );
   this->SetColorProperty( m_MarkerlineColor, PF_DEFAULT, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerlineOpacity, PF_DEFAULT, 1.0 );
   this->SetColorProperty( m_MarkerColor, PF_DEFAULT, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerOpacity, PF_DEFAULT, 0.0 );
 
   this->SetColorProperty( m_LineColor, PF_HOVER, 1.0, 0.7, 0.0 );
   this->SetFloatProperty( m_LineOpacity, PF_HOVER, 1.0 );
   this->SetColorProperty( m_OutlineColor, PF_HOVER, 0.0, 0.0, 1.0 );
   this->SetFloatProperty( m_OutlineOpacity, PF_HOVER, 1.0 );
   this->SetColorProperty( m_HelperlineColor, PF_HOVER, 0.4, 0.8, 0.2 );
   this->SetFloatProperty( m_HelperlineOpacity, PF_HOVER, 0.4 );
   this->SetColorProperty( m_MarkerlineColor, PF_HOVER, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerlineOpacity, PF_HOVER, 1.0 );
   this->SetColorProperty( m_MarkerColor, PF_HOVER, 1.0, 0.6, 0.0 );
   this->SetFloatProperty( m_MarkerOpacity, PF_HOVER, 0.2 );
 
   this->SetColorProperty( m_LineColor, PF_SELECTED, 1.0, 0.0, 0.0 );
   this->SetFloatProperty( m_LineOpacity, PF_SELECTED, 1.0 );
   this->SetColorProperty( m_OutlineColor, PF_SELECTED, 0.0, 0.0, 1.0 );
   this->SetFloatProperty( m_OutlineOpacity, PF_SELECTED, 1.0 );
   this->SetColorProperty( m_HelperlineColor, PF_SELECTED, 0.4, 0.8, 0.2 );
   this->SetFloatProperty( m_HelperlineOpacity, PF_SELECTED, 0.4 );
   this->SetColorProperty( m_MarkerlineColor, PF_SELECTED, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerlineOpacity, PF_SELECTED, 1.0 );
   this->SetColorProperty( m_MarkerColor, PF_SELECTED, 1.0, 0.6, 0.0 );
   this->SetFloatProperty( m_MarkerOpacity, PF_SELECTED, 1.0 );
 }
 
 
 void mitk::PlanarFigureMapper2D::InitializePlanarFigurePropertiesFromDataNode( const mitk::DataNode* node )
 {
   if ( node == NULL )
   {
     return;
   }
 
+  //Get Global Opacity
+  float globalOpacity = 1.0;
+  node->GetFloatProperty("opacity", globalOpacity);
+
   node->GetBoolProperty( "selected", m_IsSelected );
   node->GetBoolProperty( "planarfigure.ishovering", m_IsHovering );
   node->GetBoolProperty( "planarfigure.drawoutline", m_DrawOutline );
-  node->GetBoolProperty( "planarfigure.drawquantities", m_DrawQuantities );
   node->GetBoolProperty( "planarfigure.drawshadow", m_DrawShadow );
+  node->GetBoolProperty( "planarfigure.drawquantities", m_DrawQuantities );
   node->GetBoolProperty( "planarfigure.drawcontrolpoints", m_DrawControlPoints );
   node->GetBoolProperty( "planarfigure.drawname", m_DrawName );
 
   node->GetFloatProperty( "planarfigure.line.width", m_LineWidth );
   node->GetFloatProperty( "planarfigure.shadow.widthmodifier", m_ShadowWidthFactor );
   node->GetFloatProperty( "planarfigure.outline.width", m_OutlineWidth );
   node->GetFloatProperty( "planarfigure.helperline.width", m_HelperlineWidth );
 
   PlanarFigureControlPointStyleProperty::Pointer styleProperty = 
     dynamic_cast< PlanarFigureControlPointStyleProperty* >( node->GetProperty( "planarfigure.controlpointshape" ) );
   if ( styleProperty.IsNotNull() )
   {
     m_ControlPointShape = styleProperty->GetShape();
   }
 
-  node->GetColor( m_LineColor[PF_DEFAULT], NULL, "planarfigure.default.line.color" );
+  //Set default color and opacity
+  //If property "planarfigure.default.*.color" exists, then use that color. Otherwise global "color" property is used.
+  if( !node->GetColor( m_LineColor[PF_DEFAULT], NULL, "planarfigure.default.line.color"))
+  {
+    node->GetColor( m_LineColor[PF_DEFAULT], NULL, "color" );
+  }
   node->GetFloatProperty( "planarfigure.default.line.opacity", m_LineOpacity[PF_DEFAULT] );
-  node->GetColor( m_OutlineColor[PF_DEFAULT], NULL, "planarfigure.default.outline.color" );
+
+  if( !node->GetColor( m_OutlineColor[PF_DEFAULT], NULL, "planarfigure.default.outline.color"))
+  {
+    node->GetColor( m_OutlineColor[PF_DEFAULT], NULL, "color" );
+  }
   node->GetFloatProperty( "planarfigure.default.outline.opacity", m_OutlineOpacity[PF_DEFAULT] );
-  node->GetColor( m_HelperlineColor[PF_DEFAULT], NULL, "planarfigure.default.helperline.color" );
+
+  if( !node->GetColor( m_HelperlineColor[PF_DEFAULT], NULL, "planarfigure.default.helperline.color"))
+  {
+    node->GetColor( m_HelperlineColor[PF_DEFAULT], NULL, "color" );
+  }
   node->GetFloatProperty( "planarfigure.default.helperline.opacity", m_HelperlineOpacity[PF_DEFAULT] );
+
   node->GetColor( m_MarkerlineColor[PF_DEFAULT], NULL, "planarfigure.default.markerline.color" );
   node->GetFloatProperty( "planarfigure.default.markerline.opacity", m_MarkerlineOpacity[PF_DEFAULT] );
   node->GetColor( m_MarkerColor[PF_DEFAULT], NULL, "planarfigure.default.marker.color" );
   node->GetFloatProperty( "planarfigure.default.marker.opacity", m_MarkerOpacity[PF_DEFAULT] );
 
+  //Set hover color and opacity
   node->GetColor( m_LineColor[PF_HOVER], NULL, "planarfigure.hover.line.color" );
   node->GetFloatProperty( "planarfigure.hover.line.opacity", m_LineOpacity[PF_HOVER] );
   node->GetColor( m_OutlineColor[PF_HOVER], NULL, "planarfigure.hover.outline.color" );
   node->GetFloatProperty( "planarfigure.hover.outline.opacity", m_OutlineOpacity[PF_HOVER] );
   node->GetColor( m_HelperlineColor[PF_HOVER], NULL, "planarfigure.hover.helperline.color" );
   node->GetFloatProperty( "planarfigure.hover.helperline.opacity", m_HelperlineOpacity[PF_HOVER] );
   node->GetColor( m_MarkerlineColor[PF_HOVER], NULL, "planarfigure.hover.markerline.color" );
   node->GetFloatProperty( "planarfigure.hover.markerline.opacity", m_MarkerlineOpacity[PF_HOVER] );
   node->GetColor( m_MarkerColor[PF_HOVER], NULL, "planarfigure.hover.marker.color" );
   node->GetFloatProperty( "planarfigure.hover.marker.opacity", m_MarkerOpacity[PF_HOVER] );
 
+  //Set selected color and opacity
   node->GetColor( m_LineColor[PF_SELECTED], NULL, "planarfigure.selected.line.color" );
   node->GetFloatProperty( "planarfigure.selected.line.opacity", m_LineOpacity[PF_SELECTED] );
   node->GetColor( m_OutlineColor[PF_SELECTED], NULL, "planarfigure.selected.outline.color" );
   node->GetFloatProperty( "planarfigure.selected.outline.opacity", m_OutlineOpacity[PF_SELECTED] );
   node->GetColor( m_HelperlineColor[PF_SELECTED], NULL, "planarfigure.selected.helperline.color" );
   node->GetFloatProperty( "planarfigure.selected.helperline.opacity", m_HelperlineOpacity[PF_SELECTED] );
   node->GetColor( m_MarkerlineColor[PF_SELECTED], NULL, "planarfigure.selected.markerline.color" );
   node->GetFloatProperty( "planarfigure.selected.markerline.opacity", m_MarkerlineOpacity[PF_SELECTED] );
   node->GetColor( m_MarkerColor[PF_SELECTED], NULL, "planarfigure.selected.marker.color" );
   node->GetFloatProperty( "planarfigure.selected.marker.opacity", m_MarkerOpacity[PF_SELECTED] );
 
+  //adapt opacity values to global "opacity" property
+  for( unsigned int i = 0; i < PF_COUNT; ++i )
+  {
+    m_LineOpacity[i] *= globalOpacity;
+    m_OutlineOpacity[i] *= globalOpacity;
+    m_HelperlineOpacity[i] *= globalOpacity;
+    m_MarkerlineOpacity[i] *= globalOpacity;
+    m_MarkerOpacity[i] *= globalOpacity;
+  }
 }
 
 
 void mitk::PlanarFigureMapper2D::SetDefaultProperties( mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite )
 {
   node->AddProperty( "visible", mitk::BoolProperty::New(true), renderer, overwrite );
 
   //node->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
   //node->SetProperty("planarfigure.isextendable",mitk::BoolProperty::New(true));
   //node->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawoutline", mitk::BoolProperty::New(true) );
   //node->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawcontrolpoints", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawname", mitk::BoolProperty::New(true) );
 
   node->AddProperty("planarfigure.line.width", mitk::FloatProperty::New(2.0) );
   node->AddProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0) );
   node->AddProperty("planarfigure.outline.width", mitk::FloatProperty::New(2.0) );
   node->AddProperty("planarfigure.helperline.width", mitk::FloatProperty::New(2.0) );
 
-  node->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.line.opacity", mitk::FloatProperty::New(1.0) );
-  node->AddProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.outline.opacity", mitk::FloatProperty::New(1.0) );
-  node->AddProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.helperline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.markerline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.marker.opacity",mitk::FloatProperty::New(1.0) );
 
   node->AddProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.line.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.outline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.marker.opacity", mitk::FloatProperty::New(1.0) );
 
   node->AddProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.line.opacity",mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.outline.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.helperline.opacity",mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.marker.opacity",mitk::FloatProperty::New(1.0));
 }
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
index 3d91db673c..9cfc0274ec 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
@@ -1,242 +1,244 @@
 /*===================================================================
 
 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 MITK_PLANAR_FIGURE_MAPPER_2D_H_
 #define MITK_PLANAR_FIGURE_MAPPER_2D_H_
 
 #include "mitkCommon.h"
 #include "PlanarFigureExports.h"
 #include "mitkGLMapper2D.h"
 #include "mitkPlanarFigure.h"
 #include "mitkPlanarFigureControlPointStyleProperty.h"
 
 namespace mitk {
 
 class BaseRenderer;
 class Contour;
 
 
 /**
 * \brief OpenGL-based mapper to render display sub-class instances of mitk::PlanarFigure
 * 
 * The appearance of planar figures can be configured through  properties. If no properties are specified,
 * default values will be used. There are four elements a planar figure consists of:
 * 
 * <ol>
 * <li>"line": the main line segments of the planar figure (note: text is drawn in the same style)
 * <li>"helperline": additional line segments of planar figures, such as arrow tips, arches of angles, etc.
 * <li>"outline": background which is drawn behind the lines and helperlines of the planar figure (optional)
 * <li>"marker": the markers (control points) of a planar figure
 * <li>"markerline": the lines by which markers (control points) are surrounded
 * </ol>
 * 
 * In the following, all appearance-related planar figure properties are listed:
 * 
 * <ol>
 * <li>General properties for the planar figure
 *   <ul>
 *     <li>"planarfigure.drawoutline": if true, the "outline" lines is drawn
 *     <li>"planarfigure.drawquantities": if true, the quantities (text) associated with the planar figure is drawn
 *     <li>"planarfigure.drawname": if true, the name specified by the dataNode is drawn
 *     <li>"planarfigure.drawshadow": if true, a black shadow is drawn around the planar figure
 *     <li>"planarfigure.controlpointshape": style of the control points (enum)
 *   </ul>
 * <li>Line widths of planar figure elements
 *   <ul>
 *     <li>"planarfigure.line.width": width of "line" segments (float value, in mm)
 *     <li>"planarfigure.shadow.widthmodifier": the width of the shadow is defined by width of the "line" * this modifier
 *     <li>"planarfigure.outline.width": width of "outline" segments (float value, in mm)
 *     <li>"planarfigure.helperline.width": width of "helperline" segments (float value, in mm)
 *   </ul>
 * <li>Color/opacity of planar figure elements in normal mode (unselected)
 *   <ul>
 *     <li>"planarfigure.default.line.color"
 *     <li>"planarfigure.default.line.opacity"
 *     <li>"planarfigure.default.outline.color"
 *     <li>"planarfigure.default.outline.opacity"
 *     <li>"planarfigure.default.helperline.color"
 *     <li>"planarfigure.default.helperline.opacity"
 *     <li>"planarfigure.default.markerline.color"
 *     <li>"planarfigure.default.markerline.opacity"
 *     <li>"planarfigure.default.marker.color"
 *     <li>"planarfigure.default.marker.opacity"
 *   </ul>
 * <li>Color/opacity of planar figure elements in hover mode (mouse-over)
 *   <ul>
 *     <li>"planarfigure.hover.line.color"
 *     <li>"planarfigure.hover.line.opacity"
 *     <li>"planarfigure.hover.outline.color"
 *     <li>"planarfigure.hover.outline.opacity"
 *     <li>"planarfigure.hover.helperline.color"
 *     <li>"planarfigure.hover.helperline.opacity"
 *     <li>"planarfigure.hover.markerline.color"
 *     <li>"planarfigure.hover.markerline.opacity"
 *     <li>"planarfigure.hover.marker.color"
 *     <li>"planarfigure.hover.marker.opacity"
 *   </ul>
 * <li>Color/opacity of planar figure elements in selected mode
 *   <ul>
 *     <li>"planarfigure.selected.line.color"
 *     <li>"planarfigure.selected.line.opacity"
 *     <li>"planarfigure.selected.outline.color"
 *     <li>"planarfigure.selected.outline.opacity"
 *     <li>"planarfigure.selected.helperline.color"
 *     <li>"planarfigure.selected.helperline.opacity"
 *     <li>"planarfigure.selected.markerline.color;"
 *     <li>"planarfigure.selected.markerline.opacity"
 *     <li>"planarfigure.selected.marker.color"
 *     <li>"planarfigure.selected.marker.opacity"
 *   </ul>
 * </ol>
 *
 * \ingroup Mapper
 */
 
 class PlanarFigure_EXPORT PlanarFigureMapper2D : public GLMapper2D
 {
 public:
     
   mitkClassMacro(PlanarFigureMapper2D, Mapper2D);
 
   itkNewMacro(Self);
 
   /**
   * reimplemented from Baseclass
   */
   virtual void Paint(BaseRenderer * renderer);
 
   static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
 
 
 protected:
   
   enum PlanarFigureDisplayMode
   {
     PF_DEFAULT = 0,
-    PF_HOVER,
-    PF_SELECTED
+    PF_HOVER = 1,
+    PF_SELECTED = 2,
+
+    PF_COUNT = 3 //helper variable
   };
 
   PlanarFigureMapper2D();
 
   virtual ~PlanarFigureMapper2D();
 
   void TransformObjectToDisplay(
     const mitk::Point2D &point2D,
     mitk::Point2D &displayPoint,
     const mitk::Geometry2D *objectGeometry,
     const mitk::Geometry2D *rendererGeometry,
     const mitk::DisplayGeometry *displayGeometry );
 
   void DrawMarker(
     const mitk::Point2D &point,
     float* lineColor,
     float lineOpacity,
     float* markerColor,
     float markerOpacity,
     float lineWidth,
     PlanarFigureControlPointStyleProperty::Shape shape,
     const mitk::Geometry2D *objectGeometry,
     const mitk::Geometry2D *rendererGeometry,
     const mitk::DisplayGeometry *displayGeometry );
 
   void PaintPolyLine( mitk::PlanarFigure::PolyLineType vertices,
     bool closed,
     float* color, 
     float opacity, 
     float lineWidth, 
     Point2D& firstPoint,
     const Geometry2D* planarFigureGeometry2D, 
     const Geometry2D* rendererGeometry2D, 
     const DisplayGeometry* displayGeometry);
 
   void DrawMainLines( mitk::PlanarFigure* figure, 
     float* color, 
     float opacity, 
     bool drawShadow,
     float lineWidth, 
     float shadowWidthFactor,
     Point2D& firstPoint,
     const Geometry2D* planarFigureGeometry2D, 
     const Geometry2D* rendererGeometry2D, 
     const DisplayGeometry* displayGeometry) ;
 
   void DrawHelperLines( mitk::PlanarFigure* figure,
     float* color, 
     float opacity, 
     bool drawShadow,
     float lineWidth, 
     float shadowWidthFactor,
     Point2D& firstPoint,
     const Geometry2D* planarFigureGeometry2D, 
     const Geometry2D* rendererGeometry2D, 
     const DisplayGeometry* displayGeometry) ;
 
   void InitializeDefaultPlanarFigureProperties();
 
   void InitializePlanarFigurePropertiesFromDataNode( const mitk::DataNode* node );
 
   void SetColorProperty( float property[3][3], PlanarFigureDisplayMode mode, float red, float green, float blue )
   {
     property[mode][0] = red;
     property[mode][1] = green;
     property[mode][2] = blue;
   }
 
   void SetFloatProperty( float* property, PlanarFigureDisplayMode mode, float value )
   {
     property[mode] = value;
   }
 
 
 
 private:
   bool m_IsSelected;
   bool m_IsHovering;
   bool m_DrawOutline;
   bool m_DrawQuantities;
   bool m_DrawShadow;
   bool m_DrawControlPoints;
   bool m_DrawName;
 
   // the width of the shadow is defined as 'm_LineWidth * m_ShadowWidthFactor'
   float m_LineWidth;
   float m_ShadowWidthFactor;
   float m_OutlineWidth;
   float m_HelperlineWidth;
   float m_PointWidth;
 
   PlanarFigureControlPointStyleProperty::Shape m_ControlPointShape;
 
   float m_LineColor[3][3];
   float m_LineOpacity[3];
   float m_OutlineColor[3][3];
   float m_OutlineOpacity[3];
   float m_HelperlineColor[3][3];
   float m_HelperlineOpacity[3];
   float m_MarkerlineColor[3][3];
   float m_MarkerlineOpacity[3];
   float m_MarkerColor[3][3];
   float m_MarkerOpacity[3];
 
 };
 
 } // namespace mitk
 
 
 
 #endif /* MITK_PLANAR_FIGURE_MAPPER_2D_H_ */
diff --git a/Modules/Qmitk/QmitkServiceListWidget.h b/Modules/Qmitk/QmitkServiceListWidget.h
index 8bba3dbe56..0c5e5d037b 100644
--- a/Modules/Qmitk/QmitkServiceListWidget.h
+++ b/Modules/Qmitk/QmitkServiceListWidget.h
@@ -1,239 +1,239 @@
 /*===================================================================
 
 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 _QmitkServiceListWidget_H_INCLUDED
 #define _QmitkServiceListWidget_H_INCLUDED
 
 #include "QmitkExports.h"
 #include "ui_QmitkServiceListWidgetControls.h"
 #include <vector>
 
 //QT headers
 #include <QWidget>
 #include <QListWidgetItem>
 
 //Microservices
 #include "usServiceReference.h"
 #include "usModuleContext.h"
 #include "usServiceEvent.h"
 #include "usServiceInterface.h"
 
 
 
 /**
 * @brief This widget provides abstraction for the handling of MicroServices . Place one in your Plugin and set it to look for a certain interface.
 * One can also specify a filter and / or a property to use for captioning of the services. It also offers functionality to signal
 * ServiceEvents and to return the actual classes, so only a minimum of interaction with the MicroserviceInterface is required.
 * To get started, just put it in your Plugin or Widget, call the Initialize Method and optionally connect it's signals.
 * As QT limits templating possibilities, events only throw ServiceReferences. You can manually dereference them using TranslateServiceReference()
 *
 * @ingroup QMITK
 */
 class QMITK_EXPORT QmitkServiceListWidget :public QWidget
 {
 
   //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   private:
 
     mitk::ModuleContext* m_Context;
     /** \brief a filter to further narrow down the list of results*/
     std::string m_Filter;
     /** \brief The name of the ServiceInterface that this class should list */
     std::string m_Interface;
     /** \brief The name of the ServiceProperty that will be displayed in the list to represent the service */
     std::string m_NamingProperty;
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkServiceListWidget(QWidget* p = 0, Qt::WindowFlags f1 = 0);
     virtual ~QmitkServiceListWidget();
 
     /** \brief This method is part of the widget an needs not to be called separately. */
     virtual void CreateQtPartControl(QWidget *parent);
     /** \brief This method is part of the widget an needs not to be called separately. (Creation of the connections of main and control widget.)*/
     virtual void CreateConnections();
 
     /**
     * \brief Will return true, if a service is currently selected and false otherwise.
     *
     * Call this before requesting service references to avoid invalid ServiceReferences.
     */
     bool GetIsServiceSelected();
 
     /**
     * \brief Returns the currently selected Service as a ServiceReference.
     *
     * If no Service is selected, the result will probably be a bad pointer. call GetIsServiceSelected()
     * beforehand to avoid this
     */
     mitk::ServiceReference GetSelectedServiceReference();
 
     /**
     * \brief Use this function to return the currently selected service as a class directly.
     *
     *  Make sure you pass the appropriate type, or else this call will fail.
     *  Usually, you will pass the class itself, not the SmartPointer, but the function returns a pointer. Example:
     *  \verbatim mitk::USDevice::Pointer device = GetSelectedService<mitk::USDevice>(); \endverbatim
     */
     template <class T>
     T* GetSelectedService()
     {
       mitk::ServiceReference ref = GetServiceForListItem( this->m_Controls->m_ServiceList->currentItem() );
       return ( m_Context->GetService<T>(ref) );
     }
 
     /**
     * \brief  Initializes the Widget with essential parameters.
     *
     * The string filter is an LDAP parsable String, compare mitk::ModuleContext for examples on filtering.
     * Pass class T to tell the widget which class it should filter for - only services of this class will be listed.
     * NamingProperty is a property that will be used to caption the Items in the list. If no filter is supplied, all
     * matching interfaces are shown. If no namingProperty is supplied, the interfaceName will be used to caption Items in the list.
     * For example, this Initialization will filter for all USDevices that are set to active. The USDevice's model will be used to display it in the list:
     * \verbatim
         std::string filter = "(&(" + mitk::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.UltrasoundDevice)(IsActive=true))";
         m_Controls.m_ActiveVideoDevices->Initialize<mitk::USDevice>(mitk::USImageMetadata::PROP_DEV_MODEL ,filter);
     * \endverbatim
     */
     template <class T>
-    void Initialize(const std::string& namingProperty = static_cast< std::string >(""), std::string& filter = static_cast< std::string >(""))
+    void Initialize(const std::string& namingProperty = static_cast< std::string >(""),const std::string& filter = static_cast< std::string >(""))
       {
         std::string interfaceName ( us_service_interface_iid<T*>() );
         m_Interface = interfaceName;
         InitPrivate(namingProperty, filter);
       }
 
     /**
     * \brief Translates a serviceReference to a class of the given type.
     *
     * Use this to translate the signal's parameters. To adhere to the MicroService contract,
     * only ServiceReferences stemming from the same widget should be used as parameters for this method.
     * \verbatim mitk::USDevice::Pointer device = TranslateReference<mitk::USDevice>(myDeviceReference); \endverbatim
     */
     template <class T>
     T* TranslateReference(mitk::ServiceReference reference)
       {
         return dynamic_cast<T*> ( m_Context->GetService<T>(reference) );
       }
 
     /**
     *\brief This Function listens to ServiceRegistry changes and updates the list of services accordingly.
     *
     * The user of this widget does not need to call this method, it is instead used to recieve events from the module registry.
     */
     void OnServiceEvent(const mitk::ServiceEvent event);
 
   signals:
 
     /**
     *\brief Emitted when a new Service matching the filter is being registered.
     *
     * Be careful if you use a filter:
     * If a device does not match the filter when registering, but modifies it's properties later to match the filter,
     * then the first signal you will see this device in will be ServiceModified.
     */
     void ServiceRegistered(mitk::ServiceReference);
 
     /**
     *\brief Emitted directly before a Service matching the filter is being unregistered.
     */
     void ServiceUnregistering(mitk::ServiceReference);
 
     /**
     *\brief Emitted when a Service matching the filter changes it's properties, or when a service that formerly not matched the filter
     * changed it's properties and now matches the filter.
     */
     void ServiceModified(mitk::ServiceReference);
 
     /**
     *\brief Emitted when a Service matching the filter changes it's properties,
     *
     * and the new properties make it fall trough the filter. This effectively means that
     * the widget will not track the service anymore. Usually, the Service should still be useable though
     */
     void ServiceModifiedEndMatch(mitk::ServiceReference);
 
     /**
     *\brief Emitted if the user selects a Service from the list.
     *
     * If no service is selected, an invalid serviceReference is returned. The user can easily check for this.
     * if (serviceReference) will evaluate to false, if the reference is invalid and true if valid.
     */
     void ServiceSelectionChanged(mitk::ServiceReference);
 
   public slots:
 
   protected slots:
 
     /**
     \brief Called, when the selection in the list of Services changes.
     */
     void OnServiceSelectionChanged();
 
 
   protected:
 
     Ui::QmitkServiceListWidgetControls* m_Controls; ///< member holding the UI elements of this widget
 
     /**
     * \brief  Internal structure used to link ServiceReferences to their QListWidgetItems
     */
     struct ServiceListLink {
       mitk::ServiceReference service;
       QListWidgetItem* item;
     };
 
     /**
     * \brief Finishes initialization after Initialize has been called.
     *
     * This function assumes that m_Interface is set correctly (Which Initialize does).
     */
     void InitPrivate(const std::string& namingProperty, const std::string& filter);
 
     /**
     * \brief Contains a list of currently active services and their entires in the list. This is wiped with every ServiceRegistryEvent.
     */
     std::vector<ServiceListLink> m_ListContent;
 
     /**
     * \brief Constructs a ListItem from the given service, displays it, and locally stores the service.
     */
     QListWidgetItem* AddServiceToList(mitk::ServiceReference serviceRef);
 
     /**
     * \brief Removes the given service from the list and cleans up. Returns true if successful, false if service was not found.
     */
     bool RemoveServiceFromList(mitk::ServiceReference serviceRef);
 
     /**
     * \brief Returns the serviceReference corresponding to the given ListEntry or an invalid one if none was found (will evaluate to false in bool expressions).
     */
     mitk::ServiceReference GetServiceForListItem(QListWidgetItem* item);
 
     /**
     * \brief Returns a list of ServiceReferences matching the filter criteria by querying the service registry.
     */
     std::list<mitk::ServiceReference> GetAllRegisteredServices();
 
 
 
 };
 
 #endif // _QmitkServiceListWidget_H_INCLUDED
diff --git a/Modules/Qmitk/QmitkStdMultiWidget.cpp b/Modules/Qmitk/QmitkStdMultiWidget.cpp
index 92b48792e6..447d43a513 100644
--- a/Modules/Qmitk/QmitkStdMultiWidget.cpp
+++ b/Modules/Qmitk/QmitkStdMultiWidget.cpp
@@ -1,2216 +1,2218 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #define SMW_INFO MITK_INFO("widget.stdmulti")
 
 #include "QmitkStdMultiWidget.h"
 
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QGridLayout>
 #include <qsplitter.h>
 #include <QMotifStyle>
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 
 #include "mitkProperties.h"
 #include "mitkGeometry2DDataMapper2D.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkDisplayInteractor.h"
 #include "mitkPointSet.h"
 #include "mitkPositionEvent.h"
 #include "mitkStateEvent.h"
 #include "mitkLine.h"
 #include "mitkInteractionConst.h"
 #include "mitkDataStorage.h"
 
 #include "mitkNodePredicateBase.h"
 #include "mitkNodePredicateDataType.h"
 
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkStatusBar.h"
 #include "mitkImage.h"
 
 #include "mitkVtkLayerController.h"
 
 QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget* parent, Qt::WindowFlags f, mitk::RenderingManager* renderingManager)
 : QWidget(parent, f), 
 mitkWidget1(NULL),
 mitkWidget2(NULL),
 mitkWidget3(NULL),
 mitkWidget4(NULL),
 levelWindowWidget(NULL),
 QmitkStdMultiWidgetLayout(NULL),
 m_Layout(LAYOUT_DEFAULT),
 m_PlaneMode(PLANE_MODE_SLICING),
 m_RenderingManager(renderingManager),
 m_GradientBackgroundFlag(true),
 m_TimeNavigationController(NULL),
 m_MainSplit(NULL),
 m_LayoutSplit(NULL),
 m_SubSplit1(NULL),
 m_SubSplit2(NULL),
 mitkWidget1Container(NULL),
 mitkWidget2Container(NULL),
 mitkWidget3Container(NULL),
 mitkWidget4Container(NULL),
 m_PendingCrosshairPositionEvent(false),
 m_CrosshairNavigationEnabled(false)
 {
   /******************************************************
    * Use the global RenderingManager if none was specified
    * ****************************************************/
   if (m_RenderingManager == NULL)
   {
     m_RenderingManager = mitk::RenderingManager::GetInstance();
   }
   m_TimeNavigationController = m_RenderingManager->GetTimeNavigationController();
 
   /*******************************/
   //Create Widget manually
   /*******************************/
 
   //create Layouts
   QmitkStdMultiWidgetLayout = new QHBoxLayout( this ); 
   QmitkStdMultiWidgetLayout->setContentsMargins(0,0,0,0);
 
   //Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
 //  QmitkNavigationToolBar* toolBar = new QmitkNavigationToolBar();
 //  QmitkStdMultiWidgetLayout->addWidget( toolBar );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //creae Widget Container
   mitkWidget1Container = new QWidget(m_SubSplit1);
   mitkWidget2Container = new QWidget(m_SubSplit1);
   mitkWidget3Container = new QWidget(m_SubSplit2);
   mitkWidget4Container = new QWidget(m_SubSplit2);
 
   mitkWidget1Container->setContentsMargins(0,0,0,0);
   mitkWidget2Container->setContentsMargins(0,0,0,0);
   mitkWidget3Container->setContentsMargins(0,0,0,0);
   mitkWidget4Container->setContentsMargins(0,0,0,0);
 
   //create Widget Layout
   QHBoxLayout *mitkWidgetLayout1 = new QHBoxLayout(mitkWidget1Container);
   QHBoxLayout *mitkWidgetLayout2 = new QHBoxLayout(mitkWidget2Container);
   QHBoxLayout *mitkWidgetLayout3 = new QHBoxLayout(mitkWidget3Container);
   QHBoxLayout *mitkWidgetLayout4 = new QHBoxLayout(mitkWidget4Container);
 
   mitkWidgetLayout1->setMargin(0);
   mitkWidgetLayout2->setMargin(0);
   mitkWidgetLayout3->setMargin(0);
   mitkWidgetLayout4->setMargin(0);
 
   //set Layout to Widget Container  
   mitkWidget1Container->setLayout(mitkWidgetLayout1); 
   mitkWidget2Container->setLayout(mitkWidgetLayout2); 
   mitkWidget3Container->setLayout(mitkWidgetLayout3); 
   mitkWidget4Container->setLayout(mitkWidgetLayout4); 
 
   //set SizePolicy
   mitkWidget1Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
   mitkWidget2Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
   mitkWidget3Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
   mitkWidget4Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
 
 
   //insert Widget Container into the splitters
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
 
   m_SubSplit2->addWidget( mitkWidget3Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //  m_RenderingManager->SetGlobalInteraction( mitk::GlobalInteraction::GetInstance() );
 
   //Create RenderWindows 1
   mitkWidget1 = new QmitkRenderWindow(mitkWidget1Container, "stdmulti.widget1", NULL, m_RenderingManager);
   mitkWidget1->setMaximumSize(2000,2000);
   mitkWidget1->SetLayoutIndex( AXIAL );
   mitkWidgetLayout1->addWidget(mitkWidget1); 
 
   //Create RenderWindows 2
   mitkWidget2 = new QmitkRenderWindow(mitkWidget2Container, "stdmulti.widget2", NULL, m_RenderingManager);
   mitkWidget2->setMaximumSize(2000,2000);
   mitkWidget2->setEnabled( TRUE );
   mitkWidget2->SetLayoutIndex( SAGITTAL );
   mitkWidgetLayout2->addWidget(mitkWidget2); 
 
   //Create RenderWindows 3
   mitkWidget3 = new QmitkRenderWindow(mitkWidget3Container, "stdmulti.widget3", NULL, m_RenderingManager);
   mitkWidget3->setMaximumSize(2000,2000);
   mitkWidget3->SetLayoutIndex( CORONAL );
   mitkWidgetLayout3->addWidget(mitkWidget3); 
 
   //Create RenderWindows 4
   mitkWidget4 = new QmitkRenderWindow(mitkWidget4Container, "stdmulti.widget4", NULL, m_RenderingManager);
   mitkWidget4->setMaximumSize(2000,2000);
   mitkWidget4->SetLayoutIndex( THREE_D );
   mitkWidgetLayout4->addWidget(mitkWidget4); 
 
   //create SignalSlot Connection
   connect( mitkWidget1, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget1, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget1, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget1, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   connect( mitkWidget2, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget2, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget2, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget2, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   connect( mitkWidget3, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget3, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget3, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget3, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   connect( mitkWidget4, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget4, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget4, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget4, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   //Create Level Window Widget
   levelWindowWidget = new QmitkLevelWindowWidget( m_MainSplit ); //this
   levelWindowWidget->setObjectName(QString::fromUtf8("levelWindowWidget"));
   QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
   sizePolicy.setHorizontalStretch(0);
   sizePolicy.setVerticalStretch(0);
   sizePolicy.setHeightForWidth(levelWindowWidget->sizePolicy().hasHeightForWidth());
   levelWindowWidget->setSizePolicy(sizePolicy);
   levelWindowWidget->setMaximumSize(QSize(50, 2000));
   
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //resize Image.
   this->resize( QSize(364, 477).expandedTo(minimumSizeHint()) );
 
   //Initialize the widgets.
   this->InitializeWidget();
 
   //Activate Widget Menu
   this->ActivateMenuWidget( true );
 }
 
 void QmitkStdMultiWidget::InitializeWidget()
 {
   m_PositionTracker = NULL;
 
   // transfer colors in WorldGeometry-Nodes of the associated Renderer
   QColor qcolor;
   //float color[3] = {1.0f,1.0f,1.0f};
   mitk::DataNode::Pointer planeNode;
   mitk::IntProperty::Pointer  layer;
 
   // of widget 1
   planeNode = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
   planeNode->SetColor(1.0,0.0,0.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   // ... of widget 2
   planeNode = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
   planeNode->SetColor(0.0,1.0,0.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   // ... of widget 3
   planeNode = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
   planeNode->SetColor(0.0,0.0,1.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   // ... of widget 4
   planeNode = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
   planeNode->SetColor(1.0,1.0,0.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
   // Set plane mode (slicing/rotation behavior) to slicing (default)
   m_PlaneMode = PLANE_MODE_SLICING;
 
   // Set default view directions for SNCs
   mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Axial );
   mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Sagittal );
   mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Frontal );
   mitkWidget4->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Original );
 
   /*************************************************/
   //Write Layout Names into the viewers -- hardCoded
 
   //Info for later: 
   //int view = this->GetRenderWindow1()->GetSliceNavigationController()->GetDefaultViewDirection();
   //QString layoutName;
   //if( view == mitk::SliceNavigationController::Axial )
   //  layoutName = "Axial";
   //else if( view == mitk::SliceNavigationController::Sagittal )
   //  layoutName = "Sagittal";
   //else if( view == mitk::SliceNavigationController::Frontal )
   //  layoutName = "Coronal";
   //else if( view == mitk::SliceNavigationController::Original )
   //  layoutName = "Original";
   //if( view >= 0 && view < 4 )
   //  //write LayoutName --> Viewer 3D shoudn't write the layoutName.
 
   //Render Window 1 == axial
   m_CornerAnnotaions[0].cornerText = vtkCornerAnnotation::New();
   m_CornerAnnotaions[0].cornerText->SetText(0, "Axial");
   m_CornerAnnotaions[0].cornerText->SetMaximumFontSize(12);
   m_CornerAnnotaions[0].textProp = vtkTextProperty::New();
   m_CornerAnnotaions[0].textProp->SetColor( 1.0, 0.0, 0.0 );
   m_CornerAnnotaions[0].cornerText->SetTextProperty( m_CornerAnnotaions[0].textProp );
   m_CornerAnnotaions[0].ren = vtkRenderer::New();
   m_CornerAnnotaions[0].ren->AddActor(m_CornerAnnotaions[0].cornerText);
   m_CornerAnnotaions[0].ren->InteractiveOff();
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow1()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[0].ren,true);
   
   //Render Window 2 == sagittal
   m_CornerAnnotaions[1].cornerText = vtkCornerAnnotation::New();
   m_CornerAnnotaions[1].cornerText->SetText(0, "Sagittal");
   m_CornerAnnotaions[1].cornerText->SetMaximumFontSize(12);
   m_CornerAnnotaions[1].textProp = vtkTextProperty::New();
   m_CornerAnnotaions[1].textProp->SetColor( 0.0, 1.0, 0.0 );
   m_CornerAnnotaions[1].cornerText->SetTextProperty( m_CornerAnnotaions[1].textProp );
   m_CornerAnnotaions[1].ren = vtkRenderer::New();
   m_CornerAnnotaions[1].ren->AddActor(m_CornerAnnotaions[1].cornerText);
   m_CornerAnnotaions[1].ren->InteractiveOff();
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow2()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[1].ren,true);
   
   //Render Window 3 == coronal
   m_CornerAnnotaions[2].cornerText = vtkCornerAnnotation::New();
   m_CornerAnnotaions[2].cornerText->SetText(0, "Coronal");
   m_CornerAnnotaions[2].cornerText->SetMaximumFontSize(12);
   m_CornerAnnotaions[2].textProp = vtkTextProperty::New();
   m_CornerAnnotaions[2].textProp->SetColor( 0.295, 0.295, 1.0 );
   m_CornerAnnotaions[2].cornerText->SetTextProperty( m_CornerAnnotaions[2].textProp );
   m_CornerAnnotaions[2].ren = vtkRenderer::New();
   m_CornerAnnotaions[2].ren->AddActor(m_CornerAnnotaions[2].cornerText);
   m_CornerAnnotaions[2].ren->InteractiveOff();
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow3()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[2].ren,true);
    
   /*************************************************/
 
 
   // create a slice rotator
   // m_SlicesRotator = mitk::SlicesRotator::New();
   // @TODO next line causes sure memory leak
   // rotator will be created nonetheless (will be switched on and off)
   m_SlicesRotator = mitk::SlicesRotator::New("slices-rotator");
   m_SlicesRotator->AddSliceController(
     mitkWidget1->GetSliceNavigationController() );
   m_SlicesRotator->AddSliceController(
     mitkWidget2->GetSliceNavigationController() );
   m_SlicesRotator->AddSliceController(
     mitkWidget3->GetSliceNavigationController() );
 
   // create a slice swiveller (using the same state-machine as SlicesRotator)
   m_SlicesSwiveller = mitk::SlicesSwiveller::New("slices-rotator");
   m_SlicesSwiveller->AddSliceController(
     mitkWidget1->GetSliceNavigationController() );
   m_SlicesSwiveller->AddSliceController(
     mitkWidget2->GetSliceNavigationController() );
   m_SlicesSwiveller->AddSliceController(
     mitkWidget3->GetSliceNavigationController() );
 
   //connect to the "time navigation controller": send time via sliceNavigationControllers
   m_TimeNavigationController->ConnectGeometryTimeEvent(
     mitkWidget1->GetSliceNavigationController() , false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(
     mitkWidget2->GetSliceNavigationController() , false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(
     mitkWidget3->GetSliceNavigationController() , false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(
     mitkWidget4->GetSliceNavigationController() , false);
   mitkWidget1->GetSliceNavigationController()
     ->ConnectGeometrySendEvent(mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
 
   //reverse connection between sliceNavigationControllers and m_TimeNavigationController
   mitkWidget1->GetSliceNavigationController()
     ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget2->GetSliceNavigationController()
     ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget3->GetSliceNavigationController()
     ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget4->GetSliceNavigationController()
     ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
 
   m_MouseModeSwitcher = mitk::MouseModeSwitcher::New( mitk::GlobalInteraction::GetInstance() );
 
   m_LastLeftClickPositionSupplier =
     mitk::CoordinateSupplier::New("navigation", NULL);
   mitk::GlobalInteraction::GetInstance()->AddListener(
     m_LastLeftClickPositionSupplier
     );
   // setup gradient background
   m_GradientBackground1 = mitk::GradientBackground::New();
   m_GradientBackground1->SetRenderWindow(
     mitkWidget1->GetRenderWindow() );
   m_GradientBackground1->Disable();
 
   m_GradientBackground2 = mitk::GradientBackground::New();
   m_GradientBackground2->SetRenderWindow(
     mitkWidget2->GetRenderWindow() );
   m_GradientBackground2->Disable();
 
   m_GradientBackground3 = mitk::GradientBackground::New();
   m_GradientBackground3->SetRenderWindow(
     mitkWidget3->GetRenderWindow() );
   m_GradientBackground3->Disable();
 
   m_GradientBackground4 = mitk::GradientBackground::New();
   m_GradientBackground4->SetRenderWindow(
     mitkWidget4->GetRenderWindow() );
   m_GradientBackground4->SetGradientColors(0.1,0.1,0.1,0.5,0.5,0.5);
   m_GradientBackground4->Enable();
 
   // setup the department logo rendering
   m_LogoRendering1 = mitk::ManufacturerLogo::New();
   m_LogoRendering1->SetRenderWindow(
     mitkWidget1->GetRenderWindow() );
   m_LogoRendering1->Disable();
 
   m_LogoRendering2 = mitk::ManufacturerLogo::New();
   m_LogoRendering2->SetRenderWindow(
     mitkWidget2->GetRenderWindow() );
   m_LogoRendering2->Disable();
 
   m_LogoRendering3 = mitk::ManufacturerLogo::New();
   m_LogoRendering3->SetRenderWindow(
     mitkWidget3->GetRenderWindow() );
   m_LogoRendering3->Disable();
 
   m_LogoRendering4 = mitk::ManufacturerLogo::New();
   m_LogoRendering4->SetRenderWindow(
     mitkWidget4->GetRenderWindow() );
   m_LogoRendering4->Enable();
 
   m_RectangleRendering1 = mitk::RenderWindowFrame::New();
   m_RectangleRendering1->SetRenderWindow(
     mitkWidget1->GetRenderWindow() );
   m_RectangleRendering1->Enable(1.0,0.0,0.0);
 
   m_RectangleRendering2 = mitk::RenderWindowFrame::New();
   m_RectangleRendering2->SetRenderWindow(
     mitkWidget2->GetRenderWindow() );
   m_RectangleRendering2->Enable(0.0,1.0,0.0);
 
   m_RectangleRendering3 = mitk::RenderWindowFrame::New();
   m_RectangleRendering3->SetRenderWindow(
     mitkWidget3->GetRenderWindow() );
   m_RectangleRendering3->Enable(0.0,0.0,1.0);
 
   m_RectangleRendering4 = mitk::RenderWindowFrame::New();
   m_RectangleRendering4->SetRenderWindow(
     mitkWidget4->GetRenderWindow() );
   m_RectangleRendering4->Enable(1.0,1.0,0.0);
 }
   
 QmitkStdMultiWidget::~QmitkStdMultiWidget()
 {
   DisablePositionTracking();
   DisableNavigationControllerEventListening();
 
   m_TimeNavigationController->Disconnect(mitkWidget1->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget2->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget3->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget4->GetSliceNavigationController());
 
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow1()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[0].ren );
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow2()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[1].ren );
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow3()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[2].ren );
 
   //Delete CornerAnnotation
   m_CornerAnnotaions[0].cornerText->Delete();
   m_CornerAnnotaions[0].textProp->Delete();
   m_CornerAnnotaions[0].ren->Delete();
 
   m_CornerAnnotaions[1].cornerText->Delete();
   m_CornerAnnotaions[1].textProp->Delete();
   m_CornerAnnotaions[1].ren->Delete();
 
   m_CornerAnnotaions[2].cornerText->Delete();
   m_CornerAnnotaions[2].textProp->Delete();
   m_CornerAnnotaions[2].ren->Delete();
 }
 
 void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
 {
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
   {
     if(m_DataStorage.IsNotNull())
     {
       m_DataStorage->Remove(m_PlaneNode1);
       m_DataStorage->Remove(m_PlaneNode2);
       m_DataStorage->Remove(m_PlaneNode3);
       m_DataStorage->Remove(m_Node);
     }
   }
 }
 
 void QmitkStdMultiWidget::AddPlanesToDataStorage()
 {
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
   {
     if (m_DataStorage.IsNotNull())
     {
       m_DataStorage->Add(m_Node);
       m_DataStorage->Add(m_PlaneNode1, m_Node);
       m_DataStorage->Add(m_PlaneNode2, m_Node);
       m_DataStorage->Add(m_PlaneNode3, m_Node);
       static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode1->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
       static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode2->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
       static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode3->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
     }
   }
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DImagesUp()
 {
   SMW_INFO << "changing layout to 2D images up... " << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget Container into splitter top
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
   m_SubSplit1->addWidget( mitkWidget3Container );
 
   //set SplitterSize for splitter top
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
 
   //insert Widget Container into splitter bottom
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set SplitterSize for splitter m_LayoutSplit
   splitterSize.clear();
   splitterSize.push_back(400);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt
   m_MainSplit->show();
 
   //show Widget if hidden
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   //Change Layout Name
   m_Layout = LAYOUT_2D_IMAGES_UP;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DImagesLeft()
 {
   SMW_INFO << "changing layout to 2D images left... " << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget into the splitters
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
   m_SubSplit1->addWidget( mitkWidget3Container );
 
   //set splitterSize of SubSplit1
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
 
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set splitterSize of Layout Split
   splitterSize.clear();
   splitterSize.push_back(400);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show Widget if hidden
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   //update Layout Name
   m_Layout = LAYOUT_2D_IMAGES_LEFT;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToDefault()
 {
   SMW_INFO << "changing layout to default... " << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget container into the splitters
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
 
   m_SubSplit2->addWidget( mitkWidget3Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
   m_SubSplit2->setSizes( splitterSize );
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show Widget if hidden
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_DEFAULT;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_DEFAULT );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_DEFAULT );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_DEFAULT );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_DEFAULT );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToBig3D()
 {
   SMW_INFO << "changing layout to big 3D ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget4Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_BIG_3D;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_BIG_3D );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_BIG_3D );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_BIG_3D );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_BIG_3D );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget1()
 {
   SMW_INFO << "changing layout to big Widget1 ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget1Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   mitkWidget2->hide();
   mitkWidget3->hide();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET1;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET1 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET1 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET1 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET1 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget2()
 {
   SMW_INFO << "changing layout to big Widget2 ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget2Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   mitkWidget3->hide();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET2;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET2 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET2 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET2 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET2 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget3()
 {
   SMW_INFO << "changing layout to big Widget3 ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget3Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET3;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET3 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET3 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET3 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET3 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToRowWidget3And4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //add Widgets to splitter
   m_LayoutSplit->addWidget( mitkWidget3Container );
   m_LayoutSplit->addWidget( mitkWidget4Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_ROW_WIDGET_3_AND_4;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToColumnWidget3And4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in one Column..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //add Widgets to splitter
   m_LayoutSplit->addWidget( mitkWidget3Container );
   m_LayoutSplit->addWidget( mitkWidget4Container );
 
   //set SplitterSize
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_COLUMN_WIDGET_3_AND_4;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToRowWidgetSmall3andBig4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   this->changeLayoutToRowWidget3And4();
 
   m_Layout = LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4;
 }
 
 
 void QmitkStdMultiWidget::changeLayoutToSmallUpperWidget2Big3and4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget into the splitters
   m_SubSplit1->addWidget( mitkWidget2Container );
 
   m_SubSplit2->addWidget( mitkWidget3Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit2->setSizes( splitterSize );
   splitterSize.clear();
   splitterSize.push_back(500);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt
   m_MainSplit->show();
 
   //show Widget if hidden
   mitkWidget1->hide();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 
 void QmitkStdMultiWidget::changeLayoutTo2x2Dand3DWidget()
 {
   SMW_INFO << "changing layout to 2 x 2D and 3D Widget" << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //add Widgets to splitter
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_2X_2D_AND_3D_WIDGET;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 
 void QmitkStdMultiWidget::changeLayoutToLeft2Dand3DRight2D()
 {
   SMW_INFO << "changing layout to 2D and 3D left, 2D right Widget" << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
 
   //add Widgets to splitter
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget4Container );
   m_SubSplit2->addWidget( mitkWidget2Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DUpAnd3DDown()
 {
   SMW_INFO << "changing layout to 2D up and 3D down" << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget Container into splitter top
   m_SubSplit1->addWidget( mitkWidget1Container );
 
   //set SplitterSize for splitter top
    QList<int> splitterSize;
 //   splitterSize.push_back(1000);
 //   splitterSize.push_back(1000);
 //   splitterSize.push_back(1000);
 //   m_SubSplit1->setSizes( splitterSize );
 
   //insert Widget Container into splitter bottom
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set SplitterSize for splitter m_LayoutSplit
   splitterSize.clear();
   splitterSize.push_back(700);
   splitterSize.push_back(700);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   mitkWidget2->hide();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_2D_UP_AND_3D_DOWN;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
 
   //update all Widgets
   this->UpdateAllWidgets();
 }
 
 
 
 void QmitkStdMultiWidget::SetDataStorage( mitk::DataStorage* ds )
 {
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetDataStorage(ds);
   m_DataStorage = ds;
 }
 
 
 void QmitkStdMultiWidget::Fit()
 {
   vtkRenderer * vtkrenderer;
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetDisplayGeometry()->Fit();
 
   int w = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL ) 
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL ) 
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL ) 
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL ) 
     vtkrenderer->ResetCamera();
 
   vtkObject::SetGlobalWarningDisplay(w);
 }
 
 
 void QmitkStdMultiWidget::InitPositionTracking()
 {
   //PoinSetNode for MouseOrientation
   m_PositionTrackerNode = mitk::DataNode::New();
   m_PositionTrackerNode->SetProperty("name", mitk::StringProperty::New("Mouse Position"));
   m_PositionTrackerNode->SetData( mitk::PointSet::New() );
   m_PositionTrackerNode->SetColor(1.0,0.33,0.0);
   m_PositionTrackerNode->SetProperty("layer", mitk::IntProperty::New(1001));
   m_PositionTrackerNode->SetVisibility(true);
   m_PositionTrackerNode->SetProperty("inputdevice", mitk::BoolProperty::New(true) );
   m_PositionTrackerNode->SetProperty("BaseRendererMapperID", mitk::IntProperty::New(0) );//point position 2D mouse
   m_PositionTrackerNode->SetProperty("baserenderer", mitk::StringProperty::New("N/A"));
 }
 
 
 void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
 {
   // add the displayed planes of the multiwidget to a node to which the subtree 
   // @a planesSubTree points ...
 
   float white[3] = {1.0f,1.0f,1.0f};
   mitk::Geometry2DDataMapper2D::Pointer mapper;
 
   // ... of widget 1
   m_PlaneNode1 = (mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
   m_PlaneNode1->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
   m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode1->SetProperty("name", mitk::StringProperty::New("widget1Plane"));
   m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::Geometry2DDataMapper2D::New();
   m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 2
   m_PlaneNode2 =( mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
   m_PlaneNode2->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
   m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode2->SetProperty("name", mitk::StringProperty::New("widget2Plane"));
   m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::Geometry2DDataMapper2D::New();
   m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 3
   m_PlaneNode3 = (mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
   m_PlaneNode3->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
   m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode3->SetProperty("name", mitk::StringProperty::New("widget3Plane"));
   m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::Geometry2DDataMapper2D::New();
   m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   m_Node = mitk::DataNode::New();
   m_Node->SetProperty("name", mitk::StringProperty::New("Widgets"));
   m_Node->SetProperty("helper object", mitk::BoolProperty::New(true));
 }
 
 
 mitk::SliceNavigationController* QmitkStdMultiWidget::GetTimeNavigationController()
 {
   return m_TimeNavigationController;
 }
 
 
 void QmitkStdMultiWidget::EnableStandardLevelWindow()
 {
   levelWindowWidget->disconnect(this);
   levelWindowWidget->SetDataStorage(mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDataStorage());
   levelWindowWidget->show();
 }
 
 
 void QmitkStdMultiWidget::DisableStandardLevelWindow()
 {
   levelWindowWidget->disconnect(this);
   levelWindowWidget->hide();
 }
 
 
 // CAUTION: Legacy code for enabling Qt-signal-controlled view initialization.
 // Use RenderingManager::InitializeViews() instead.
 bool QmitkStdMultiWidget::InitializeStandardViews( const mitk::Geometry3D * geometry )
 {
   return m_RenderingManager->InitializeViews( geometry );
 }
 
 
 void QmitkStdMultiWidget::RequestUpdate()
 {
   m_RenderingManager->RequestUpdate(mitkWidget1->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget2->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget3->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget4->GetRenderWindow());
 }
 
 
 void QmitkStdMultiWidget::ForceImmediateUpdate()
 {
   m_RenderingManager->ForceImmediateUpdate(mitkWidget1->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget2->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget3->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget4->GetRenderWindow());
 }
 
 
 void QmitkStdMultiWidget::wheelEvent( QWheelEvent * e )
 {
   emit WheelMoved( e );
 }
 
 void QmitkStdMultiWidget::mousePressEvent(QMouseEvent * e)
 {
    if (e->button() == Qt::LeftButton) {
        mitk::Point3D pointValue = this->GetLastLeftClickPosition();
        emit LeftMouseClicked(pointValue); 
    }
 }
 
 void QmitkStdMultiWidget::moveEvent( QMoveEvent* e )
 {
   QWidget::moveEvent( e );
   
   // it is necessary to readjust the position of the overlays as the StdMultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 void QmitkStdMultiWidget::leaveEvent ( QEvent * /*e*/  )
 {
   //set cursor back to initial state
   m_SlicesRotator->ResetMouseCursor();
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow1() const
 {
   return mitkWidget1;
 }
 
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow2() const
 {
   return mitkWidget2;
 }
 
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow3() const
 {
   return mitkWidget3;
 }
 
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow4() const
 {
   return mitkWidget4;
 }
 
 
 const mitk::Point3D& QmitkStdMultiWidget::GetLastLeftClickPosition() const
 {
   return m_LastLeftClickPositionSupplier->GetCurrentPoint();
 }
 
 
 const mitk::Point3D QmitkStdMultiWidget::GetCrossPosition() const
 {
   const mitk::PlaneGeometry *plane1 =
     mitkWidget1->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane2 =
     mitkWidget2->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane3 =
     mitkWidget3->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ( (plane1 != NULL) && (plane2 != NULL)
     && (plane1->IntersectionLine( plane2, line )) )
   {
     mitk::Point3D point;
     if ( (plane3 != NULL)
       && (plane3->IntersectionPoint( line, point )) )
     {
       return point;
     }
   }
   return m_LastLeftClickPositionSupplier->GetCurrentPoint();
 }
 
 
 void QmitkStdMultiWidget::EnablePositionTracking()
 {
   if (!m_PositionTracker)
   {
     m_PositionTracker = mitk::PositionTracker::New("PositionTracker", NULL);
   }
   mitk::GlobalInteraction* globalInteraction = mitk::GlobalInteraction::GetInstance();
   if (globalInteraction)
   {
     if(m_DataStorage.IsNotNull())
       m_DataStorage->Add(m_PositionTrackerNode);
     globalInteraction->AddListener(m_PositionTracker);
   }
 }
 
 
 void QmitkStdMultiWidget::DisablePositionTracking()
 {
   mitk::GlobalInteraction* globalInteraction =
     mitk::GlobalInteraction::GetInstance();
 
   if(globalInteraction)
   {
     if (m_DataStorage.IsNotNull())
       m_DataStorage->Remove(m_PositionTrackerNode);
     globalInteraction->RemoveListener(m_PositionTracker);
   }
 }
 
 
 void QmitkStdMultiWidget::EnsureDisplayContainsPoint(
   mitk::DisplayGeometry* displayGeometry, const mitk::Point3D& p)
 {
   mitk::Point2D pointOnPlane;
   displayGeometry->Map( p, pointOnPlane );
 
   // point minus origin < width or height ==> outside ?
   mitk::Vector2D pointOnRenderWindow_MM;
   pointOnRenderWindow_MM = pointOnPlane.GetVectorFromOrigin()
     - displayGeometry->GetOriginInMM();
 
   mitk::Vector2D sizeOfDisplay( displayGeometry->GetSizeInMM() );
 
   if (   sizeOfDisplay[0] < pointOnRenderWindow_MM[0]
   ||                0 > pointOnRenderWindow_MM[0]
   || sizeOfDisplay[1] < pointOnRenderWindow_MM[1]
   ||                0 > pointOnRenderWindow_MM[1] )
   {
     // point is not visible -> move geometry
     mitk::Vector2D offset( (pointOnRenderWindow_MM - sizeOfDisplay / 2.0)
       / displayGeometry->GetScaleFactorMMPerDisplayUnit() );
 
     displayGeometry->MoveBy( offset );
   }
 }
 
 
 void QmitkStdMultiWidget::MoveCrossToPosition(const mitk::Point3D& newPosition)
 {
   // create a PositionEvent with the given position and
   // tell the slice navigation controllers to move there
 
   mitk::Point2D p2d;
   mitk::PositionEvent event( mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow()), 0, 0, 0,
     mitk::Key_unknown, p2d, newPosition );
   mitk::StateEvent stateEvent(mitk::EIDLEFTMOUSEBTN, &event);
   mitk::StateEvent stateEvent2(mitk::EIDLEFTMOUSERELEASE, &event);
 
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     mitkWidget1->GetSliceNavigationController()->HandleEvent( &stateEvent );
     mitkWidget2->GetSliceNavigationController()->HandleEvent( &stateEvent );
     mitkWidget3->GetSliceNavigationController()->HandleEvent( &stateEvent );
 
     // just in case SNCs will develop something that depends on the mouse
     // button being released again
     mitkWidget1->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
     mitkWidget2->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
     mitkWidget3->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
     break;
 
   case PLANE_MODE_ROTATION:
     m_SlicesRotator->HandleEvent( &stateEvent );
 
     // just in case SNCs will develop something that depends on the mouse
     // button being released again
     m_SlicesRotator->HandleEvent( &stateEvent2 );
     break;
 
   case PLANE_MODE_SWIVEL:
     m_SlicesSwiveller->HandleEvent( &stateEvent );
 
     // just in case SNCs will develop something that depends on the mouse
     // button being released again
     m_SlicesSwiveller->HandleEvent( &stateEvent2 );
     break;
   }
 
   // determine if cross is now out of display
   // if so, move the display window
   EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())
     ->GetDisplayGeometry(), newPosition );
   EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())
     ->GetDisplayGeometry(), newPosition );
   EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())
     ->GetDisplayGeometry(), newPosition );
 
   // update displays
   m_RenderingManager->RequestUpdateAll();
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEvent()
 {
   if(!m_PendingCrosshairPositionEvent)
   {
     m_PendingCrosshairPositionEvent=true;
     QTimer::singleShot(0,this,SLOT( HandleCrosshairPositionEventDelayed() ) );
   }
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
 {
   m_PendingCrosshairPositionEvent = false;
 
   // find image with highest layer
   mitk::Point3D crosshairPos = this->GetCrossPosition();
 
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
 
   mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->m_DataStorage->GetSubset(isImageData).GetPointer();
   std::string statusText;
-  mitk::Image::Pointer image3D;
+  mitk::Image::Pointer image;
   int  maxlayer = -32768;
 
   mitk::BaseRenderer* baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
   // find image with largest layer, that is the image shown on top in the render window
   for (unsigned int x = 0; x < nodes->size(); x++)
   {
     if ( (nodes->at(x)->GetData()->GetGeometry() != NULL) &&
          nodes->at(x)->GetData()->GetGeometry()->IsInside(crosshairPos) )
     {
       int layer = 0;
       if(!(nodes->at(x)->GetIntProperty("layer", layer))) continue;
       if(layer > maxlayer)
       {
         if( static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible( baseRenderer ) )
         {
-          image3D = dynamic_cast<mitk::Image*>(nodes->at(x)->GetData());
+          image = dynamic_cast<mitk::Image*>(nodes->at(x)->GetData());
           maxlayer = layer;
         }
       }
     }
   }
 
   std::stringstream stream;
 
   mitk::Index3D p;
-  if(image3D.IsNotNull())
+  int timestep = baseRenderer->GetTimeStep();
+
+  if(image.IsNotNull() && (image->GetTimeSteps() > timestep ))
   {
-    image3D->GetGeometry()->WorldToIndex(crosshairPos, p);
+    image->GetGeometry()->WorldToIndex(crosshairPos, p);
     stream.precision(2);
     stream<<"Position: <" << std::fixed <<crosshairPos[0] << ", " << std::fixed << crosshairPos[1] << ", " << std::fixed << crosshairPos[2] << "> mm";
     stream<<"; Index: <"<<p[0] << ", " << p[1] << ", " << p[2] << "> ";
-    mitk::ScalarType pixelValue = image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep());
+    mitk::ScalarType pixelValue = image->GetPixelValueByIndex(p, timestep);
     if (fabs(pixelValue)>1000000)
     {
-      stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<<std::scientific<<image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep())<<"  ";
+      stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<<std::scientific<<image->GetPixelValueByIndex(p, timestep)<<"  ";
     }
     else
     {
-      stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<<image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep())<<"  ";
+      stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<<image->GetPixelValueByIndex(p, timestep)<<"  ";
     }
   }
   else
   {
     stream << "No image information at this position!";
   }
 
   statusText = stream.str();
   mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
 
 
 }
 
 void QmitkStdMultiWidget::EnableNavigationControllerEventListening()
 {
   // Let NavigationControllers listen to GlobalInteraction
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
 
   // Listen for SliceNavigationController
   mitkWidget1->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
   mitkWidget2->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
   mitkWidget3->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
 
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     gi->AddListener( mitkWidget1->GetSliceNavigationController() );
     gi->AddListener( mitkWidget2->GetSliceNavigationController() );
     gi->AddListener( mitkWidget3->GetSliceNavigationController() );
     gi->AddListener( mitkWidget4->GetSliceNavigationController() );
     break;
 
   case PLANE_MODE_ROTATION:
     gi->AddListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     gi->AddListener( m_SlicesSwiveller );
     break;
   }
 
   gi->AddListener( m_TimeNavigationController );
   m_CrosshairNavigationEnabled = true;
 }
 
 void QmitkStdMultiWidget::DisableNavigationControllerEventListening()
 {
   // Do not let NavigationControllers listen to GlobalInteraction
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
 
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     gi->RemoveListener( mitkWidget1->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget2->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget3->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget4->GetSliceNavigationController() );
     break;
 
   case PLANE_MODE_ROTATION:
     m_SlicesRotator->ResetMouseCursor();
     gi->RemoveListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     m_SlicesSwiveller->ResetMouseCursor();
     gi->RemoveListener( m_SlicesSwiveller );
     break;
   }
 
   gi->RemoveListener( m_TimeNavigationController );
   m_CrosshairNavigationEnabled = false;
 }
 
 
 int QmitkStdMultiWidget::GetLayout() const
 {
   return m_Layout;
 }
 
 bool QmitkStdMultiWidget::GetGradientBackgroundFlag() const
 {
   return m_GradientBackgroundFlag;
 }
 
 void QmitkStdMultiWidget::EnableGradientBackground()
 {
   // gradient background is by default only in widget 4, otherwise
   // interferences between 2D rendering and VTK rendering may occur.
   //m_GradientBackground1->Enable();
   //m_GradientBackground2->Enable();
   //m_GradientBackground3->Enable();
   m_GradientBackground4->Enable();
   m_GradientBackgroundFlag = true;
 }
 
 
 void QmitkStdMultiWidget::DisableGradientBackground()
 {
   //m_GradientBackground1->Disable();
   //m_GradientBackground2->Disable();
   //m_GradientBackground3->Disable();
   m_GradientBackground4->Disable();
   m_GradientBackgroundFlag = false;
 }
 
 
 void QmitkStdMultiWidget::EnableDepartmentLogo()
 {
   m_LogoRendering4->Enable();
 }
 
 
 void QmitkStdMultiWidget::DisableDepartmentLogo()
 {
   m_LogoRendering4->Disable();
 }
 
 bool QmitkStdMultiWidget::IsDepartmentLogoEnabled() const
 {
   return m_LogoRendering4->IsEnabled();
 }
 
 bool QmitkStdMultiWidget::IsCrosshairNavigationEnabled() const
 {
   return m_CrosshairNavigationEnabled;
 }
 
 
 mitk::SlicesRotator * QmitkStdMultiWidget::GetSlicesRotator() const
 {
   return m_SlicesRotator;
 }
 
 
 mitk::SlicesSwiveller * QmitkStdMultiWidget::GetSlicesSwiveller() const
 {
   return m_SlicesSwiveller;
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char* widgetName, bool visible, mitk::BaseRenderer *renderer)
 {
   if (m_DataStorage.IsNotNull())
   {
     mitk::DataNode* n = m_DataStorage->GetNamedNode(widgetName);
     if (n != NULL)
       n->SetVisibility(visible, renderer);
   }
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
 {
   SetWidgetPlaneVisibility("widget1Plane", visible, renderer);
   SetWidgetPlaneVisibility("widget2Plane", visible, renderer);
   SetWidgetPlaneVisibility("widget3Plane", visible, renderer);
   m_RenderingManager->RequestUpdateAll();
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlanesLocked(bool locked)
 {
   //do your job and lock or unlock slices.
   GetRenderWindow1()->GetSliceNavigationController()->SetSliceLocked(locked);
   GetRenderWindow2()->GetSliceNavigationController()->SetSliceLocked(locked);
   GetRenderWindow3()->GetSliceNavigationController()->SetSliceLocked(locked);
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlanesRotationLocked(bool locked)
 {
   //do your job and lock or unlock slices.
   GetRenderWindow1()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
   GetRenderWindow2()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
   GetRenderWindow3()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlanesRotationLinked( bool link )
 {
   m_SlicesRotator->SetLinkPlanes( link );
   m_SlicesSwiveller->SetLinkPlanes( link );
   emit WidgetPlanesRotationLinked( link );
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlaneMode( int userMode )
 {
   MITK_DEBUG << "Changing crosshair mode to " << userMode;
 
   // first of all reset left mouse button interaction to default if PACS interaction style is active
   m_MouseModeSwitcher->SelectMouseMode( mitk::MouseModeSwitcher::MousePointer );
 
   emit WidgetNotifyNewCrossHairMode( userMode );
   
   int mode = m_PlaneMode;
   bool link = false;
   
   // Convert user interface mode to actual mode
   {
     switch(userMode)
     {
       case 0:
         mode = PLANE_MODE_SLICING;
         link = false;
         break;
       
       case 1:
         mode = PLANE_MODE_ROTATION;
         link = false;
         break;
      
       case 2:
         mode = PLANE_MODE_ROTATION;
         link = true;
         break;
      
       case 3:
         mode = PLANE_MODE_SWIVEL;
         link = false;
         break;
     }
   }
 
   // Slice rotation linked
   m_SlicesRotator->SetLinkPlanes( link );
   m_SlicesSwiveller->SetLinkPlanes( link );
 
   // Do nothing if mode didn't change
   if ( m_PlaneMode == mode )
   {
     return;
   }
 
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
 
   // Remove listeners of previous mode
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     // Notify MainTemplate GUI that this mode has been deselected
     emit WidgetPlaneModeSlicing( false );
 
     gi->RemoveListener( mitkWidget1->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget2->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget3->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget4->GetSliceNavigationController() );
     break;
 
   case PLANE_MODE_ROTATION:
     // Notify MainTemplate GUI that this mode has been deselected
     emit WidgetPlaneModeRotation( false );
 
     m_SlicesRotator->ResetMouseCursor();
     gi->RemoveListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     // Notify MainTemplate GUI that this mode has been deselected
     emit WidgetPlaneModeSwivel( false );
 
     m_SlicesSwiveller->ResetMouseCursor();
     gi->RemoveListener( m_SlicesSwiveller );
     break;
   }
 
   // Set new mode and add corresponding listener to GlobalInteraction
   m_PlaneMode = mode;
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     // Notify MainTemplate GUI that this mode has been selected
     emit WidgetPlaneModeSlicing( true );
 
     // Add listeners
     gi->AddListener( mitkWidget1->GetSliceNavigationController() );
     gi->AddListener( mitkWidget2->GetSliceNavigationController() );
     gi->AddListener( mitkWidget3->GetSliceNavigationController() );
     gi->AddListener( mitkWidget4->GetSliceNavigationController() );
 
     m_RenderingManager->InitializeViews();
     break;
 
   case PLANE_MODE_ROTATION:
     // Notify MainTemplate GUI that this mode has been selected
     emit WidgetPlaneModeRotation( true );
 
     // Add listener
     gi->AddListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     // Notify MainTemplate GUI that this mode has been selected
     emit WidgetPlaneModeSwivel( true );
 
     // Add listener
     gi->AddListener( m_SlicesSwiveller );
     break;
   }
   // Notify MainTemplate GUI that mode has changed
   emit WidgetPlaneModeChange(m_PlaneMode);
 }
 
 
 void QmitkStdMultiWidget::SetGradientBackgroundColors( const mitk::Color & upper, const mitk::Color & lower )
 {
   m_GradientBackground1->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackground2->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackground3->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackground4->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackgroundFlag = true;
 }
 
 
 void QmitkStdMultiWidget::SetDepartmentLogoPath( const char * path )
 {
   m_LogoRendering1->SetLogoSource(path);
   m_LogoRendering2->SetLogoSource(path);
   m_LogoRendering3->SetLogoSource(path);
   m_LogoRendering4->SetLogoSource(path);
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToSlicing( bool activate )
 {
   if ( activate )
   {
     this->SetWidgetPlaneMode( PLANE_MODE_SLICING );
   }
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToRotation( bool activate )
 {
   if ( activate )
   {
     this->SetWidgetPlaneMode( PLANE_MODE_ROTATION );
   }
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToSwivel( bool activate )
 {
   if ( activate )
   {
     this->SetWidgetPlaneMode( PLANE_MODE_SWIVEL );
   }
 }
 
 void QmitkStdMultiWidget::OnLayoutDesignChanged( int layoutDesignIndex )
 {
   switch( layoutDesignIndex )
   {
   case LAYOUT_DEFAULT:
     {
       this->changeLayoutToDefault();
       break;
     }
   case LAYOUT_2D_IMAGES_UP:
     {
       this->changeLayoutTo2DImagesUp();
       break;
     }
   case LAYOUT_2D_IMAGES_LEFT:
     {
       this->changeLayoutTo2DImagesLeft();
       break;
     }
   case LAYOUT_BIG_3D:
     {
       this->changeLayoutToBig3D();
       break;
     }
   case LAYOUT_WIDGET1:
     {
       this->changeLayoutToWidget1();
       break;
     }
   case LAYOUT_WIDGET2:
     {
       this->changeLayoutToWidget2();
       break;
     }
   case LAYOUT_WIDGET3:
     {
       this->changeLayoutToWidget3();
       break;
     }
   case LAYOUT_2X_2D_AND_3D_WIDGET:
     {
       this->changeLayoutTo2x2Dand3DWidget();
       break;
     }
   case LAYOUT_ROW_WIDGET_3_AND_4:
     {
       this->changeLayoutToRowWidget3And4();
       break;
     }
   case LAYOUT_COLUMN_WIDGET_3_AND_4:
     {
       this->changeLayoutToColumnWidget3And4();
       break;
     }
   case LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4:
     {
       this->changeLayoutToRowWidgetSmall3andBig4();
       break;
     }
   case LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4:
     {
       this->changeLayoutToSmallUpperWidget2Big3and4();
       break;
     }
   case LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET:
     {
       this->changeLayoutToLeft2Dand3DRight2D();
       break;
     }
 
   };
 
 
 }
 
 void QmitkStdMultiWidget::UpdateAllWidgets()
 {
   mitkWidget1->resize( mitkWidget1Container->frameSize().width()-1, mitkWidget1Container->frameSize().height() );
   mitkWidget1->resize( mitkWidget1Container->frameSize().width(), mitkWidget1Container->frameSize().height() );
 
   mitkWidget2->resize( mitkWidget2Container->frameSize().width()-1, mitkWidget2Container->frameSize().height() );
   mitkWidget2->resize( mitkWidget2Container->frameSize().width(), mitkWidget2Container->frameSize().height() );
 
   mitkWidget3->resize( mitkWidget3Container->frameSize().width()-1, mitkWidget3Container->frameSize().height() );
   mitkWidget3->resize( mitkWidget3Container->frameSize().width(), mitkWidget3Container->frameSize().height() );
 
   mitkWidget4->resize( mitkWidget4Container->frameSize().width()-1, mitkWidget4Container->frameSize().height() );
   mitkWidget4->resize( mitkWidget4Container->frameSize().width(), mitkWidget4Container->frameSize().height() );
 
 }
 
 
 void QmitkStdMultiWidget::HideAllWidgetToolbars()
 {
   mitkWidget1->HideRenderWindowMenu();
   mitkWidget2->HideRenderWindowMenu();
   mitkWidget3->HideRenderWindowMenu();
   mitkWidget4->HideRenderWindowMenu();
 }
 
 void QmitkStdMultiWidget::ActivateMenuWidget( bool state )
 {
   mitkWidget1->ActivateMenuWidget( state, this );
   mitkWidget2->ActivateMenuWidget( state, this );
   mitkWidget3->ActivateMenuWidget( state, this );
   mitkWidget4->ActivateMenuWidget( state, this );
 }
 
 bool QmitkStdMultiWidget::IsMenuWidgetEnabled() const
 {
   return mitkWidget1->GetActivateMenuWidgetFlag();
 }
  
 void QmitkStdMultiWidget::ResetCrosshair()
 {
   if (m_DataStorage.IsNotNull())
   {
     mitk::NodePredicateNot::Pointer pred
     = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
     , mitk::BoolProperty::New(false)));
 
     mitk::NodePredicateNot::Pointer pred2
     = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
     , mitk::BoolProperty::New(true)));
 
     mitk::DataStorage::SetOfObjects::ConstPointer rs = m_DataStorage->GetSubset(pred);
     mitk::DataStorage::SetOfObjects::ConstPointer rs2 = m_DataStorage->GetSubset(pred2);
     // calculate bounding geometry of these nodes
     mitk::TimeSlicedGeometry::Pointer bounds = m_DataStorage->ComputeBoundingGeometry3D(rs, "visible");
     
     m_RenderingManager->InitializeViews(bounds);
     //m_RenderingManager->InitializeViews( m_DataStorage->ComputeVisibleBoundingGeometry3D() );
     // reset interactor to normal slicing
     this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
   }
 }
 
 void QmitkStdMultiWidget::EnableColoredRectangles()
 {
   m_RectangleRendering1->Enable(1.0, 0.0, 0.0);
   m_RectangleRendering2->Enable(0.0, 1.0, 0.0);
   m_RectangleRendering3->Enable(0.0, 0.0, 1.0);
   m_RectangleRendering4->Enable(1.0, 1.0, 0.0);
 }
 
 void QmitkStdMultiWidget::DisableColoredRectangles()
 {
   m_RectangleRendering1->Disable();
   m_RectangleRendering2->Disable();
   m_RectangleRendering3->Disable();
   m_RectangleRendering4->Disable();
 }
 
 bool QmitkStdMultiWidget::IsColoredRectanglesEnabled() const
 {
   return m_RectangleRendering1->IsEnabled();
 }
 
 mitk::MouseModeSwitcher* QmitkStdMultiWidget::GetMouseModeSwitcher()
 {
   return m_MouseModeSwitcher;
 }
 
 void QmitkStdMultiWidget::MouseModeSelected( mitk::MouseModeSwitcher::MouseMode mouseMode )
 {
   if ( mouseMode == 0 )
   {
     this->EnableNavigationControllerEventListening();
   }
   else
   {
     this->DisableNavigationControllerEventListening();
   }
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1()
 {
   return this->m_PlaneNode1;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2()
 {
   return this->m_PlaneNode2;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3()
 {
   return this->m_PlaneNode3;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(int id)
 {
   switch(id)
   {
     case 1: return this->m_PlaneNode1;
     break;
     case 2: return this->m_PlaneNode2;
     break;
     case 3: return this->m_PlaneNode3;
     break;
     default: return NULL;
   }
 }
 
diff --git a/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialog.cpp b/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialog.cpp
index be1d4dfb8d..f46598e694 100644
--- a/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialog.cpp
+++ b/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialog.cpp
@@ -1,78 +1,77 @@
 /*===================================================================
 
 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 "QmitkAboutDialog.h"
 #include "QmitkModulesDialog.h"
 #include <QPushButton>
 #include <mitkVersion.h>
 
 QmitkAboutDialog::QmitkAboutDialog(QWidget* parent, Qt::WindowFlags f)
   : QDialog(parent, f)
 {
   m_GUI.setupUi(this);
 
   QString mitkRevision(MITK_REVISION);
+  QString mitkRevisionDescription(MITK_REVISION_DESC);
 
-  m_GUI.m_RevisionLabel->setText(m_GUI.m_RevisionLabel->text().arg(mitkRevision));
+  m_GUI.m_RevisionLabel->setText(m_GUI.m_RevisionLabel->text().arg(mitkRevision).arg(mitkRevisionDescription));
 
   QPushButton* btnModules = new QPushButton(QIcon(":/qmitk/ModuleView.png"), "Modules");
   m_GUI.m_ButtonBox->addButton(btnModules, QDialogButtonBox::ActionRole);
 
   connect(btnModules, SIGNAL(clicked()), this, SLOT(ShowModules()));
   connect(m_GUI.m_ButtonBox, SIGNAL(rejected()), this, SLOT(reject()));
 }
 
 QmitkAboutDialog::~QmitkAboutDialog()
 {
 }
 
 void QmitkAboutDialog::ShowModules()
 {
   QmitkModulesDialog dialog(this);
   dialog.exec();
-
-  SetCaptionText("MITK Diffusion");
 }
 
 QString QmitkAboutDialog::GetAboutText() const
 {
   return m_GUI.m_AboutLabel->text();
 }
 
 QString QmitkAboutDialog::GetCaptionText() const
 {
   return m_GUI.m_CaptionLabel->text();
 }
 
 QString QmitkAboutDialog::GetRevisionText() const
 {
   return m_GUI.m_RevisionLabel->text();
 }
 
 void QmitkAboutDialog::SetAboutText(const QString &text)
 {
   m_GUI.m_AboutLabel->setText(text);
 }
 
 void QmitkAboutDialog::SetCaptionText(const QString &text)
 {
   m_GUI.m_CaptionLabel->setText(text);
 }
 
 void QmitkAboutDialog::SetRevisionText(const QString &text)
 {
   m_GUI.m_RevisionLabel->setText(text);
 }
diff --git a/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialogGUI.ui b/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialogGUI.ui
index 52569abe7b..1aa16621d5 100644
--- a/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialogGUI.ui
+++ b/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialogGUI.ui
@@ -1,166 +1,167 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkAboutDialog</class>
  <widget class="QDialog" name="QmitkAboutDialog">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>534</width>
     <height>397</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>About</string>
   </property>
   <property name="autoFillBackground">
    <bool>false</bool>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_2">
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <layout class="QVBoxLayout" name="verticalLayout">
        <item>
         <widget class="QLabel" name="m_CaptionLabel">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="font">
           <font>
            <family>MS Sans Serif</family>
            <pointsize>48</pointsize>
            <weight>75</weight>
            <bold>true</bold>
           </font>
          </property>
          <property name="text">
           <string>MITK</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft</set>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="m_RevisionLabel">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="text">
-          <string>Revision %1</string>
+          <string>Revision %1
+Description %2</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
          </property>
         </widget>
        </item>
       </layout>
      </item>
      <item>
       <spacer name="horizontalSpacer">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeType">
         <enum>QSizePolicy::Expanding</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QLabel" name="m_LogoLabel">
        <property name="maximumSize">
         <size>
          <width>84</width>
          <height>56</height>
         </size>
        </property>
        <property name="text">
         <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:8.25pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a href=&quot;http://www.dkfz.de/en/mbi/&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;&lt;img src=&quot;:/qmitk/Logo_mbiATdkfz_small.png&quot; /&gt;&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
        </property>
        <property name="scaledContents">
         <bool>true</bool>
        </property>
        <property name="openExternalLinks">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QScrollArea" name="scrollArea">
      <property name="widgetResizable">
       <bool>true</bool>
      </property>
      <widget class="QWidget" name="m_ScrollArea">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>-51</y>
         <width>496</width>
         <height>375</height>
        </rect>
       </property>
       <layout class="QGridLayout" name="gridLayout">
        <item row="0" column="1">
         <widget class="QLabel" name="m_AboutLabel">
          <property name="text">
           <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'Ubuntu'; font-size:11pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:10pt; font-weight:600;&quot;&gt;General Information&lt;/span&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;br /&gt;&lt;/p&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;MITK [1] has been developed by the Division of Medical and Biological Informatics of the German Cancer Research Center (DKFZ).&lt;/span&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;&lt;br /&gt;&lt;/p&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;[1] &lt;/span&gt;&lt;a href=&quot;http://www.mitk.org/&quot;&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt; text-decoration: underline; color:#0000ff;&quot;&gt;http://www.mitk.org/&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;[2] &lt;/span&gt;&lt;a href=&quot;http://www.dkfz.de/en/mbi/index.html&quot;&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt; text-decoration: underline; color:#0000ff;&quot;&gt;http://www.dkfz.de/en/mbi/index.html&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;&lt;br /&gt;&lt;/p&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;To contact the MITK Team, see &lt;/span&gt;&lt;a href=&quot;http://www.mitk.org/wiki/Contact&quot;&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt; text-decoration: underline; color:#0000ff;&quot;&gt;http://www.mitk.org/wiki/Contact&lt;/span&gt;&lt;/a&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;.&lt;/span&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;br /&gt;&lt;/p&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:10pt; font-weight:600;&quot;&gt;Third Party Libraries&lt;/span&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;&lt;br /&gt;&lt;/p&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;a href=&quot;http://docs.mitk.org/nightly-qt4/thirdpartylibs.html&quot;&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt; text-decoration: underline; color:#0000ff;&quot;&gt;http://docs.mitk.org/nightly-qt4/thirdpartylibs.html&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'MS Shell Dlg 2'; font-size:8pt; text-decoration: underline; color:#0000ff;&quot;&gt;&lt;br /&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
          <property name="wordWrap">
           <bool>true</bool>
          </property>
          <property name="openExternalLinks">
           <bool>true</bool>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item>
     <widget class="QDialogButtonBox" name="m_ButtonBox">
      <property name="standardButtons">
       <set>QDialogButtonBox::Close</set>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>
diff --git a/Modules/QmitkExt/QmitkSlicesInterpolator.cpp b/Modules/QmitkExt/QmitkSlicesInterpolator.cpp
index 8a9bf33ff6..c176ec221f 100644
--- a/Modules/QmitkExt/QmitkSlicesInterpolator.cpp
+++ b/Modules/QmitkExt/QmitkSlicesInterpolator.cpp
@@ -1,1061 +1,1074 @@
 /*===================================================================
 
 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 "QmitkSlicesInterpolator.h"
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkSelectableGLWidget.h"
 
 #include "mitkToolManager.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkOverwriteSliceImageFilter.h"
 #include "mitkProgressBar.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 #include "mitkInteractionConst.h"
 #include "mitkApplyDiffImageOperation.h"
 #include "mitkDiffImageApplier.h"
 #include "mitkSegTool2D.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkSurfaceToImageFilter.h"
 
 #include <itkCommand.h>
 
 #include <QCheckBox>
 #include <QPushButton>
 #include <QMenu>
 #include <QCursor>
 #include <QHBoxLayout>
 #include <QMessageBox>
 
 
 #define ROUND(a)     ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 const std::map<QAction*, unsigned int> QmitkSlicesInterpolator::createActionToSliceDimension()
 {
   std::map<QAction*, unsigned int> actionToSliceDimension;
   actionToSliceDimension[new QAction("Axial (red window)", 0)] = 2;
   actionToSliceDimension[new QAction("Sagittal (green window)", 0)] = 0;
   actionToSliceDimension[new QAction("Coronal (blue window)", 0)] = 1;
   return actionToSliceDimension;
 }
 
 
 QmitkSlicesInterpolator::QmitkSlicesInterpolator(QWidget* parent, const char*  /*name*/)
   :QWidget(parent),
     ACTION_TO_SLICEDIMENSION( createActionToSliceDimension() ),
     m_Interpolator( mitk::SegmentationInterpolationController::New() ),
     m_MultiWidget(NULL),
     m_ToolManager(NULL),
     m_Initialized(false),
     m_LastSliceDimension(2),
     m_LastSliceIndex(0),
     m_2DInterpolationEnabled(false),
     m_3DInterpolationEnabled(false)
 {
 
   m_SurfaceInterpolator = mitk::SurfaceInterpolationController::GetInstance();
   QHBoxLayout* layout = new QHBoxLayout(this);
 
   m_GroupBoxEnableExclusiveInterpolationMode = new QGroupBox("Interpolation", this);
   QGridLayout* grid = new QGridLayout(m_GroupBoxEnableExclusiveInterpolationMode);
 
   m_RBtnEnable3DInterpolation = new QRadioButton("3D",this);
   connect(m_RBtnEnable3DInterpolation, SIGNAL(toggled(bool)), this, SLOT(On3DInterpolationEnabled(bool)));
   m_RBtnEnable3DInterpolation->setChecked(true);
   grid->addWidget(m_RBtnEnable3DInterpolation,0,0);
 
   m_BtnAccept3DInterpolation = new QPushButton("Accept", this);
   m_BtnAccept3DInterpolation->setEnabled(false);
   connect(m_BtnAccept3DInterpolation, SIGNAL(clicked()), this, SLOT(OnAccept3DInterpolationClicked()));
   grid->addWidget(m_BtnAccept3DInterpolation, 0,1);
 
   m_CbShowMarkers = new QCheckBox("Show Position Nodes", this);
   m_CbShowMarkers->setChecked(true);
   connect(m_CbShowMarkers, SIGNAL(toggled(bool)), this, SLOT(OnShowMarkers(bool)));
   connect(m_CbShowMarkers, SIGNAL(toggled(bool)), this, SIGNAL(SignalShowMarkerNodes(bool)));
   grid->addWidget(m_CbShowMarkers,0,2);
 
   m_RBtnEnable2DInterpolation = new QRadioButton("2D",this);
   connect(m_RBtnEnable2DInterpolation, SIGNAL(toggled(bool)), this, SLOT(On2DInterpolationEnabled(bool)));
   grid->addWidget(m_RBtnEnable2DInterpolation,1,0);
 
   m_BtnAcceptInterpolation = new QPushButton("Accept", this);
   m_BtnAcceptInterpolation->setEnabled( false );
   connect( m_BtnAcceptInterpolation, SIGNAL(clicked()), this, SLOT(OnAcceptInterpolationClicked()) );
   grid->addWidget(m_BtnAcceptInterpolation,1,1);
 
   m_BtnAcceptAllInterpolations = new QPushButton("... for all slices", this);
   m_BtnAcceptAllInterpolations->setEnabled( false );
   connect( m_BtnAcceptAllInterpolations, SIGNAL(clicked()), this, SLOT(OnAcceptAllInterpolationsClicked()) );
   grid->addWidget(m_BtnAcceptAllInterpolations,1,2);
 
   m_RBtnDisableInterpolation = new QRadioButton("Disable", this);
   connect(m_RBtnDisableInterpolation, SIGNAL(toggled(bool)), this, SLOT(OnInterpolationDisabled(bool)));
   grid->addWidget(m_RBtnDisableInterpolation, 2,0);
 
   layout->addWidget(m_GroupBoxEnableExclusiveInterpolationMode);
   this->setLayout(layout);
 
   itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
   command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnInterpolationInfoChanged );
   InterpolationInfoChangedObserverTag = m_Interpolator->AddObserver( itk::ModifiedEvent(), command );
 
   itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command2 = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
   command2->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged );
   SurfaceInterpolationInfoChangedObserverTag = m_SurfaceInterpolator->AddObserver( itk::ModifiedEvent(), command2 );
 
   // feedback node and its visualization properties
   m_FeedbackNode = mitk::DataNode::New();
   mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties( m_FeedbackNode );
 
   m_FeedbackNode->SetProperty( "binary", mitk::BoolProperty::New(true) );
   m_FeedbackNode->SetProperty( "outline binary", mitk::BoolProperty::New(true) );
   m_FeedbackNode->SetProperty( "color", mitk::ColorProperty::New(255.0, 255.0, 0.0) );
   m_FeedbackNode->SetProperty( "texture interpolation", mitk::BoolProperty::New(false) );
   m_FeedbackNode->SetProperty( "layer", mitk::IntProperty::New( 20 ) );
   m_FeedbackNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( mitk::LevelWindow(0, 1) ) );
   m_FeedbackNode->SetProperty( "name", mitk::StringProperty::New("Interpolation feedback") );
   m_FeedbackNode->SetProperty( "opacity", mitk::FloatProperty::New(0.8) );
   m_FeedbackNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
 
   m_InterpolatedSurfaceNode = mitk::DataNode::New();
   m_InterpolatedSurfaceNode->SetProperty( "color", mitk::ColorProperty::New(255.0,255.0,0.0) );
   m_InterpolatedSurfaceNode->SetProperty( "name", mitk::StringProperty::New("Surface Interpolation feedback") );
   m_InterpolatedSurfaceNode->SetProperty( "opacity", mitk::FloatProperty::New(0.5) );
   m_InterpolatedSurfaceNode->SetProperty( "includeInBoundingBox", mitk::BoolProperty::New(false));
   m_InterpolatedSurfaceNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
   m_InterpolatedSurfaceNode->SetVisibility(false);
 
   m_3DContourNode = mitk::DataNode::New();
   m_3DContourNode->SetProperty( "color", mitk::ColorProperty::New(0.0, 0.0, 0.0) );
   m_3DContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_3DContourNode->SetProperty( "name", mitk::StringProperty::New("Drawn Contours") );
   m_3DContourNode->SetProperty("material.representation", mitk::VtkRepresentationProperty::New(VTK_WIREFRAME));
   m_3DContourNode->SetProperty("material.wireframeLineWidth", mitk::FloatProperty::New(2.0f));
   m_3DContourNode->SetProperty("3DContourContainer", mitk::BoolProperty::New(true));
   m_3DContourNode->SetProperty( "includeInBoundingBox", mitk::BoolProperty::New(false));
   m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
   m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget2")));
   m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
   m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
 
   QWidget::setContentsMargins(0, 0, 0, 0);
   if ( QWidget::layout() != NULL )
   {
     QWidget::layout()->setContentsMargins(0, 0, 0, 0);
   }
 
   //For running 3D Interpolation in background
   // create a QFuture and a QFutureWatcher
 
   connect(&m_Watcher, SIGNAL(started()), this, SLOT(StartUpdateInterpolationTimer()));
   connect(&m_Watcher, SIGNAL(finished()), this, SLOT(SurfaceInterpolationFinished()));
   connect(&m_Watcher, SIGNAL(finished()), this, SLOT(StopUpdateInterpolationTimer()));
   m_Timer = new QTimer(this);
   connect(m_Timer, SIGNAL(timeout()), this, SLOT(ChangeSurfaceColor()));
 }
 
 void QmitkSlicesInterpolator::SetDataStorage( mitk::DataStorage& storage )
 {
   m_DataStorage = &storage;
   m_SurfaceInterpolator->SetDataStorage(storage);
 }
 
 mitk::DataStorage* QmitkSlicesInterpolator::GetDataStorage()
 {
   if ( m_DataStorage.IsNotNull() )
   {
     return m_DataStorage;
   }
   else
   {
     return NULL;
   }
 }
 
 
 void QmitkSlicesInterpolator::Initialize(mitk::ToolManager* toolManager, QmitkStdMultiWidget* multiWidget)
 {
   if (m_Initialized)
   {
     // remove old observers
     if (m_ToolManager)
     {
       m_ToolManager->WorkingDataChanged
           -= mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified );
 
       m_ToolManager->ReferenceDataChanged
           -= mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified );
     }
 
     if (m_MultiWidget)
     {
       disconnect( m_MultiWidget, SIGNAL(destroyed(QObject*)), this, SLOT(OnMultiWidgetDeleted(QObject*)) );
       mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
       slicer->RemoveObserver( TSliceObserverTag );
       slicer->RemoveObserver( TTimeObserverTag );
       slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
       slicer->RemoveObserver( SSliceObserverTag );
       slicer->RemoveObserver( STimeObserverTag );
       slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
       slicer->RemoveObserver( FSliceObserverTag );
       slicer->RemoveObserver( FTimeObserverTag );
     }
 
     //return;
   }
 
   m_MultiWidget = multiWidget;
 
   connect( m_MultiWidget, SIGNAL(destroyed(QObject*)), this, SLOT(OnMultiWidgetDeleted(QObject*)) );
 
   m_ToolManager = toolManager;
 
   if (m_ToolManager)
   {
     // set enabled only if a segmentation is selected
     mitk::DataNode* node = m_ToolManager->GetWorkingData(0);
     QWidget::setEnabled( node != NULL );
 
     // react whenever the set of selected segmentation changes
     m_ToolManager->WorkingDataChanged += mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified );
     m_ToolManager->ReferenceDataChanged += mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified );
 
     // connect to the steppers of the three multi widget widgets. after each change, call the interpolator
     if (m_MultiWidget)
     {
       mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
       m_TimeStep.resize(3);
       m_TimeStep[2] = slicer->GetTime()->GetPos();
       {
         itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
         command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnAxialTimeChanged );
         TTimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
       }
 
       {
         itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
         command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnAxialSliceChanged );
         TSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
       }
 
       // connect to the steppers of the three multi widget widgets. after each change, call the interpolator
       slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
       m_TimeStep[0] = slicer->GetTime()->GetPos();
       {
         itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
         command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSagittalTimeChanged );
         STimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
       }
 
       {
         itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
         command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSagittalSliceChanged );
         SSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
       }
 
       // connect to the steppers of the three multi widget widgets. after each change, call the interpolator
       slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
       m_TimeStep[1] = slicer->GetTime()->GetPos();
       {
         itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
         command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnFrontalTimeChanged );
         FTimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
       }
 
       {
         itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
         command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnFrontalSliceChanged );
         FSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
       }
     }
   }
 
   m_Initialized = true;
 }
 
 QmitkSlicesInterpolator::~QmitkSlicesInterpolator()
 {
   if (m_MultiWidget)
   {
     mitk::SliceNavigationController* slicer;
     if(m_MultiWidget->mitkWidget1 != NULL)
     {
       slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
       slicer->RemoveObserver( TSliceObserverTag );
       slicer->RemoveObserver( TTimeObserverTag );
     }
     if(m_MultiWidget->mitkWidget2 != NULL)
     {
       slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
       slicer->RemoveObserver( SSliceObserverTag );
       slicer->RemoveObserver( STimeObserverTag );
     }
     if(m_MultiWidget->mitkWidget3 != NULL)
     {
       slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
       slicer->RemoveObserver( FSliceObserverTag );
       slicer->RemoveObserver( FTimeObserverTag );
     }
   }
   if(m_DataStorage->Exists(m_3DContourNode))
     m_DataStorage->Remove(m_3DContourNode);
   if(m_DataStorage->Exists(m_InterpolatedSurfaceNode))
     m_DataStorage->Remove(m_InterpolatedSurfaceNode);
+
+  // remove observer
+  m_Interpolator->RemoveObserver( InterpolationInfoChangedObserverTag );
+  m_SurfaceInterpolator->RemoveObserver( SurfaceInterpolationInfoChangedObserverTag );
+
   delete m_Timer;
 }
 
 void QmitkSlicesInterpolator::On2DInterpolationEnabled(bool status)
 {
   OnInterpolationActivated(status);
 }
 
 void QmitkSlicesInterpolator::On3DInterpolationEnabled(bool status)
 {
   On3DInterpolationActivated(status);
 }
 
 void QmitkSlicesInterpolator::OnInterpolationDisabled(bool status)
 {
   if (status)
   {
     OnInterpolationActivated(!status);
     On3DInterpolationActivated(!status);
     this->Show3DInterpolationResult(false);
   }
 }
 
 void QmitkSlicesInterpolator::OnShowMarkers(bool state)
 {
   mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = m_DataStorage->GetSubset(mitk::NodePredicateProperty::New("isContourMarker"
                                                                                                                               , mitk::BoolProperty::New(true)));
 
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
   {
     it->Value()->SetProperty("helper object", mitk::BoolProperty::New(!state));
   }
 }
 
 void QmitkSlicesInterpolator::OnToolManagerWorkingDataModified()
 {
   //Check if the new working data has already a contourlist for 3D interpolation
   this->SetCurrentContourListID();
   if (m_2DInterpolationEnabled)
   {
     OnInterpolationActivated( true ); // re-initialize if needed
   }
   if (m_3DInterpolationEnabled)
   {
     On3DInterpolationActivated( true);
   }
 }
 
 void QmitkSlicesInterpolator::OnToolManagerReferenceDataModified()
 {
   if (m_2DInterpolationEnabled)
   {
     OnInterpolationActivated( true ); // re-initialize if needed
   }
   if (m_3DInterpolationEnabled)
   {
     this->Show3DInterpolationResult(false);
   }
 }
 
 void QmitkSlicesInterpolator::OnAxialTimeChanged(itk::Object* sender, const itk::EventObject& e)
 {
   const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
   m_TimeStep[2] = event.GetPos();
 
   if (m_LastSliceDimension == 2)
   {
     mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
     if (snc) snc->SendSlice(); // will trigger a new interpolation
   }
 }
 
 void QmitkSlicesInterpolator::OnTransversalTimeChanged(itk::Object* sender, const itk::EventObject& e)
 {
   this->OnAxialTimeChanged(sender, e);
 }
 
 void QmitkSlicesInterpolator::OnSagittalTimeChanged(itk::Object* sender, const itk::EventObject& e)
 {
   const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
   m_TimeStep[0] = event.GetPos();
 
   if (m_LastSliceDimension == 0)
   {
     mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
     if (snc) snc->SendSlice(); // will trigger a new interpolation
   }
 }
 
 void QmitkSlicesInterpolator::OnFrontalTimeChanged(itk::Object* sender, const itk::EventObject& e)
 {
   const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
   m_TimeStep[1] = event.GetPos();
 
   if (m_LastSliceDimension == 1)
   {
     mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
     if (snc) snc->SendSlice(); // will trigger a new interpolation
   }
 }
 
 void QmitkSlicesInterpolator::OnAxialSliceChanged(const itk::EventObject& e)
 {
   if ( TranslateAndInterpolateChangedSlice( e, 2 ) )
   {
     if (m_MultiWidget)
     {
       mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget1->GetRenderWindow())->RequestUpdate();
     }
   }
 }
 
 void QmitkSlicesInterpolator::OnTransversalSliceChanged(const itk::EventObject& e)
 {
   this->OnAxialSliceChanged(e);
 }
 
 void QmitkSlicesInterpolator::OnSagittalSliceChanged(const itk::EventObject& e)
 {
   if ( TranslateAndInterpolateChangedSlice( e, 0 ) )
   {
     if (m_MultiWidget)
     {
       mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget2->GetRenderWindow())->RequestUpdate();
     }
   }
 }
 
 void QmitkSlicesInterpolator::OnFrontalSliceChanged(const itk::EventObject& e)
 {
   if ( TranslateAndInterpolateChangedSlice( e, 1 ) )
   {
     if (m_MultiWidget)
     {
       mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget3->GetRenderWindow())->RequestUpdate();
     }
   }
 }
 
 bool QmitkSlicesInterpolator::TranslateAndInterpolateChangedSlice(const itk::EventObject& e, unsigned int windowID)
 {
   if (!m_2DInterpolationEnabled) return false;
 
   try
   {
     const mitk::SliceNavigationController::GeometrySliceEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent&>(e);
 
     mitk::TimeSlicedGeometry* tsg = event.GetTimeSlicedGeometry();
     if (tsg && m_TimeStep.size() > windowID)
     {
       mitk::SlicedGeometry3D* slicedGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(tsg->GetGeometry3D(m_TimeStep[windowID]));
       if (slicedGeometry)
       {
         mitk::PlaneGeometry* plane = dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry->GetGeometry2D( event.GetPos() ));
         if (plane)
           Interpolate( plane, m_TimeStep[windowID] );
         return true;
       }
     }
   }
   catch(std::bad_cast)
   {
     return false; // so what
   }
 
   return false;
 }
 
 void QmitkSlicesInterpolator::Interpolate( mitk::PlaneGeometry* plane, unsigned int timeStep )
 {
   if (m_ToolManager)
   {
     mitk::DataNode* node = m_ToolManager->GetWorkingData(0);
     if (node)
     {
       m_Segmentation = dynamic_cast<mitk::Image*>(node->GetData());
       if (m_Segmentation)
       {
         int clickedSliceDimension(-1);
         int clickedSliceIndex(-1);
 
         // calculate real slice position, i.e. slice of the image and not slice of the TimeSlicedGeometry
         mitk::SegTool2D::DetermineAffectedImageSlice( m_Segmentation, plane, clickedSliceDimension, clickedSliceIndex );
         mitk::Image::Pointer interpolation = m_Interpolator->Interpolate( clickedSliceDimension, clickedSliceIndex, timeStep );
         m_FeedbackNode->SetData( interpolation );
 
         // Workaround for Bug 11318
         if ((interpolation.IsNotNull()) && (interpolation->GetGeometry() != NULL))
         {
           if(clickedSliceDimension == 1)
           {
             mitk::Point3D orig = interpolation->GetGeometry()->GetOrigin();
             orig[0] = orig[0];
             orig[1] = orig[1] + 0.5;
             orig[2] = orig[2];
             interpolation->GetGeometry()->SetOrigin(orig);
           }
         }
 
         // Workaround for Bug 11318 END
 
         m_LastSliceDimension = clickedSliceDimension;
         m_LastSliceIndex = clickedSliceIndex;
       }
     }
   }
 }
 
 void QmitkSlicesInterpolator::SurfaceInterpolationFinished()
 {
   mitk::Surface::Pointer interpolatedSurface = m_SurfaceInterpolator->GetInterpolationResult();
 
   if(interpolatedSurface.IsNotNull())
   {
     m_BtnAccept3DInterpolation->setEnabled(true);
     m_InterpolatedSurfaceNode->SetData(interpolatedSurface);
     m_3DContourNode->SetData(m_SurfaceInterpolator->GetContoursAsSurface());
 
     this->Show3DInterpolationResult(true);
 
     if( !m_DataStorage->Exists(m_InterpolatedSurfaceNode) && !m_DataStorage->Exists(m_3DContourNode))
     {
       m_DataStorage->Add(m_3DContourNode);
       m_DataStorage->Add(m_InterpolatedSurfaceNode);
 
     }
   }
   else if (interpolatedSurface.IsNull())
   {
     m_BtnAccept3DInterpolation->setEnabled(false);
 
     if (m_DataStorage->Exists(m_InterpolatedSurfaceNode))
     {
       this->Show3DInterpolationResult(false);
     }
   }
 
   if (m_MultiWidget)
   {
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSlicesInterpolator::OnAcceptInterpolationClicked()
 {
   if (m_Segmentation && m_FeedbackNode->GetData())
   {
     //making interpolation separately undoable
     mitk::UndoStackItem::IncCurrObjectEventId();
     mitk::UndoStackItem::IncCurrGroupEventId();
     mitk::UndoStackItem::ExecuteIncrement();
 
     mitk::OverwriteSliceImageFilter::Pointer slicewriter = mitk::OverwriteSliceImageFilter::New();
     slicewriter->SetInput( m_Segmentation );
     slicewriter->SetCreateUndoInformation( true );
     slicewriter->SetSliceImage( dynamic_cast<mitk::Image*>(m_FeedbackNode->GetData()) );
     slicewriter->SetSliceDimension( m_LastSliceDimension );
     slicewriter->SetSliceIndex( m_LastSliceIndex );
     slicewriter->SetTimeStep( m_TimeStep[m_LastSliceDimension] );
     slicewriter->Update();
     m_FeedbackNode->SetData(NULL);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSlicesInterpolator::AcceptAllInterpolations(unsigned int windowID)
 {
   // first creates a 3D diff image, then applies this diff to the segmentation
   if (m_Segmentation)
   {
     int sliceDimension(-1);
     int dummySliceIndex(-1);
     if (!GetSliceForWindowsID(windowID, sliceDimension, dummySliceIndex))
     {
       return; // cannot determine slice orientation
     }
 
     //making interpolation separately undoable
     mitk::UndoStackItem::IncCurrObjectEventId();
     mitk::UndoStackItem::IncCurrGroupEventId();
     mitk::UndoStackItem::ExecuteIncrement();
 
     // create a diff image for the undo operation
     mitk::Image::Pointer diffImage = mitk::Image::New();
     diffImage->Initialize( m_Segmentation );
     mitk::PixelType pixelType( mitk::MakeScalarPixelType<short signed int>()  );
     diffImage->Initialize( pixelType, 3, m_Segmentation->GetDimensions() );
 
     memset( diffImage->GetData(), 0, (pixelType.GetBpe() >> 3) * diffImage->GetDimension(0) * diffImage->GetDimension(1) * diffImage->GetDimension(2) );
     // now the diff image is all 0
 
     unsigned int timeStep( m_TimeStep[windowID] );
 
     // a slicewriter to create the diff image
     mitk::OverwriteSliceImageFilter::Pointer diffslicewriter = mitk::OverwriteSliceImageFilter::New();
     diffslicewriter->SetCreateUndoInformation( false );
     diffslicewriter->SetInput( diffImage );
     diffslicewriter->SetSliceDimension( sliceDimension );
     diffslicewriter->SetTimeStep( timeStep );
 
     unsigned int totalChangedSlices(0);
     unsigned int zslices = m_Segmentation->GetDimension( sliceDimension );
     mitk::ProgressBar::GetInstance()->AddStepsToDo(zslices);
     for (unsigned int sliceIndex = 0; sliceIndex < zslices; ++sliceIndex)
     {
       mitk::Image::Pointer interpolation = m_Interpolator->Interpolate( sliceDimension, sliceIndex, timeStep );
       if (interpolation.IsNotNull()) // we don't check if interpolation is necessary/sensible - but m_Interpolator does
       {
         diffslicewriter->SetSliceImage( interpolation );
         diffslicewriter->SetSliceIndex( sliceIndex );
         diffslicewriter->Update();
         ++totalChangedSlices;
       }
       mitk::ProgressBar::GetInstance()->Progress();
     }
 
     if (totalChangedSlices > 0)
     {
       // store undo stack items
       if ( true )
       {
         // create do/undo operations (we don't execute the doOp here, because it has already been executed during calculation of the diff image
         mitk::ApplyDiffImageOperation* doOp = new mitk::ApplyDiffImageOperation( mitk::OpTEST, m_Segmentation, diffImage, timeStep );
         mitk::ApplyDiffImageOperation* undoOp = new mitk::ApplyDiffImageOperation( mitk::OpTEST, m_Segmentation, diffImage, timeStep );
         undoOp->SetFactor( -1.0 );
         std::stringstream comment;
         comment << "Accept all interpolations (" << totalChangedSlices << ")";
         mitk::OperationEvent* undoStackItem = new mitk::OperationEvent( mitk::DiffImageApplier::GetInstanceForUndo(), doOp, undoOp, comment.str() );
         mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
 
         // acutally apply the changes here
         mitk::DiffImageApplier::GetInstanceForUndo()->ExecuteOperation( doOp );
       }
     }
 
     m_FeedbackNode->SetData(NULL);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSlicesInterpolator::FinishInterpolation(int windowID)
 {
   //this redirect is for calling from outside
 
   if (windowID < 0)
     OnAcceptAllInterpolationsClicked();
   else
     AcceptAllInterpolations( (unsigned int)windowID );
 }
 
 void QmitkSlicesInterpolator::OnAcceptAllInterpolationsClicked()
 {
   QMenu orientationPopup(this);
   std::map<QAction*, unsigned int>::const_iterator it;
   for(it = ACTION_TO_SLICEDIMENSION.begin(); it != ACTION_TO_SLICEDIMENSION.end(); it++)
     orientationPopup.addAction(it->first);
 
   connect( &orientationPopup, SIGNAL(triggered(QAction*)), this, SLOT(OnAcceptAllPopupActivated(QAction*)) );
 
   orientationPopup.exec( QCursor::pos() );
 }
 
 void QmitkSlicesInterpolator::OnAccept3DInterpolationClicked()
 {
   if (m_InterpolatedSurfaceNode.IsNotNull() && m_InterpolatedSurfaceNode->GetData())
   {
     mitk::SurfaceToImageFilter::Pointer s2iFilter = mitk::SurfaceToImageFilter::New();
     s2iFilter->MakeOutputBinaryOn();
     s2iFilter->SetInput(dynamic_cast<mitk::Surface*>(m_InterpolatedSurfaceNode->GetData()));
     s2iFilter->SetImage(dynamic_cast<mitk::Image*>(m_ToolManager->GetReferenceData(0)->GetData()));
     s2iFilter->Update();
 
     mitk::DataNode* segmentationNode = m_ToolManager->GetWorkingData(0);
     segmentationNode->SetData(s2iFilter->GetOutput());
     m_RBtnDisableInterpolation->setChecked(true);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     this->Show3DInterpolationResult(false);
   }
 }
 
 void QmitkSlicesInterpolator::OnAcceptAllPopupActivated(QAction* action)
 {
   try
   {
     std::map<QAction*, unsigned int>::const_iterator iter = ACTION_TO_SLICEDIMENSION.find( action );
     if (iter != ACTION_TO_SLICEDIMENSION.end())
     {
       int windowID = iter->second;
       AcceptAllInterpolations( windowID );
     }
 
   }
   catch(...)
   {
     /* Showing message box with possible memory error */
     QMessageBox errorInfo;
     errorInfo.setWindowTitle("Interpolation Process");
     errorInfo.setIcon(QMessageBox::Critical);
     errorInfo.setText("An error occurred during interpolation. Possible cause: Not enough memory!");
     errorInfo.exec();
 
     //additional error message on std::cerr
     std::cerr << "Ill construction in " __FILE__ " l. " << __LINE__ << std::endl;
   }
 }
 
 void QmitkSlicesInterpolator::OnInterpolationActivated(bool on)
 {
   m_2DInterpolationEnabled = on;
 
   try
   {
     if ( m_DataStorage.IsNotNull() )
     {
       if (on && !m_DataStorage->Exists(m_FeedbackNode))
       {
         m_DataStorage->Add( m_FeedbackNode );
       }
       //else
       //{
       //  m_DataStorage->Remove( m_FeedbackNode );
       //}
     }
   }
   catch(...)
   {
     // don't care (double add/remove)
   }
 
   if (m_ToolManager)
   {
     mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
     mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
     QWidget::setEnabled( workingNode != NULL );
 
     m_BtnAcceptAllInterpolations->setEnabled( on );
     m_BtnAcceptInterpolation->setEnabled( on );
     m_FeedbackNode->SetVisibility( on );
 
     if (!on)
     {
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       return;
     }
 
     if (workingNode)
     {
       mitk::Image* segmentation = dynamic_cast<mitk::Image*>(workingNode->GetData());
       if (segmentation)
       {
         m_Interpolator->SetSegmentationVolume( segmentation );
 
         if (referenceNode)
         {
           mitk::Image* referenceImage = dynamic_cast<mitk::Image*>(referenceNode->GetData());
           m_Interpolator->SetReferenceVolume( referenceImage ); // may be NULL
         }
       }
     }
   }
 
   UpdateVisibleSuggestion();
 }
 
 void QmitkSlicesInterpolator::Run3DInterpolation()
 {
   m_SurfaceInterpolator->Interpolate();
 }
 
 void QmitkSlicesInterpolator::StartUpdateInterpolationTimer()
 {
   m_Timer->start(500);
 }
 
 void QmitkSlicesInterpolator::StopUpdateInterpolationTimer()
 {
   m_Timer->stop();
   m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(255.0,255.0,0.0));
   mitk::RenderingManager::GetInstance()->RequestUpdate(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetRenderWindow());
 }
 
 void QmitkSlicesInterpolator::ChangeSurfaceColor()
 {
   float currentColor[3];
   m_InterpolatedSurfaceNode->GetColor(currentColor);
 
   float yellow[3] = {255.0,255.0,0.0};
 
   if( currentColor[2] == yellow[2])
   {
     m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(255.0,255.0,255.0));
   }
   else
   {
     m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(yellow));
   }
   m_InterpolatedSurfaceNode->Update();
   mitk::RenderingManager::GetInstance()->RequestUpdate(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetRenderWindow());
 }
 
 void QmitkSlicesInterpolator::On3DInterpolationActivated(bool on)
 {
   m_3DInterpolationEnabled = on;
 
   try
   {
     if ( m_DataStorage.IsNotNull() && m_ToolManager && m_3DInterpolationEnabled)
     {
       mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
 
       if (workingNode)
       {
         bool isInterpolationResult(false);
         workingNode->GetBoolProperty("3DInterpolationResult",isInterpolationResult);
 
         if ((workingNode->IsSelected() &&
              workingNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")))) &&
             !isInterpolationResult && m_3DInterpolationEnabled)
         {
           int ret = QMessageBox::Yes;
 
           if (m_SurfaceInterpolator->EstimatePortionOfNeededMemory() > 0.5)
           {
             QMessageBox msgBox;
             msgBox.setText("Due to short handed system memory the 3D interpolation may be very slow!");
             msgBox.setInformativeText("Are you sure you want to activate the 3D interpolation?");
             msgBox.setStandardButtons(QMessageBox::No | QMessageBox::Yes);
             ret = msgBox.exec();
           }
 
           if (m_Watcher.isRunning())
             m_Watcher.waitForFinished();
 
           if (ret == QMessageBox::Yes)
           {
             m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
             m_Watcher.setFuture(m_Future);
           }
           else
           {
             m_RBtnDisableInterpolation->toggle();
           }
         }
         else if (!m_3DInterpolationEnabled)
         {
           this->Show3DInterpolationResult(false);
           m_BtnAccept3DInterpolation->setEnabled(m_3DInterpolationEnabled);
         }
       }
       else
       {
         QWidget::setEnabled( false );
         m_CbShowMarkers->setEnabled(m_3DInterpolationEnabled);
       }
     }
+    if (!m_3DInterpolationEnabled)
+    {
+       this->Show3DInterpolationResult(false);
+       m_BtnAccept3DInterpolation->setEnabled(m_3DInterpolationEnabled);
+    }
   }
   catch(...)
   {
     MITK_ERROR<<"Error with 3D surface interpolation!";
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSlicesInterpolator::EnableInterpolation(bool on)
 {
   // only to be called from the outside world
   // just a redirection to OnInterpolationActivated
   OnInterpolationActivated(on);
 }
 
 void QmitkSlicesInterpolator::Enable3DInterpolation(bool on)
 {
   // only to be called from the outside world
   // just a redirection to OnInterpolationActivated
   On3DInterpolationActivated(on);
 }
 
 void QmitkSlicesInterpolator::UpdateVisibleSuggestion()
 {
   if (m_2DInterpolationEnabled)
   {
     // determine which one is the current view, try to do an initial interpolation
     mitk::BaseRenderer* renderer = mitk::GlobalInteraction::GetInstance()->GetFocus();
     if (renderer && renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
     {
       const mitk::TimeSlicedGeometry* timeSlicedGeometry = dynamic_cast<const mitk::TimeSlicedGeometry*>( renderer->GetWorldGeometry() );
       if (timeSlicedGeometry)
       {
         mitk::SliceNavigationController::GeometrySliceEvent event( const_cast<mitk::TimeSlicedGeometry*>(timeSlicedGeometry), renderer->GetSlice() );
 
         if ( renderer->GetCurrentWorldGeometry2DNode() )
         {
           if ( renderer->GetCurrentWorldGeometry2DNode()==this->m_MultiWidget->GetWidgetPlane1() )
           {
             TranslateAndInterpolateChangedSlice( event, 2 );
           }
           else if ( renderer->GetCurrentWorldGeometry2DNode()==this->m_MultiWidget->GetWidgetPlane2() )
           {
             TranslateAndInterpolateChangedSlice( event, 0 );
           }
           else if ( renderer->GetCurrentWorldGeometry2DNode()==this->m_MultiWidget->GetWidgetPlane3() )
           {
             TranslateAndInterpolateChangedSlice( event, 1 );
           }
         }
       }
     }
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSlicesInterpolator::OnInterpolationInfoChanged(const itk::EventObject& /*e*/)
 {
   // something (e.g. undo) changed the interpolation info, we should refresh our display
   UpdateVisibleSuggestion();
 }
 
 void QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged(const itk::EventObject& /*e*/)
 {
   if(m_3DInterpolationEnabled)
   {
     if (m_Watcher.isRunning())
       m_Watcher.waitForFinished();
     m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
     m_Watcher.setFuture(m_Future);
   }
 }
 
 bool QmitkSlicesInterpolator::GetSliceForWindowsID(unsigned windowID, int& sliceDimension, int& sliceIndex)
 {
   mitk::BaseRenderer* renderer(NULL);
 
   // find sliceDimension for windowID:
   //   windowID 2: axial window = renderWindow1
   //   windowID 1: frontal window = renderWindow3
   //   windowID 0: sagittal window = renderWindow2
   if ( m_MultiWidget )
   {
     switch (windowID)
     {
     case 2:
     default:
       renderer = m_MultiWidget->mitkWidget1->GetRenderer();
       break;
     case 1:
       renderer = m_MultiWidget->mitkWidget3->GetRenderer();
       break;
     case 0:
       renderer = m_MultiWidget->mitkWidget2->GetRenderer();
       break;
     }
   }
 
   if ( m_Segmentation && renderer && renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
   {
     const mitk::TimeSlicedGeometry* timeSlicedGeometry = dynamic_cast<const mitk::TimeSlicedGeometry*>( renderer->GetWorldGeometry() );
     if (timeSlicedGeometry)
     {
       mitk::SlicedGeometry3D* slicedGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(timeSlicedGeometry->GetGeometry3D(m_TimeStep[windowID]));
       if (slicedGeometry)
       {
         mitk::PlaneGeometry* plane = dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry->GetGeometry2D( renderer->GetSlice() ));
         Interpolate( plane, m_TimeStep[windowID] );
         return mitk::SegTool2D::DetermineAffectedImageSlice( m_Segmentation, plane, sliceDimension, sliceIndex );
       }
     }
   }
 
   return false;
 }
 
 void QmitkSlicesInterpolator::OnMultiWidgetDeleted(QObject*)
 {
   if (m_MultiWidget)
   {
     m_MultiWidget = NULL;
   }
 }
 
 void QmitkSlicesInterpolator:: SetCurrentContourListID()
 {
   if ( m_DataStorage.IsNotNull() && m_ToolManager )
   {
     mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
 
     if (workingNode)
     {
       int listID;
       bool isInterpolationResult(false);
       workingNode->GetBoolProperty("3DInterpolationResult",isInterpolationResult);
 
       if ((workingNode->IsSelected() &&
            workingNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")))) &&
           !isInterpolationResult)
       {
         QWidget::setEnabled( true );
         if (workingNode->GetIntProperty("3DInterpolationListID", listID))
         {
           m_SurfaceInterpolator->SetCurrentListID(listID);
         }
         else
         {
           listID = m_SurfaceInterpolator->CreateNewContourList();
           workingNode->SetIntProperty("3DInterpolationListID", listID);
           this->Show3DInterpolationResult(false);
           m_BtnAccept3DInterpolation->setEnabled(false);
         }
 
         mitk::Vector3D spacing = workingNode->GetData()->GetGeometry( m_MultiWidget->GetRenderWindow3()->GetRenderer()->GetTimeStep() )->GetSpacing();
         double minSpacing (100);
         double maxSpacing (0);
         for (int i =0; i < 3; i++)
         {
           if (spacing[i] < minSpacing)
           {
             minSpacing = spacing[i];
           }
           else if (spacing[i] > maxSpacing)
           {
             maxSpacing = spacing[i];
           }
         }
 
         m_SurfaceInterpolator->SetWorkingImage(dynamic_cast<mitk::Image*>(workingNode->GetData()));
         m_SurfaceInterpolator->SetMaxSpacing(maxSpacing);
         m_SurfaceInterpolator->SetMinSpacing(minSpacing);
         m_SurfaceInterpolator->SetDistanceImageVolume(50000);
       }
     }
   }
 }
 
 void QmitkSlicesInterpolator::Show3DInterpolationResult(bool status)
 {
-  m_InterpolatedSurfaceNode->SetVisibility(status);
-  m_3DContourNode->SetVisibility(status, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
+   if (m_InterpolatedSurfaceNode.IsNotNull())
+      m_InterpolatedSurfaceNode->SetVisibility(status);
+
+   if (m_3DContourNode.IsNotNull())
+      m_3DContourNode->SetVisibility(status, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
 }
diff --git a/Modules/QmitkExt/QmitkTransferFunctionGeneratorWidget.ui b/Modules/QmitkExt/QmitkTransferFunctionGeneratorWidget.ui
index 27bade05b2..ac793cfc1b 100644
--- a/Modules/QmitkExt/QmitkTransferFunctionGeneratorWidget.ui
+++ b/Modules/QmitkExt/QmitkTransferFunctionGeneratorWidget.ui
@@ -1,427 +1,422 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkTransferFunctionGeneratorWidget</class>
  <widget class="QWidget" name="QmitkTransferFunctionGeneratorWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>349</width>
     <height>316</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
     <horstretch>1</horstretch>
     <verstretch>1</verstretch>
    </sizepolicy>
   </property>
   <property name="maximumSize">
    <size>
     <width>16777215</width>
     <height>16777215</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QHBoxLayout" name="horizontalLayout_4">
    <property name="margin">
     <number>0</number>
    </property>
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="sizePolicy">
       <sizepolicy hsizetype="MinimumExpanding" vsizetype="Maximum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>0</height>
       </size>
      </property>
      <property name="maximumSize">
       <size>
        <width>16777215</width>
        <height>120</height>
       </size>
      </property>
      <property name="toolTip">
       <string/>
      </property>
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="m_PresetTab">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <attribute name="title">
        <string>Presets</string>
       </attribute>
       <attribute name="toolTip">
        <string notr="true">Apply internal MITK transferfunction presets.
 Or save and load your own created transferfunctions in a folder in XML format.</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_3">
        <item>
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>0</height>
           </size>
          </property>
         </spacer>
        </item>
        <item>
         <widget class="QComboBox" name="m_TransferFunctionComboBox">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>0</height>
           </size>
          </property>
          <property name="toolTip">
           <string>Choose one of generic MITK internal presets to apply on standard CT data or MR data.</string>
          </property>
          <property name="statusTip">
           <string>Load a MITK internal preset</string>
          </property>
          <property name="currentIndex">
           <number>-1</number>
          </property>
          <property name="iconSize">
           <size>
            <width>16</width>
            <height>16</height>
           </size>
          </property>
          <property name="duplicatesEnabled">
           <bool>false</bool>
          </property>
          <property name="frame">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_3">
          <item>
           <widget class="QLabel" name="m_InfoPreset">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>1</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>0</width>
              <height>0</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>16777215</width>
              <height>25</height>
             </size>
            </property>
-           <property name="font">
-            <font>
-             <pointsize>7</pointsize>
-            </font>
-           </property>
            <property name="text">
             <string/>
            </property>
            <property name="textFormat">
             <enum>Qt::AutoText</enum>
            </property>
            <property name="alignment">
             <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
            </property>
            <property name="wordWrap">
             <bool>true</bool>
            </property>
            <property name="indent">
             <number>0</number>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="m_LoadPreset">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Maximum" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="maximumSize">
             <size>
              <width>64</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Load a transferfunction in xml-format from the filesystem.
 The load includes all transferfunctions: grayvalue, color and gradient.</string>
            </property>
            <property name="text">
             <string>Load</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="m_SavePreset">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Maximum" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="maximumSize">
             <size>
              <width>64</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Save a transferfunction in xml-format in the filesystem.
 The save includes all transferfunctions: grayvalue, color and gradient.</string>
            </property>
            <property name="text">
             <string>Save</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="m_ThresholdTab">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <attribute name="title">
        <string>Threshold</string>
       </attribute>
       <attribute name="toolTip">
        <string>Generate a threshold transfer function interactively.
 Click on the cross and move the mouse.
 With a vertical move the function will be steeper or flatter.
 With a horizontal move the center of the function left or right.</string>
       </attribute>
       <layout class="QHBoxLayout" name="horizontalLayout">
        <item>
         <widget class="QmitkCrossWidget" name="m_CrossThreshold">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>0</height>
           </size>
          </property>
          <property name="maximumSize">
           <size>
            <width>48</width>
            <height>48</height>
           </size>
          </property>
          <property name="toolTip">
           <string>Click and hold left mouse button on the cross.
 Move the mouse to the top and the function will be flatter.
 Move the mouse to the  bottom and the function will be steeper.
 Move the mouse to the left and the function moves to the left.
 Move the mouse to the right and the function moves to the right. </string>
          </property>
          <property name="layoutDirection">
           <enum>Qt::LeftToRight</enum>
          </property>
          <property name="text">
           <string/>
          </property>
          <property name="pixmap">
           <pixmap resource="resources/QmitkResources.qrc">:/qmitk/cross.png</pixmap>
          </property>
          <property name="scaledContents">
           <bool>true</bool>
          </property>
          <property name="alignment">
           <set>Qt::AlignCenter</set>
          </property>
          <property name="indent">
           <number>-1</number>
          </property>
          <property name="textInteractionFlags">
           <set>Qt::NoTextInteraction</set>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="m_InfoThreshold">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>0</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>7</pointsize>
           </font>
          </property>
          <property name="text">
           <string>Click and hold left mouse button on the cross to interactively generate a threshold transferfunction</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
          </property>
          <property name="wordWrap">
           <bool>true</bool>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="m_BellTab">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <attribute name="title">
        <string>Bell</string>
       </attribute>
       <attribute name="toolTip">
        <string>Generate a bell transfer function interactively.
 Click on the cross and move the mouse.
 With a vertical move the bell will be narrower or wider.
 With a horizontal move the center of the bell moves to the left or right.</string>
       </attribute>
       <layout class="QHBoxLayout" name="horizontalLayout_2">
        <item>
         <widget class="QmitkCrossWidget" name="m_CrossLevelWindow">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>0</height>
           </size>
          </property>
          <property name="maximumSize">
           <size>
            <width>48</width>
            <height>48</height>
           </size>
          </property>
          <property name="toolTip">
           <string>Click and hold left mouse button on the cross.
 Move the mouse to the top and the bell will be wider.
 Move the mouse to the  bottom and the bell will be flattened.
 Move the mouse to the left and the center of the bell moves to the left.
 Move the mouse to the  right and the center of the bell moves to the right.</string>
          </property>
          <property name="text">
           <string/>
          </property>
          <property name="pixmap">
           <pixmap resource="resources/QmitkResources.qrc">:/qmitk/cross.png</pixmap>
          </property>
          <property name="scaledContents">
           <bool>true</bool>
          </property>
          <property name="alignment">
           <set>Qt::AlignCenter</set>
          </property>
          <property name="textInteractionFlags">
           <set>Qt::NoTextInteraction</set>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="m_InfoLevelWindow">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>0</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>7</pointsize>
           </font>
          </property>
          <property name="text">
           <string>Click and hold left mouse button on the cross to interactively generate a bell transferfunction</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
          </property>
          <property name="wordWrap">
           <bool>true</bool>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkCrossWidget</class>
    <extends>QLabel</extends>
    <header location="global">QmitkCrossWidget.h</header>
   </customwidget>
  </customwidgets>
  <resources>
   <include location="resources/QmitkResources.qrc"/>
  </resources>
  <connections/>
 </ui>
diff --git a/Modules/QmitkExt/QmitkTransferFunctionWidget.ui b/Modules/QmitkExt/QmitkTransferFunctionWidget.ui
index 408efa83da..dc252e2c8a 100755
--- a/Modules/QmitkExt/QmitkTransferFunctionWidget.ui
+++ b/Modules/QmitkExt/QmitkTransferFunctionWidget.ui
@@ -1,507 +1,482 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkTransferFunctionWidget</class>
  <widget class="QWidget" name="QmitkTransferFunctionWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>300</width>
     <height>542</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Expanding" vsizetype="MinimumExpanding">
     <horstretch>1</horstretch>
     <verstretch>1</verstretch>
    </sizepolicy>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="margin">
     <number>0</number>
    </property>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QmitkFloatingPointSpanSlider" name="m_RangeSlider">
        <property name="toolTip">
         <string>modify actual seen window by dragging left and right slider. </string>
        </property>
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="m_RangeSliderReset">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="maximumSize">
         <size>
          <width>48</width>
          <height>16777215</height>
         </size>
        </property>
        <property name="toolTip">
         <string>Resets range to histogram minimum and maximum.</string>
        </property>
        <property name="text">
         <string>Reset</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QWidget" name="m_ScalarOpacityWidget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>3</verstretch>
       </sizepolicy>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <property name="margin">
        <number>0</number>
       </property>
       <item>
        <widget class="QmitkPiecewiseFunctionCanvas" name="m_ScalarOpacityFunctionCanvas" native="true">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
           <horstretch>0</horstretch>
           <verstretch>1</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>64</height>
          </size>
         </property>
         <property name="font">
          <font/>
         </property>
         <property name="toolTip">
          <string>Left-click to select a point or add a new point.
  Hold left mouse button to move selected point.
 Click right mouse button to delete a point.</string>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout">
         <item>
          <widget class="QLineEdit" name="m_XEditScalarOpacity">
           <property name="enabled">
            <bool>true</bool>
           </property>
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>48</width>
             <height>0</height>
            </size>
           </property>
           <property name="maximumSize">
            <size>
             <width>48</width>
             <height>16777215</height>
            </size>
           </property>
-          <property name="font">
-           <font>
-            <pointsize>7</pointsize>
-           </font>
-          </property>
           <property name="toolTip">
            <string>Edit x-coordinate (grayvalue) of currently selected point.</string>
           </property>
           <property name="text">
            <string/>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLabel" name="m_textLabelX">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="font">
            <font/>
           </property>
           <property name="toolTip">
            <string>Edit x-coordinate (grayvalue) of currently selected point.</string>
           </property>
           <property name="text">
            <string>Grayvalue</string>
           </property>
           <property name="wordWrap">
            <bool>false</bool>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLabel" name="m_textLabelY">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="font">
            <font/>
           </property>
           <property name="toolTip">
            <string>Edit y-coordinate (opacity) of currently selected point.</string>
           </property>
           <property name="text">
            <string>Opacity</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
           <property name="wordWrap">
            <bool>false</bool>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLineEdit" name="m_YEditScalarOpacity">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>48</width>
             <height>0</height>
            </size>
           </property>
           <property name="maximumSize">
            <size>
             <width>48</width>
             <height>16777215</height>
            </size>
           </property>
-          <property name="font">
-           <font>
-            <pointsize>7</pointsize>
-           </font>
-          </property>
           <property name="toolTip">
            <string>Edit y-coordinate (opacity) of currently selected point.</string>
           </property>
           <property name="text">
            <string/>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QWidget" name="m_ColorWidget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_3">
       <property name="margin">
        <number>0</number>
       </property>
       <item>
        <widget class="QmitkColorTransferFunctionCanvas" name="m_ColorTransferFunctionCanvas" native="true">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>1</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>48</height>
          </size>
         </property>
         <property name="font">
          <font/>
         </property>
         <property name="toolTip">
          <string>Left-click to select a point or add a new point.
  Hold left mouse button to move selected point.
 Click right mouse button to delete a point.
 Double-click left mouse button to change color of a point.</string>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout">
         <item>
          <widget class="QLineEdit" name="m_XEditColor">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>48</width>
             <height>0</height>
            </size>
           </property>
           <property name="maximumSize">
            <size>
             <width>48</width>
             <height>16777215</height>
            </size>
           </property>
-          <property name="font">
-           <font>
-            <pointsize>7</pointsize>
-           </font>
-          </property>
           <property name="toolTip">
            <string>Edit x-coordinate (grayvalue) of currently selected point.</string>
           </property>
           <property name="text">
            <string/>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLabel" name="m_textLabelX_3">
           <property name="font">
            <font/>
           </property>
           <property name="toolTip">
            <string>Edit x-coordinate (grayvalue) of currently selected point.</string>
           </property>
           <property name="text">
            <string>Grayvalue</string>
           </property>
           <property name="wordWrap">
            <bool>false</bool>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QWidget" name="m_GradientOpacityWidget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>2</verstretch>
       </sizepolicy>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_4">
       <property name="margin">
        <number>0</number>
       </property>
       <item>
        <widget class="QmitkPiecewiseFunctionCanvas" name="m_GradientOpacityCanvas" native="true">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
           <horstretch>0</horstretch>
           <verstretch>1</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>64</height>
          </size>
         </property>
         <property name="font">
          <font/>
         </property>
         <property name="toolTip">
          <string>Left-click to select a point or add a new point.
  Hold left mouse button to move selected point.
 Click right mouse button to delete a point.</string>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout">
         <item>
          <widget class="QLineEdit" name="m_XEditGradientOpacity">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>48</width>
             <height>0</height>
            </size>
           </property>
           <property name="maximumSize">
            <size>
             <width>48</width>
             <height>16777215</height>
            </size>
           </property>
-          <property name="font">
-           <font>
-            <pointsize>7</pointsize>
-           </font>
-          </property>
           <property name="toolTip">
            <string>Edit x-coordinate (grayvalue) of currently selected point.</string>
           </property>
           <property name="text">
            <string/>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLabel" name="m_textLabelX_2">
           <property name="font">
            <font/>
           </property>
           <property name="toolTip">
            <string>Edit x-coordinate (grayvalue) of currently selected point.</string>
           </property>
           <property name="text">
            <string>Grayvalue</string>
           </property>
           <property name="wordWrap">
            <bool>false</bool>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLabel" name="m_textLabelY_2">
           <property name="font">
            <font/>
           </property>
           <property name="toolTip">
            <string>Edit y-coordinate (opacity) of currently selected point.</string>
           </property>
           <property name="text">
            <string>Opacity</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
           <property name="wordWrap">
            <bool>false</bool>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLineEdit" name="m_YEditGradientOpacity">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>48</width>
             <height>0</height>
            </size>
           </property>
           <property name="maximumSize">
            <size>
             <width>48</width>
             <height>16777215</height>
            </size>
           </property>
-          <property name="font">
-           <font>
-            <pointsize>7</pointsize>
-           </font>
-          </property>
           <property name="toolTip">
            <string>Edit y-coordinate (opacity) of currently selected point.</string>
           </property>
           <property name="text">
            <string/>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>0</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkPiecewiseFunctionCanvas</class>
    <extends>QWidget</extends>
    <header>QmitkPiecewiseFunctionCanvas.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkColorTransferFunctionCanvas</class>
    <extends>QWidget</extends>
    <header>QmitkColorTransferFunctionCanvas.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkFloatingPointSpanSlider</class>
    <extends>QSlider</extends>
    <header location="global">QmitkFloatingPointSpanSlider.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/Modules/SceneSerialization/mitkSceneReaderV1.cpp b/Modules/SceneSerialization/mitkSceneReaderV1.cpp
index 1a9b31aa96..b785d71534 100644
--- a/Modules/SceneSerialization/mitkSceneReaderV1.cpp
+++ b/Modules/SceneSerialization/mitkSceneReaderV1.cpp
@@ -1,320 +1,327 @@
 /*===================================================================
 
 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 "mitkSceneReaderV1.h"
 #include "mitkSerializerMacros.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkBaseRenderer.h"
 #include "mitkPropertyListDeserializer.h"
 #include "mitkProgressBar.h"
 #include "Poco/Path.h"
 
 MITK_REGISTER_SERIALIZER(SceneReaderV1)
     
 bool mitk::SceneReaderV1::LoadScene( TiXmlDocument& document, const std::string& workingDirectory, DataStorage* storage )
 {
   assert(storage);
   bool error(false);
 
   // TODO prepare to detect errors (such as cycles) from wrongly written or edited xml files
 
   //Get number of elements to initialze progress bar
   unsigned int listSize = 0;
   for( TiXmlElement* element = document.FirstChildElement("node"); element != NULL; element = element->NextSiblingElement("node") )
   {
     ++listSize;
   }
 
   ProgressBar::GetInstance()->AddStepsToDo( listSize ); 
 
   // iterate all nodes
   // first level nodes should be <node> elements
   for( TiXmlElement* element = document.FirstChildElement("node"); element != NULL; element = element->NextSiblingElement("node") )
   {
     //   1. if there is a <data type="..." file="..."> element,
     //        - construct a name for the appropriate serializer
     //        - try to instantiate this serializer via itk object factory
     //        - if serializer could be created, use it to read the file into a BaseData object
     //        - if successful, call the new node's SetData(..)
     DataNode::Pointer node = LoadBaseDataFromDataTag( element->FirstChildElement("data"), workingDirectory, error );
 
     // create a node for the tag "data" and test if node was created
     // in case dataXmlElement is valid test whether it containts the "properties" child tag
     // and process further if and only if yes
     TiXmlElement *dataXmlElement = element->FirstChildElement("data");
     if( dataXmlElement && dataXmlElement->FirstChildElement("properties") )
     {
       TiXmlElement *baseDataElement = dataXmlElement->FirstChildElement("properties");
-      DecorateBaseDataWithProperties( node->GetData(), baseDataElement, workingDirectory);
+      if ( node->GetData() )
+      {
+        DecorateBaseDataWithProperties( node->GetData(), baseDataElement, workingDirectory);
+      }
+      else
+      {
+        MITK_WARN << "BaseData properties stored in scene file, but BaseData can't be read" << std::endl;
+      }
     }
 
     //   2. check child nodes
     const char* uida = element->Attribute("UID");
     std::string uid("");
 
     if (uida)
     {
       uid = uida;
       m_NodeForID[uid] = node.GetPointer();
       m_IDForNode[ node.GetPointer() ] = uid;
     }
     else
     {
       MITK_ERROR << "No UID found for current node. Node will have no parents.";
       error = true;
     }
 
     // remember node for later adding to DataStorage
     m_Nodes.insert( std::make_pair( node, std::list<std::string>() ) );
 
     //   3. if there are <source> elements, remember parent objects
     for( TiXmlElement* source = element->FirstChildElement("source"); source != NULL; source = source->NextSiblingElement("source") )
     {
       const char* sourceUID = source->Attribute("UID");
       if (sourceUID)
       {
         m_Nodes[node].push_back( std::string(sourceUID) );
       }
     }
 
 
     //   5. if there are <properties> nodes, 
     //        - instantiate the appropriate PropertyListDeSerializer
     //        - use them to construct PropertyList objects
     //        - add these properties to the node (if necessary, use renderwindow name)
     bool success = DecorateNodeWithProperties(node, element, workingDirectory);
     if (!success)
     {
       MITK_ERROR << "Could not load properties for node.";
       error = true;
     }
 
     ProgressBar::GetInstance()->Progress();
 
   } // end for all <node>
     
   // remove all unknown parent UIDs
   for (NodesAndParentsMapType::iterator nodesIter = m_Nodes.begin();
        nodesIter != m_Nodes.end();
        ++nodesIter)
   {
     for (std::list<std::string>::iterator parentsIter = nodesIter->second.begin();
          parentsIter != nodesIter->second.end();)
     {
       if (m_NodeForID.find( *parentsIter ) == m_NodeForID.end())
       {
         parentsIter = nodesIter->second.erase( parentsIter );
         MITK_WARN << "Found a DataNode with unknown parents. Will add it to DataStorage without any parent objects.";
         error = true;
       }
       else
       {
         ++parentsIter;
       }
     }
   }
 
   // repeat
   //   for all created nodes
   unsigned int lastMapSize(0);
   while ( lastMapSize != m_Nodes.size()) // this is to prevent infinite loops; each iteration must at least add one node to DataStorage
   {
     lastMapSize = m_Nodes.size();
 
     for (NodesAndParentsMapType::iterator nodesIter = m_Nodes.begin();
          nodesIter != m_Nodes.end();
          ++nodesIter)
     {
       bool addNow(true);
       // if any parent node is not yet in DataStorage, skip node for now and check later
       for (std::list<std::string>::iterator parentsIter = nodesIter->second.begin();
            parentsIter != nodesIter->second.end();
            ++parentsIter)
       {
         if ( !storage->Exists( m_NodeForID[ *parentsIter ] ) )
         {
           addNow = false;
           break;
         }
       }
       
       if (addNow)
       {
         DataStorage::SetOfObjects::Pointer parents = DataStorage::SetOfObjects::New();
         for (std::list<std::string>::iterator parentsIter = nodesIter->second.begin();
              parentsIter != nodesIter->second.end();
              ++parentsIter)
         {
           parents->push_back( m_NodeForID[ *parentsIter ] );
         }
    
         // if all parents are found in datastorage (or are unknown), add node to DataStorage
         storage->Add( nodesIter->first, parents );
 
         // remove this node from m_Nodes
         m_Nodes.erase( nodesIter );
 
         // break this for loop because iterators are probably invalid
         break;
       }
     }
   }
 
   // All nodes that are still in m_Nodes at this point are not part of a proper directed graph structure. We'll add such nodes without any parent information.
   for (NodesAndParentsMapType::iterator nodesIter = m_Nodes.begin();
        nodesIter != m_Nodes.end();
        ++nodesIter)
   {
     storage->Add( nodesIter->first );
     MITK_WARN << "Encountered node that is not part of a directed graph structure. Will be added to DataStorage without parents.";
     error = true;
   }
 
   return !error;
 }
 
 mitk::DataNode::Pointer mitk::SceneReaderV1::LoadBaseDataFromDataTag( TiXmlElement* dataElement, const std::string& workingDirectory, bool& error )
 {
   DataNode::Pointer node;
 
   if (dataElement) 
   {
     const char* filename( dataElement->Attribute("file") );
     if ( filename )
     {
       DataNodeFactory::Pointer factory = DataNodeFactory::New();
       factory->SetFileName( workingDirectory + Poco::Path::separator() + filename );
       
       try
       {
         factory->Update();
         node = factory->GetOutput();
       }
       catch (std::exception& e)
       {
         MITK_ERROR << "Error during attempt to read '" << filename << "'. Exception says: " << e.what();
         error = true;
       }
 
       if (node.IsNull())
       {
         MITK_ERROR << "Error during attempt to read '" << filename << "'. Factory returned NULL object.";
         error = true;
       }
     }
   }
 
   // in case there was no <data> element we create a new empty node (for appending a propertylist later)
   if (node.IsNull())
   {
     node = DataNode::New();
   }
 
   return node;
 }
 
 bool mitk::SceneReaderV1::DecorateNodeWithProperties(DataNode* node, TiXmlElement* nodeElement, const std::string& workingDirectory)
 {
   assert(node);
   assert(nodeElement);
   bool error(false);
 
   for( TiXmlElement* properties = nodeElement->FirstChildElement("properties"); properties != NULL; properties = properties->NextSiblingElement("properties") )
   {
     const char* propertiesfilea( properties->Attribute("file") );
     std::string propertiesfile( propertiesfilea ? propertiesfilea : "" );
     
     const char* renderwindowa( properties->Attribute("renderwindow") );
     std::string renderwindow( renderwindowa ? renderwindowa : "" );
 
     BaseRenderer* renderer = BaseRenderer::GetByName( renderwindow );
     if (renderer || renderwindow.empty())
     {
       PropertyList::Pointer propertyList = node->GetPropertyList(renderer); // DataNode implementation always returns a propertylist
       // clear all properties from node that might be set by DataNodeFactory during loading 
       propertyList->Clear();
 
       // use deserializer to construct new properties
       PropertyListDeserializer::Pointer deserializer = PropertyListDeserializer::New();
       
       deserializer->SetFilename(workingDirectory + Poco::Path::separator() + propertiesfile);
       bool success = deserializer->Deserialize();
       error |= !success;
       PropertyList::Pointer readProperties = deserializer->GetOutput();
 
       if (readProperties.IsNotNull())
       {
         propertyList->ConcatenatePropertyList( readProperties, true ); // true = replace
       }
       else
       {
         MITK_ERROR << "Property list reader did not return a property list. This is an implementation error. Please tell your developer.";
         error = true;
       }
     }
     else
     {
       MITK_ERROR << "Found properties for renderer " << renderwindow << " but there is no such renderer in current application. Ignoring those properties";
       error = true;
     }
   }
 
   return !error;
 }
 
 bool mitk::SceneReaderV1::DecorateBaseDataWithProperties(BaseData::Pointer data, TiXmlElement *baseDataNodeElem, const std::string &workingDir)
 {
   // check given variables, initialize error variable
   assert(baseDataNodeElem);
   bool error(false);
 
   // get the file name stored in the <properties ...> tag
   const char* baseDataPropertyFile( baseDataNodeElem->Attribute("file") );
   // check if the filename was found
   if(baseDataPropertyFile)
   {
     //PropertyList::Pointer dataPropList = data->GetPropertyList();
 
     PropertyListDeserializer::Pointer propertyDeserializer = PropertyListDeserializer::New();
 
     // initialize the property reader
     propertyDeserializer->SetFilename(workingDir + Poco::Path::separator() + baseDataPropertyFile);
     bool ioSuccess = propertyDeserializer->Deserialize();
     error = !ioSuccess;
 
     // get the output
     PropertyList::Pointer inProperties = propertyDeserializer->GetOutput();
 
     // store the read-in properties to the given node or throw error otherwise
     if( inProperties.IsNotNull() )
     {
       data->SetPropertyList( inProperties );
     }
     else
     {
       MITK_ERROR << "The property deserializer did not return a (valid) property list.";
       error = true;
     }
   }
   else
   {
     MITK_ERROR << "Function DecorateBaseDataWithProperties(...) called with false TiXmlElement. \n \t ->Given element does not contain a 'file' attribute. \n";
     error = true;
   }
 
   return !error;
 }
 
diff --git a/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.cpp b/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.cpp
index 9a42bac728..3556014474 100644
--- a/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.cpp
+++ b/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.cpp
@@ -1,246 +1,252 @@
 /*===================================================================
 
 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 "mitkSurfaceInterpolationController.h"
 #include "mitkMemoryUtilities.h"
 
 mitk::SurfaceInterpolationController::SurfaceInterpolationController()
 : m_CurrentContourListID (0)
 {
   m_ReduceFilter = ReduceContourSetFilter::New();
   m_NormalsFilter = ComputeContourSetNormalsFilter::New();
   m_InterpolateSurfaceFilter = CreateDistanceImageFromSurfaceFilter::New();
 
-  m_ReduceFilter->SetUseProgressBar(true);
-  m_NormalsFilter->SetUseProgressBar(true);
-  m_InterpolateSurfaceFilter->SetUseProgressBar(true);
+  m_ReduceFilter->SetUseProgressBar(false);
+  m_NormalsFilter->SetUseProgressBar(false);
+  m_InterpolateSurfaceFilter->SetUseProgressBar(false);
 
   m_Contours = Surface::New();
 
   m_PolyData = vtkSmartPointer<vtkPolyData>::New();
   m_PolyData->SetPoints(vtkPoints::New());
 
   m_InterpolationResult = 0;
   m_CurrentNumberOfReducedContours = 0;
 }
 
 mitk::SurfaceInterpolationController::~SurfaceInterpolationController()
 {
   for (unsigned int i = 0; i < m_ListOfContourLists.size(); ++i)
   {
       for (unsigned int j = 0; j < m_ListOfContourLists.at(i).size(); ++j)
       {
           delete(m_ListOfContourLists.at(i).at(j).position);
       }
   }
 }
 
 mitk::SurfaceInterpolationController* mitk::SurfaceInterpolationController::GetInstance()
 {
   static mitk::SurfaceInterpolationController* m_Instance;
 
   if ( m_Instance == 0)
   {
     m_Instance = new SurfaceInterpolationController();
   }
 
   return m_Instance;
 }
 
 void mitk::SurfaceInterpolationController::AddNewContour (mitk::Surface::Pointer newContour ,RestorePlanePositionOperation* op)
 {
   AffineTransform3D::Pointer transform = AffineTransform3D::New();
   transform = op->GetTransform();
 
   mitk::Vector3D direction = op->GetDirectionVector();
   int pos (-1);
 
   for (unsigned int i = 0; i < m_ListOfContourLists.at(m_CurrentContourListID).size(); i++)
   {
       itk::Matrix<float> diffM = transform->GetMatrix()-m_ListOfContourLists.at(m_CurrentContourListID).at(i).position->GetTransform()->GetMatrix();
       bool isSameMatrix(true);
       for (unsigned int j = 0; j < 3; j++)
       {
         if (fabs(diffM[j][0]) > 0.0001 && fabs(diffM[j][1]) > 0.0001 && fabs(diffM[j][2]) > 0.0001)
         {
           isSameMatrix = false;
           break;
         }
       }
       itk::Vector<float> diffV = m_ListOfContourLists.at(m_CurrentContourListID).at(i).position->GetTransform()->GetOffset()-transform->GetOffset();
       if ( isSameMatrix && m_ListOfContourLists.at(m_CurrentContourListID).at(i).position->GetPos() == op->GetPos() && (fabs(diffV[0]) < 0.0001 && fabs(diffV[1]) < 0.0001 && fabs(diffV[2]) < 0.0001) )
       {
         pos = i;
         break;
       }
     
   }
 
   if (pos == -1)
   {
     //MITK_INFO<<"New Contour";
     mitk::RestorePlanePositionOperation* newOp = new mitk::RestorePlanePositionOperation (OpRESTOREPLANEPOSITION, op->GetWidth(), 
       op->GetHeight(), op->GetSpacing(), op->GetPos(), direction, transform);
     ContourPositionPair newData;
     newData.contour = newContour;
     newData.position = newOp;
 
     m_ReduceFilter->SetInput(m_ListOfContourLists.at(m_CurrentContourListID).size(), newContour);
     m_ListOfContourLists.at(m_CurrentContourListID).push_back(newData);
   }
   else
   {
     //MITK_INFO<<"Modified Contour";
     m_ListOfContourLists.at(m_CurrentContourListID).at(pos).contour = newContour;
     m_ReduceFilter->SetInput(pos, newContour);
   }
 
   m_ReduceFilter->Update();
   m_CurrentNumberOfReducedContours = m_ReduceFilter->GetNumberOfOutputs();
 
   for (unsigned int i = 0; i < m_CurrentNumberOfReducedContours; i++)
   {
     m_NormalsFilter->SetInput(i, m_ReduceFilter->GetOutput(i));
     m_InterpolateSurfaceFilter->SetInput(i, m_NormalsFilter->GetOutput(i));
   }
 
   this->Modified();
 }
 
 void mitk::SurfaceInterpolationController::Interpolate()
 {
   if (m_CurrentNumberOfReducedContours< 2)
     return;
 
   //Setting up progress bar
-  mitk::ProgressBar::GetInstance()->AddStepsToDo(8);
+   /*
+    * Removed due to bug 12441. ProgressBar messes around with Qt event queue which is fatal for segmentation
+    */
+  //mitk::ProgressBar::GetInstance()->AddStepsToDo(8);
 
   m_InterpolateSurfaceFilter->Update();
 
   Image::Pointer distanceImage = m_InterpolateSurfaceFilter->GetOutput();
 
   vtkSmartPointer<vtkMarchingCubes> mcFilter = vtkMarchingCubes::New();
   mcFilter->SetInput(distanceImage->GetVtkImageData());
   mcFilter->SetValue(0,0);
   mcFilter->Update();
 
   m_InterpolationResult = 0;
   m_InterpolationResult = mitk::Surface::New();
   m_InterpolationResult->SetVtkPolyData(mcFilter->GetOutput());
   m_InterpolationResult->GetGeometry()->SetOrigin(distanceImage->GetGeometry()->GetOrigin());
 
   vtkSmartPointer<vtkAppendPolyData> polyDataAppender = vtkSmartPointer<vtkAppendPolyData>::New();
   for (unsigned int i = 0; i < m_ReduceFilter->GetNumberOfOutputs(); i++)
   {
     polyDataAppender->AddInput(m_ReduceFilter->GetOutput(i)->GetVtkPolyData());
   }
   polyDataAppender->Update();
   m_Contours->SetVtkPolyData(polyDataAppender->GetOutput());
 
   //Last progress step
-  mitk::ProgressBar::GetInstance()->Progress(8);
+  /*
+   * Removed due to bug 12441. ProgressBar messes around with Qt event queue which is fatal for segmentation
+   */
+  //mitk::ProgressBar::GetInstance()->Progress(8);
 
   m_InterpolationResult->DisconnectPipeline();
 }
 
 mitk::Surface::Pointer mitk::SurfaceInterpolationController::GetInterpolationResult()
 {
     return m_InterpolationResult;
 }
 
 mitk::Surface* mitk::SurfaceInterpolationController::GetContoursAsSurface()
 {
   return m_Contours;
 }
 
 void mitk::SurfaceInterpolationController::SetDataStorage(DataStorage &ds)
 {
   m_DataStorage = &ds;
 }
 
 unsigned int mitk::SurfaceInterpolationController::CreateNewContourList()
 {
   unsigned int newID =  m_ListOfContourLists.size();
   ContourPositionPairList newList;
   m_ListOfContourLists.push_back(newList);
   this->SetCurrentListID(newID);
   m_InterpolationResult = 0;
   return m_CurrentContourListID;
 }
 
 void mitk::SurfaceInterpolationController::SetCurrentListID ( unsigned int ID )
 {
   if (ID == m_CurrentContourListID )
     return;
 
   m_CurrentContourListID = ID;
 
   m_ReduceFilter->Reset();
   m_NormalsFilter->Reset();
   m_InterpolateSurfaceFilter->Reset();
   
   for (unsigned int i = 0; i < m_ListOfContourLists.at(m_CurrentContourListID).size(); i++)
   {
     m_ReduceFilter->SetInput(i, m_ListOfContourLists.at(m_CurrentContourListID).at(i).contour);
 //    m_NormalsFilter->SetInput(i,m_ReduceFilter->GetOutput(i));
 //    m_InterpolateSurfaceFilter->SetInput(i,m_NormalsFilter->GetOutput(i));
   }
 
   m_ReduceFilter->Update();
 
   m_CurrentNumberOfReducedContours = m_ReduceFilter->GetNumberOfOutputs();
 
   for (unsigned int i = 0; i < m_CurrentNumberOfReducedContours; i++)
   {
     m_NormalsFilter->SetInput(i, m_ReduceFilter->GetOutput(i));
     m_InterpolateSurfaceFilter->SetInput(i, m_NormalsFilter->GetOutput(i));
   }
 }
 
 void mitk::SurfaceInterpolationController::SetMinSpacing(double minSpacing)
 {
   m_ReduceFilter->SetMinSpacing(minSpacing);
 }
 
 void mitk::SurfaceInterpolationController::SetMaxSpacing(double maxSpacing)
 {
   m_ReduceFilter->SetMaxSpacing(maxSpacing);
   m_NormalsFilter->SetMaxSpacing(maxSpacing);
 }
 
 void mitk::SurfaceInterpolationController::SetDistanceImageVolume(unsigned int distImgVolume)
 {
   m_InterpolateSurfaceFilter->SetDistanceImageVolume(distImgVolume);
 }
 
 void mitk::SurfaceInterpolationController::SetWorkingImage(Image* workingImage)
 {
   m_NormalsFilter->SetSegmentationBinaryImage(workingImage);
 }
 
 mitk::Image* mitk::SurfaceInterpolationController::GetImage()
 {
   return m_InterpolateSurfaceFilter->GetOutput();
 }
 
 double mitk::SurfaceInterpolationController::EstimatePortionOfNeededMemory()
 {
   double numberOfPointsAfterReduction = m_ReduceFilter->GetNumberOfPointsAfterReduction()*3;
   double sizeOfPoints = pow(numberOfPointsAfterReduction,2)*sizeof(double);
   double totalMem = mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
   double percentage = sizeOfPoints/totalMem;
   return percentage;
 }
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
index 6fa80d90bc..90ea19226a 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
@@ -1,347 +1,366 @@
 /*===================================================================
 
 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 "mitkSegTool2D.h"
 #include "mitkToolManager.h"
 
 #include "mitkDataStorage.h"
 #include "mitkBaseRenderer.h"
 
 #include "mitkPlaneGeometry.h"
 
 #include "mitkExtractImageFilter.h"
 #include "mitkExtractDirectedPlaneImageFilter.h"
 
 //Include of the new ImageExtractor
 #include "mitkExtractDirectedPlaneImageFilterNew.h"
 #include "mitkPlanarCircle.h"
 #include "mitkOverwriteSliceImageFilter.h"
 #include "mitkOverwriteDirectedPlaneImageFilter.h"
 
 #include "mitkGetModuleContext.h"
 
 //Includes for 3DSurfaceInterpolation
 #include "mitkImageToContourFilter.h"
 #include "mitkSurfaceInterpolationController.h"
 
 //includes for resling and overwriting
 #include <mitkExtractSliceFilter.h>
 #include <mitkVtkImageOverwrite.h>
 #include <vtkSmartPointer.h>
 #include <vtkImageData.h>
 
 #include <mitkDiffSliceOperationApplier.h>
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 
 #define ROUND(a)     ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 mitk::SegTool2D::SegTool2D(const char* type)
 :Tool(type),
  m_LastEventSender(NULL),
  m_LastEventSlice(0),
  m_Contourmarkername ("Position"),
  m_ShowMarkerNodes (true)
 {
 }
 
 mitk::SegTool2D::~SegTool2D()
 {
 }
 
 float mitk::SegTool2D::CanHandleEvent( StateEvent const *stateEvent) const
 {
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return 0.0;
 
   if ( positionEvent->GetSender()->GetMapperID() != BaseRenderer::Standard2D ) return 0.0; // we don't want anything but 2D
 
-  if( m_LastEventSender != positionEvent->GetSender()) return 0.0;
-  if( m_LastEventSlice != positionEvent->GetSender()->GetSlice() ) return 0.0;
-
-  return 1.0;
+  //This are the mouse event that are used by the statemachine patterns for zooming and panning. This must be possible although a tool is activ
+  if (stateEvent->GetId() == EIDRIGHTMOUSEBTN || stateEvent->GetId() == EIDMIDDLEMOUSEBTN || stateEvent->GetId() == EIDRIGHTMOUSEBTNANDCTRL ||
+      stateEvent->GetId() == EIDMIDDLEMOUSERELEASE || stateEvent->GetId() == EIDRIGHTMOUSERELEASE || stateEvent->GetId() == EIDRIGHTMOUSEBTNANDMOUSEMOVE ||
+      stateEvent->GetId() == EIDMIDDLEMOUSEBTNANDMOUSEMOVE || stateEvent->GetId() == EIDCTRLANDRIGHTMOUSEBTNANDMOUSEMOVE || stateEvent->GetId() == EIDCTRLANDRIGHTMOUSEBTNRELEASE )
+  {
+    //Since the usual segmentation tools currently do not need right click interaction but the mitkDisplayVectorInteractor
+    return 0.0;
+  }
+  else
+  {
+    return 1.0;
+  }
 }
 
 
 bool mitk::SegTool2D::DetermineAffectedImageSlice( const Image* image, const PlaneGeometry* plane, int& affectedDimension, int& affectedSlice )
 {
   assert(image);
   assert(plane);
 
   // compare normal of plane to the three axis vectors of the image
   Vector3D normal       = plane->GetNormal();
   Vector3D imageNormal0 = image->GetSlicedGeometry()->GetAxisVector(0);
   Vector3D imageNormal1 = image->GetSlicedGeometry()->GetAxisVector(1);
   Vector3D imageNormal2 = image->GetSlicedGeometry()->GetAxisVector(2);
 
   normal.Normalize();
   imageNormal0.Normalize();
   imageNormal1.Normalize();
   imageNormal2.Normalize();
 
   imageNormal0.Set_vnl_vector( vnl_cross_3d<ScalarType>(normal.Get_vnl_vector(),imageNormal0.Get_vnl_vector()) );
   imageNormal1.Set_vnl_vector( vnl_cross_3d<ScalarType>(normal.Get_vnl_vector(),imageNormal1.Get_vnl_vector()) );
   imageNormal2.Set_vnl_vector( vnl_cross_3d<ScalarType>(normal.Get_vnl_vector(),imageNormal2.Get_vnl_vector()) );
 
   double eps( 0.00001 );
   // axial
   if ( imageNormal2.GetNorm() <= eps )
   {
     affectedDimension = 2;
   }
   // sagittal
   else if ( imageNormal1.GetNorm() <= eps )
   {
     affectedDimension = 1;
   }
   // frontal
   else if ( imageNormal0.GetNorm() <= eps )
   {
     affectedDimension = 0;
   }
   else
   {
     affectedDimension = -1; // no idea
     return false;
   }
 
   // determine slice number in image
   Geometry3D* imageGeometry = image->GetGeometry(0);
   Point3D testPoint = imageGeometry->GetCenter();
   Point3D projectedPoint;
   plane->Project( testPoint, projectedPoint );
 
   Point3D indexPoint;
 
   imageGeometry->WorldToIndex( projectedPoint, indexPoint );
   affectedSlice = ROUND( indexPoint[affectedDimension] );
   MITK_DEBUG << "indexPoint " << indexPoint << " affectedDimension " << affectedDimension << " affectedSlice " << affectedSlice;
 
   // check if this index is still within the image
   if ( affectedSlice < 0 || affectedSlice >= static_cast<int>(image->GetDimension(affectedDimension)) ) return false;
 
   return true;
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PositionEvent* positionEvent, const Image* image)
 {
   if (!positionEvent) return NULL;
 
   assert( positionEvent->GetSender() ); // sure, right?
   unsigned int timeStep = positionEvent->GetSender()->GetTimeStep( image ); // get the timestep of the visible part (time-wise) of the image
 
   // first, we determine, which slice is affected
   const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
 
   if ( !image || !planeGeometry ) return NULL;
 
   //Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   //set to false to extract a slice
   reslice->SetOverwriteMode(false);
   reslice->Modified();
 
   //use ExtractSliceFilter with our specific vtkImageReslice for overwriting and extracting
   mitk::ExtractSliceFilter::Pointer extractor =  mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput( image );
   extractor->SetTimeStep( timeStep );
   extractor->SetWorldGeometry( planeGeometry );
   extractor->SetVtkOutputRequest(false);
   extractor->SetResliceTransformByGeometry( image->GetTimeSlicedGeometry()->GetGeometry3D( timeStep ) );
 
   extractor->Modified();
   extractor->Update();
 
   Image::Pointer slice = extractor->GetOutput();
 
   /*============= BEGIN undo feature block ========================*/
   //specify the undo operation with the non edited slice
   m_undoOperation = new DiffSliceOperation(const_cast<mitk::Image*>(image), extractor->GetVtkOutput(), slice->GetGeometry(), timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
   /*============= END undo feature block ========================*/
 
   return slice;
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedWorkingSlice(const PositionEvent* positionEvent)
 {
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   if ( !workingNode ) return NULL;
 
   Image* workingImage = dynamic_cast<Image*>(workingNode->GetData());
   if ( !workingImage ) return NULL;
 
   return GetAffectedImageSliceAs2DImage( positionEvent, workingImage );
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const PositionEvent* positionEvent)
 {
   DataNode* referenceNode( m_ToolManager->GetReferenceData(0) );
   if ( !referenceNode ) return NULL;
 
   Image* referenceImage = dynamic_cast<Image*>(referenceNode->GetData());
   if ( !referenceImage ) return NULL;
 
   return GetAffectedImageSliceAs2DImage( positionEvent, referenceImage );
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResult (const PositionEvent* positionEvent, Image* slice)
 {
   const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
 
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   Image* image = dynamic_cast<Image*>(workingNode->GetData());
 
   unsigned int timeStep = positionEvent->GetSender()->GetTimeStep( image );
 
     //Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
   //Set the slice as 'input'
   reslice->SetInputSlice(slice->GetVtkImageData());
 
   //set overwrite mode to true to write back to the image volume
   reslice->SetOverwriteMode(true);
   reslice->Modified();
 
   mitk::ExtractSliceFilter::Pointer extractor =  mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput( image );
   extractor->SetTimeStep( timeStep );
   extractor->SetWorldGeometry( planeGeometry );
   extractor->SetVtkOutputRequest(true);
   extractor->SetResliceTransformByGeometry( image->GetTimeSlicedGeometry()->GetGeometry3D( timeStep ) );
 
   extractor->Modified();
   extractor->Update();
 
   //the image was modified within the pipeline, but not marked so
   image->Modified();
 
   /*============= BEGIN undo feature block ========================*/
   //specify the undo operation with the edited slice
   m_doOperation = new DiffSliceOperation(image, extractor->GetVtkOutput(),slice->GetGeometry(), timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
   
   //create an operation event for the undo stack
   OperationEvent* undoStackItem = new OperationEvent( DiffSliceOperationApplier::GetInstance(), m_doOperation, m_undoOperation, "Segmentation" );
   
   //add it to the undo controller
   UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
 
   //clear the pointers as the operation are stored in the undocontroller and also deleted from there
   m_undoOperation = NULL;
   m_doOperation = NULL;
   /*============= END undo feature block ========================*/
   
   slice->DisconnectPipeline();
   ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
   contourExtractor->SetInput(slice);
   contourExtractor->Update();
   mitk::Surface::Pointer contour = contourExtractor->GetOutput();
 
   if (contour->GetVtkPolyData()->GetNumberOfPoints() > 0 )
   {
     unsigned int pos = this->AddContourmarker(positionEvent);
     mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
     PlanePositionManagerService* service = dynamic_cast<PlanePositionManagerService*>(mitk::GetModuleContext()->GetService(serviceRef));
     mitk::SurfaceInterpolationController::GetInstance()->AddNewContour( contour, service->GetPlanePosition(pos));
     contour->DisconnectPipeline();
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::SegTool2D::SetShowMarkerNodes(bool status)
 {
     m_ShowMarkerNodes = status;
 }
 
 unsigned int mitk::SegTool2D::AddContourmarker ( const PositionEvent* positionEvent )
 {
   const mitk::Geometry2D* plane = dynamic_cast<const Geometry2D*> (dynamic_cast< const mitk::SlicedGeometry3D*>(
     positionEvent->GetSender()->GetSliceNavigationController()->GetCurrentGeometry3D())->GetGeometry2D(0));
 
   mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
   PlanePositionManagerService* service = dynamic_cast<PlanePositionManagerService*>(mitk::GetModuleContext()->GetService(serviceRef));
   unsigned int size = service->GetNumberOfPlanePositions();
   unsigned int id = service->AddNewPlanePosition(plane, positionEvent->GetSender()->GetSliceNavigationController()->GetSlice()->GetPos());
 
   mitk::PlanarCircle::Pointer contourMarker = mitk::PlanarCircle::New();
+  mitk::Point2D p1;
+  plane->Map(plane->GetCenter(), p1);
+  mitk::Point2D p2 = p1;
+  p2[0] -= plane->GetSpacing()[0];
+  p2[1] -= plane->GetSpacing()[1];
+  contourMarker->PlaceFigure( p1 );
+  contourMarker->SetCurrentControlPoint( p1 );
   contourMarker->SetGeometry2D( const_cast<Geometry2D*>(plane));
 
   std::stringstream markerStream;
   mitk::DataNode* workingNode (m_ToolManager->GetWorkingData(0));
 
   markerStream << m_Contourmarkername ;
   markerStream << " ";
   markerStream << id+1;
 
   DataNode::Pointer rotatedContourNode = DataNode::New();
 
   rotatedContourNode->SetData(contourMarker);
   rotatedContourNode->SetProperty( "name", StringProperty::New(markerStream.str()) );
   rotatedContourNode->SetProperty( "isContourMarker", BoolProperty::New(true));
   rotatedContourNode->SetBoolProperty( "PlanarFigureInitializedWindow", true, positionEvent->GetSender() );
   rotatedContourNode->SetProperty( "includeInBoundingBox", BoolProperty::New(false));
   rotatedContourNode->SetProperty( "helper object", mitk::BoolProperty::New(!m_ShowMarkerNodes));
+  rotatedContourNode->SetProperty( "planarfigure.drawcontrolpoints", BoolProperty::New(false));
+  rotatedContourNode->SetProperty( "planarfigure.drawname", BoolProperty::New(false));
+  rotatedContourNode->SetProperty( "planarfigure.drawoutline", BoolProperty::New(false));
+  rotatedContourNode->SetProperty( "planarfigure.drawshadow", BoolProperty::New(false));
 
   if (plane)
   {
 
     if ( id ==  size )
     {
       m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
     else
     {
         mitk::NodePredicateProperty::Pointer isMarker = mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true));
 
         mitk::DataStorage::SetOfObjects::ConstPointer markers = m_ToolManager->GetDataStorage()->GetDerivations(workingNode,isMarker);
 
         for ( mitk::DataStorage::SetOfObjects::const_iterator iter = markers->begin();
           iter != markers->end();
           ++iter)
         {
             std::string nodeName = (*iter)->GetName();
             unsigned int t = nodeName.find_last_of(" ");
             unsigned int markerId = atof(nodeName.substr(t+1).c_str())-1;
             if(id == markerId)
             {
                 return id;
             }
         }
         m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
   }
   return id;
 }
 
 void mitk::SegTool2D::InteractiveSegmentationBugMessage( const std::string& message )
 {
   MITK_ERROR << "********************************************************************************" << std::endl
     << " " << message << std::endl
     << "********************************************************************************" << std::endl
     << "  " << std::endl
     << " If your image is rotated or the 2D views don't really contain the patient image, try to press the button next to the image selection. " << std::endl
     << "  " << std::endl
     << " Please file a BUG REPORT: " << std::endl
     << " http://bugs.mitk.org" << std::endl
     << " Contain the following information:" << std::endl
     << "  - What image were you working on?" << std::endl
     << "  - Which region of the image?" << std::endl
     << "  - Which tool did you use?" << std::endl
     << "  - What did you do?" << std::endl
     << "  - What happened (not)? What did you expect?" << std::endl;
 }
 
diff --git a/Plugins/org.mitk.core.services/src/internal/mitkPluginActivator.cpp b/Plugins/org.mitk.core.services/src/internal/mitkPluginActivator.cpp
index e12d319526..5376638a94 100644
--- a/Plugins/org.mitk.core.services/src/internal/mitkPluginActivator.cpp
+++ b/Plugins/org.mitk.core.services/src/internal/mitkPluginActivator.cpp
@@ -1,273 +1,277 @@
 /*===================================================================
 
 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 "mitkPluginActivator.h"
 
 #include "mitkLog.h"
 
 #include <QString>
 #include <QFileInfo>
 
 #include "internal/mitkDataStorageService.h"
 
 #include <mitkModuleRegistry.h>
 #include <mitkModule.h>
 #include <mitkModuleContext.h>
+#include <mitkVtkLoggingAdapter.h>
+#include <mitkItkLoggingAdapter.h>
 
 
 namespace mitk
 {
 
 class ITKLightObjectToQObjectAdapter : public QObject
 {
 
 public:
 
   ITKLightObjectToQObjectAdapter(const QStringList& clazzes, itk::LightObject* service)
     : interfaceNames(clazzes), mitkService(service)
   {}
 
   // This method is called by the Qt meta object system. It is usually
   // generated by the moc, but we create it manually to be able to return
   // a MITK micro service object (derived from itk::LightObject). It basically
   // works as if the micro service class had used the Q_INTERFACES macro in
   // its declaration. Now we can successfully do a
   // qobject_cast<mitk::SomeMicroServiceInterface>(lightObjectToQObjectAdapter)
   void* qt_metacast(const char *_clname)
   {
     if (!_clname) return 0;
     if (!strcmp(_clname, "ITKLightObjectToQObjectAdapter"))
       return static_cast<void*>(const_cast<ITKLightObjectToQObjectAdapter*>(this));
     if (interfaceNames.contains(QString(_clname)))
       return static_cast<void*>(mitkService);
     return QObject::qt_metacast(_clname);
   }
 
 private:
 
   QStringList interfaceNames;
   itk::LightObject* mitkService;
 };
 
 const std::string org_mitk_core_services_Activator::PLUGIN_ID = "org.mitk.core.services";
 
 void org_mitk_core_services_Activator::start(ctkPluginContext* context)
 {
   pluginContext = context;
 
   //initialize logging
   mitk::LoggingBackend::Register(); 
   QString filename = "mitk.log";
   QFileInfo path = context->getDataFile(filename);
   mitk::LoggingBackend::SetLogFile(path.absoluteFilePath().toStdString().c_str());
+  mitk::VtkLoggingAdapter::Initialize();
+  mitk::ItkLoggingAdapter::Initialize();
 
   //initialize data storage service
   DataStorageService* service = new DataStorageService();
   dataStorageService = IDataStorageService::Pointer(service);
   context->registerService<mitk::IDataStorageService>(service);
 
   // Get the MitkCore Module Context
   mitkContext = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
 
   // Process all already registered services
   std::list<mitk::ServiceReference> refs = mitkContext->GetServiceReferences("");
   for (std::list<mitk::ServiceReference>::const_iterator i = refs.begin();
        i != refs.end(); ++i)
   {
     this->AddMitkService(*i);
   }
 
   mitkContext->AddServiceListener(this, &org_mitk_core_services_Activator::MitkServiceChanged);
 }
 
 void org_mitk_core_services_Activator::stop(ctkPluginContext* /*context*/)
 {
   mitkContext->RemoveServiceListener(this, &org_mitk_core_services_Activator::MitkServiceChanged);
 
   foreach(ctkServiceRegistration reg, mapMitkIdToRegistration.values())
   {
     reg.unregister();
   }
   mapMitkIdToRegistration.clear();
 
   qDeleteAll(mapMitkIdToAdapter);
   mapMitkIdToAdapter.clear();
 
   //clean up logging
   mitk::LoggingBackend::Unregister();
   
   dataStorageService = 0;
   mitkContext = 0;
   pluginContext = 0;
 }
 
 void org_mitk_core_services_Activator::MitkServiceChanged(const mitk::ServiceEvent event)
 {
   switch (event.GetType())
   {
   case mitk::ServiceEvent::REGISTERED:
   {
     this->AddMitkService(event.GetServiceReference());
     break;
   }
   case mitk::ServiceEvent::UNREGISTERING:
   {
     long mitkServiceId = mitk::any_cast<long>(event.GetServiceReference().GetProperty(mitk::ServiceConstants::SERVICE_ID()));
     ctkServiceRegistration reg = mapMitkIdToRegistration.take(mitkServiceId);
     if (reg)
     {
       reg.unregister();
     }
     delete mapMitkIdToAdapter.take(mitkServiceId);
     break;
   }
   case mitk::ServiceEvent::MODIFIED:
   {
     long mitkServiceId = mitk::any_cast<long>(event.GetServiceReference().GetProperty(mitk::ServiceConstants::SERVICE_ID()));
     ctkDictionary newProps = CreateServiceProperties(event.GetServiceReference());
     mapMitkIdToRegistration[mitkServiceId].setProperties(newProps);
     break;
   }
   default:
     break; // do nothing
   }
 }
 
 void org_mitk_core_services_Activator::AddMitkService(const mitk::ServiceReference& ref)
 {
   // Get the MITK micro service object
   itk::LightObject* mitkService = mitkContext->GetService(ref);
   if (mitkService == 0) return;
 
   // Get the interface names against which the service was registered
   std::list<std::string> clazzes =
       mitk::any_cast<std::list<std::string> >(ref.GetProperty(mitk::ServiceConstants::OBJECTCLASS()));
 
   QStringList qclazzes;
   for(std::list<std::string>::const_iterator clazz = clazzes.begin();
       clazz != clazzes.end(); ++clazz)
   {
     qclazzes << QString::fromStdString(*clazz);
   }
 
   long mitkServiceId = mitk::any_cast<long>(ref.GetProperty(mitk::ServiceConstants::SERVICE_ID()));
 
   QObject* adapter = new ITKLightObjectToQObjectAdapter(qclazzes, mitkService);
   mapMitkIdToAdapter[mitkServiceId] = adapter;
 
   ctkDictionary props = CreateServiceProperties(ref);
   mapMitkIdToRegistration[mitkServiceId] = pluginContext->registerService(qclazzes, adapter, props);
 }
 
 ctkDictionary org_mitk_core_services_Activator::CreateServiceProperties(const ServiceReference &ref)
 {
   ctkDictionary props;
 
   long mitkServiceId = mitk::any_cast<long>(ref.GetProperty(mitk::ServiceConstants::SERVICE_ID()));
   props.insert("mitk.serviceid", QVariant::fromValue(mitkServiceId));
 
   // Add all other properties from the MITK micro service
   std::vector<std::string> keys;
   ref.GetPropertyKeys(keys);
   for (std::vector<std::string>::const_iterator it = keys.begin(); it != keys.end(); ++it)
   {
     QString key = QString::fromStdString(*it);
     mitk::Any value = ref.GetProperty(*it);
     // We cannot add any mitk::Any object, we need to query the type
     const std::type_info& objType = value.Type();
     if (objType == typeid(std::string))
     {
       props.insert(key, QString::fromStdString(ref_any_cast<std::string>(value)));
     }
     else if (objType == typeid(std::vector<std::string>))
     {
       const std::vector<std::string>& list = ref_any_cast<std::vector<std::string> >(value);
       QStringList qlist;
       for (std::vector<std::string>::const_iterator str = list.begin();
            str != list.end(); ++str)
       {
          qlist << QString::fromStdString(*str);
       }
       props.insert(key, qlist);
     }
     else if (objType == typeid(std::list<std::string>))
     {
       const std::list<std::string>& list = ref_any_cast<std::list<std::string> >(value);
       QStringList qlist;
       for (std::list<std::string>::const_iterator str = list.begin();
            str != list.end(); ++str)
       {
          qlist << QString::fromStdString(*str);
       }
       props.insert(key, qlist);
     }
     else if (objType == typeid(char))
     {
       props.insert(key, QChar(ref_any_cast<char>(value)));
     }
     else if (objType == typeid(unsigned char))
     {
       props.insert(key, QChar(ref_any_cast<unsigned char>(value)));
     }
     else if (objType == typeid(bool))
     {
       props.insert(key, any_cast<bool>(value));
     }
     else if (objType == typeid(short))
     {
       props.insert(key, any_cast<short>(value));
     }
     else if (objType == typeid(unsigned short))
     {
       props.insert(key, any_cast<unsigned short>(value));
     }
     else if (objType == typeid(int))
     {
       props.insert(key, any_cast<int>(value));
     }
     else if (objType == typeid(unsigned int))
     {
       props.insert(key, any_cast<unsigned int>(value));
     }
     else if (objType == typeid(float))
     {
       props.insert(key, any_cast<float>(value));
     }
     else if (objType == typeid(double))
     {
       props.insert(key, any_cast<double>(value));
     }
     else if (objType == typeid(long long int))
     {
       props.insert(key, any_cast<long long int>(value));
     }
     else if (objType == typeid(unsigned long long int))
     {
       props.insert(key, any_cast<unsigned long long int>(value));
     }
   }
 
   return props;
 }
 
 org_mitk_core_services_Activator::org_mitk_core_services_Activator()
   : mitkContext(0), pluginContext(0)
 {
 }
 
 }
 
 Q_EXPORT_PLUGIN2(org_mitk_core_services, mitk::org_mitk_core_services_Activator)
diff --git a/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h b/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
index d8ae9b4fdc..a1bc7ac766 100644
--- a/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
+++ b/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
@@ -1,191 +1,230 @@
 /*===================================================================
 
 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 MITKIRENDERWINDOWPART_H
 #define MITKIRENDERWINDOWPART_H
 
 #include <QString>
 #include <QStringList>
 #include <QHash>
 #include <QtPlugin>
 
 #include <mitkVector.h>
 #include <mitkRenderingManager.h>
 
 #include <org_mitk_gui_common_Export.h>
 
 class QmitkRenderWindow;
 
 namespace mitk {
 
 struct IRenderingManager;
 class SliceNavigationController;
 
 /**
  * \ingroup org_mitk_gui_common
  *
  * \brief Interface for a MITK Workbench Part providing a render window.
  *
  * This interface allows generic access to Workbench parts which provide some
  * kind of render window. The interface is intended to be implemented by
  * subclasses of berry::IWorkbenchPart. Usually, the interface is implemented
  * by a Workbench editor.
  *
  * A IRenderWindowPart provides zero or more QmitkRenderWindow instances which can
  * be controlled via this interface. QmitkRenderWindow instances have an associated
  * \e id, which is implementation specific. However, implementations should consider
  * to use one of the following ids for certain QmitkRenderWindow instances to maximize
  * reusability (they are free to map multiple ids to one QmitkRenderWindow internally):
  * <ul>
  * <li>transversal (deprecated, use axial instead)</li>
  * <li>axial</li>
  * <li>sagittal</li>
  * <li>coronal</li>
  * <li>3d</li>
  * </ul>
  *
  * \see ILinkedRenderWindowPart
  * \see IRenderWindowPartListener
  * \see QmitkAbstractRenderEditor
  */
 struct MITK_GUI_COMMON_PLUGIN IRenderWindowPart {
 
   static const QString DECORATION_BORDER; // = "border"
   static const QString DECORATION_LOGO; // = "logo"
   static const QString DECORATION_MENU; // = "menu"
   static const QString DECORATION_BACKGROUND; // = "background;
 
   virtual ~IRenderWindowPart();
 
+  /**
+   * Get the currently active (focused) render window.
+   * Focus handling is implementation specific.
+   *
+   * \return The active QmitkRenderWindow instance; <code>NULL</code>
+   *         if no render window is active.
+   *
+   * \deprecated The method is deprecated, use the IRenderWindowPart::GetActiveQmitkRenderWindow() instead
+   */
+  DEPRECATED( virtual QmitkRenderWindow* GetActiveRenderWindow() const)
+  {
+    return GetActiveQmitkRenderWindow();
+  }
+
+  /**
+   * Get all render windows with their ids.
+   *
+   * \return A hash map mapping the render window id to the QmitkRenderWindow instance.
+   *
+   * \deprecated The method is deprecated, use the IRenderWindowPart::GetQmitkRenderWindows() instead
+   */
+  DEPRECATED( virtual QHash<QString,QmitkRenderWindow*> GetRenderWindows() const )
+  {
+    return GetQmitkRenderWindows();
+  }
+
+  /**
+   * Get a render window with a specific id.
+   *
+   * \param id The render window id.
+   * \return The QmitkRenderWindow instance for <code>id</code>
+   *
+   * \deprecated The method is deprecated, use the IRenderWindowPart::GetQmitkRenderWindow(const QString& id) instead
+   */
+  DEPRECATED( virtual QmitkRenderWindow* GetRenderWindow(const QString& id) const )
+  {
+    return GetQmitkRenderWindow( id );
+  }
+
   /**
    * Get the currently active (focused) render window.
    * Focus handling is implementation specific.
    *
    * \return The active QmitkRenderWindow instance; <code>NULL</code>
    *         if no render window is active.
    */
-  virtual QmitkRenderWindow* GetActiveRenderWindow() const = 0;
+  virtual QmitkRenderWindow* GetActiveQmitkRenderWindow() const = 0;
 
   /**
    * Get all render windows with their ids.
    *
    * \return A hash map mapping the render window id to the QmitkRenderWindow instance.
    */
-  virtual QHash<QString,QmitkRenderWindow*> GetRenderWindows() const = 0;
+  virtual QHash<QString,QmitkRenderWindow*> GetQmitkRenderWindows() const  = 0;
 
   /**
    * Get a render window with a specific id.
    *
    * \param id The render window id.
    * \return The QmitkRenderWindow instance for <code>id</code>
    */
-  virtual QmitkRenderWindow* GetRenderWindow(const QString& id) const = 0;
+  virtual QmitkRenderWindow* GetQmitkRenderWindow(const QString& id) const = 0;
 
   /**
    * Get the rendering manager used by this render window part.
    *
    * \return The current IRenderingManager instance or <code>NULL</code>
    *         if no rendering manager is used.
    */
   virtual mitk::IRenderingManager* GetRenderingManager() const = 0;
 
   /**
    * Request an update of all render windows.
    *
    * \param requestType Specifies the type of render windows for which an update
    *        will be requested.
    */
   virtual void RequestUpdate(mitk::RenderingManager::RequestType requestType = mitk::RenderingManager::REQUEST_UPDATE_ALL) = 0;
 
   /**
    * Force an immediate update of all render windows.
    *
    * \param requestType Specifies the type of render windows for which an immediate update
    *        will be requested.
    */
   virtual void ForceImmediateUpdate(mitk::RenderingManager::RequestType requestType = mitk::RenderingManager::REQUEST_UPDATE_ALL) = 0;
 
   /**
    * Get the SliceNavigationController for controlling time positions.
    *
    * \return A SliceNavigationController if the render window supports this
    *         operation; otherwise returns <code>NULL</code>.
    */
   virtual mitk::SliceNavigationController* GetTimeNavigationController() const = 0;
 
   /**
    * Get the selected position in the render window with id <code>id</code>
    * or in the active render window if <code>id</code> is NULL.
    *
    * \param id The render window id.
    * \return The currently selected position in world coordinates.
    */
   virtual mitk::Point3D GetSelectedPosition(const QString& id = QString()) const = 0;
 
   /**
    * Set the selected position in the render window with id <code>id</code>
    * or in the active render window if <code>id</code> is NULL.
    *
    * \param pos The position in world coordinates which should be selected.
    * \param id The render window id in which the selection should take place.
    */
   virtual void SetSelectedPosition(const mitk::Point3D& pos, const QString& id = QString()) = 0;
 
   /**
    * Enable \e decorations like colored borders, menu widgets, logos, text annotations, etc.
    *
    * Decorations are implementation specific. A set of standardized decoration names is listed
    * in GetDecorations().
    *
    * \param enable If <code>true</code> enable the decorations specified in <code>decorations</code>,
    *        otherwise disable them.
    * \param decorations A list of decoration names. If empty, all supported decorations are affected.
    *
    * \see GetDecorations()
    */
   virtual void EnableDecorations(bool enable, const QStringList& decorations = QStringList()) = 0;
 
   /**
    * Return if a specific decoration is enabled.
    *
    * \return <code>true</code> if the decoration is enabled, <code>false</code> if it is disabled
    *         or unknown.
    *
    * \see GetDecorations()
    */
   virtual bool IsDecorationEnabled(const QString& decoration) const = 0;
 
   /**
    * Get a list of supported decorations.
    *
    * The following decoration names are standardized and should not be used for other decoration types:
    * <ul>
    * <li>\e DECORATION_BORDER Any border decorations like colored rectangles, etc.
    * <li>\e DECORATION_MENU Menus associated with render windows
    * <li>\e DECORATION_BACKGROUND All kinds of backgrounds (patterns, gradients, etc.) except for solid colored backgrounds
    * <li>\e DECORATION_LOGO Any kind of logo overlayed on the rendered scene
    * </ul>
    *
    * \return A list of supported decoration names.
    */
   virtual QStringList GetDecorations() const = 0;
 };
 
 }
 
 Q_DECLARE_INTERFACE(mitk::IRenderWindowPart, "org.mitk.ui.IRenderWindowPart")
 
 #endif // MITKIRENDERWINDOWPART_H
diff --git a/Plugins/org.mitk.gui.qt.basicimageprocessing/documentation/UserManual/QmitkBasicImageProcessing.dox b/Plugins/org.mitk.gui.qt.basicimageprocessing/documentation/UserManual/QmitkBasicImageProcessing.dox
index 7819419008..58326c13d8 100644
--- a/Plugins/org.mitk.gui.qt.basicimageprocessing/documentation/UserManual/QmitkBasicImageProcessing.dox
+++ b/Plugins/org.mitk.gui.qt.basicimageprocessing/documentation/UserManual/QmitkBasicImageProcessing.dox
@@ -1,132 +1,132 @@
 /**
-\page org_basicimageprocessing The Basic Image Processing Module
+\page org_mitk_views_basicimageprocessing The Basic Image Processing Plugin
 
-\image html ImageProcessing_48.png "Icon of the Module"
+\image html ImageProcessing_48.png "Icon of the Plugin"
 
 \section QmitkBasicImageProcessingUserManualSummary Summary
 
-This module provides an easy interface to fundamental image preprocessing and enhancement filters.
+This view provides an easy interface to fundamental image preprocessing and enhancement filters.
 It offers filter operations on 3D and 4D images in the areas of noise suppression, morphological operations, edge detection and image arithmetics, 
 as well as image inversion and downsampling.
 
 Please see \ref QmitkBasicImageProcessingUserManualDetails for more detailed information on usage and supported filters.
-If you encounter problems using the module, please have a look at the \ref QmitkBasicImageProcessingUserManualTrouble page.
+If you encounter problems using the view, please have a look at the \ref QmitkBasicImageProcessingUserManualTrouble page.
 
 \section QmitkBasicImageProcessingUserManualDetails Details
 
 Manual sections:
 
 - \ref QmitkBasicImageProcessingUserManualOverview 
 - \ref QmitkBasicImageProcessingUserManualFilters 
 - \ref QmitkBasicImageProcessingUserManualUsage
 - \ref QmitkBasicImageProcessingUserManualTrouble
 
 \section QmitkBasicImageProcessingUserManualOverview Overview
 
-This module provides an easy interface to fundamental image preprocessing and image enhancement filters.
+This view provides an easy interface to fundamental image preprocessing and image enhancement filters.
 It offers a variety of filter operations in the areas of noise suppression, morphological operations, edge detection and image arithmetics.
-At the moment, the module can be used with all 3D and 4D image types loadable by MITK. 2D image support will be added in the future. 
+At the moment, the view can be used with all 3D and 4D image types loadable by MITK. 2D image support will be added in the future. 
 All filters are encapsulated from the Insight Segmentation and Registration Toolkit (ITK, www.itk.org). 
 
-\image html BIP_Overview.png "MITK with the Basic Image Processing module"
+\image html BIP_Overview.png "MITK with the Basic Image Processing view"
 
-This document will tell you how to use this module, but it is assumed that you already know how to use MITK in general.
+This document will tell you how to use this view, but it is assumed that you already know how to use MITK in general.
 
 \section QmitkBasicImageProcessingUserManualFilters Filters
 
 This section will not describe the fundamental functioning of the single filters in detail, though.
 If you want to know more about a single filter, please have a look at http://www.itk.org/Doxygen316/html/classes.html 
 or in any good digital image processing book. For total denoising filter, please see Tony F. Chan et al., "The digital TV filter and nonlinear denoising".
 
 Available filters are:
 
 <H2>\a Single image operations</H2>
 
 <ul>
 <li><b>Noise Suppression</b></li>
   <ul>
   <li> Gaussian Denoising</li>
   <li> Median Filtering</li>
   <li> Total Variation Denoising</li>
   </ul>
   
 <li><b>Morphological Operations</b></li>
   <ul>
   <li> Dilation</li>
   <li> Erosion</li>
   <li> Opening</li>
   <li> Closing</li>
   </ul>
   
 <li><b>%Edge Detection</b></li>
   <ul>
   <li> Gradient Image</li>
   <li> Laplacian Operator (Second Derivative)</li>
   <li> Sobel Operator</li>
   </ul>
   
 <li><b>Misc</b></li>
   <ul>
   <li> Threshold </li>
   <li> Image Inversion</li>
   <li> Downsampling (isotropic)</li>  
   </ul>
 </ul>
   
 <H2>\a Dual image operations</H2>
 
 <ul>  
 <li><b>Image Arithmetics</b></li>
   <ul>
   <li> Add two images</li>
   <li> Subtract two images</li>
   <li> Multiply two images</li>
   <li> Divide two images</li>
   </ul>
   
   <li><b>Binary Operations</b></li>
   <ul>
   <li> Logical AND</li>
   <li> Logical OR</li>
   <li> Logical XOR</li>
   </ul>
 </ul> 
 
 \section QmitkBasicImageProcessingUserManualUsage Usage
 
 All you have to do to use a filter is to:
 <ul>
 <li> Load an image into MITK</li>
 <li> Select it in data manager
 <li> Select which filter you want to use via the drop down list</li>
 <li> Press the execute button</li>
 </ul>
 A busy cursor appeares; when it vanishes, the operation is completed. Your filtered image is displayed and selected for further processing.
 (If the  checkbox "Hide original image" is not selected, you will maybe not see the filter result imideately, 
 because your filtered image is possibly hidden by the original.)
 
 For two image operations, please make sure that the correct second image is selected in the drop down menu, and the image order is correct.
 For sure, image order only plays a role for image subtraction and division. These are conducted (Image1 - Image2) or (Image1 / Image2), respectively.
 
 Please Note: When you select a 4D image, you can select the time step for the filter to work on via the time slider at the top of the GUI.
 The 3D image at this time step is extracted and processed. The result will also be a 3D image.
 This means, a true 4D filtering is not yet supported.
 
 \section QmitkBasicImageProcessingUserManualTrouble Troubleshooting
 
 <B>I get an error when using a filter on a 2D image.</B><BR>
 2D images are not yet supported...
 
 <B>I use a filter on a 4D image, and the output is 3D.</B><BR>
 When you select a 4D image, you can select the time step for the filter to work on via the time slider at the top of the GUI.
 The 3D image at this time step is extracted and processed. The result will also be a 3D image.
 This means, a true 4D filtering is not supported by now.
 
 <B>A filter crashes during execution.</B><BR>
 Maybe your image is too large. Some filter operations, like derivatives, take a lot of memory.
 Try downsampling your image first. 
 
 <B>All other problems.</B><BR>
 Please report to the MITK mailing list.
 See http://www.mitk.org/wiki/Mailinglist on how to do this.
 */
diff --git a/Plugins/org.mitk.gui.qt.datamanager/documentation/UserManual/QmitkDatamanager.dox b/Plugins/org.mitk.gui.qt.datamanager/documentation/UserManual/QmitkDatamanager.dox
index 17029566e0..8d95aeb632 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/documentation/UserManual/QmitkDatamanager.dox
+++ b/Plugins/org.mitk.gui.qt.datamanager/documentation/UserManual/QmitkDatamanager.dox
@@ -1,108 +1,108 @@
 /**
 
-\page org_datamanager The DataManager
+\page org_mitk_views_datamanager The DataManager
 
 \image html DataManager_48.png "Icon of the Module"
 
 \section QmitkDataManagerIntroduction Introduction
 
 The Datamanager is the central componenent to manage medical data like images, surfaces, etc.. 
 After loading one or more data into the Datamanager the data are shown in the four-view window, the so called Standard View.
 The user can now start working on the data by just clicking  into the standard view or by using the MITK-modules such as "Segmentation" or "Basic Image Processing".
 
 Available sections:
   - \ref QmitkDataManagerIntroduction 
   - \ref QmitkDataManagerLoading
   - \ref QmitkDataManagerSaving
   - \ref QmitkDataManagerProperties
   - \ref QmitkDataManagerPropertiesList
   - \ref QmitkDataManagerPropertiesVisibility
   - \ref QmitkDataManagerPropertiesRepresentation
   - \ref QmitkDataManagerPropertiesPreferences
   - \ref QmitkDataManagerPropertyList
 
 
 \image html Overview.png "How MITK looks when starting"
 
 
 \section QmitkDataManagerLoading Loading Data
 
 There are three ways of loading data into the Datamanager as so called Data-Elements.
 
 The user can just drag and drop data into the Datamanager or directly into one of the four parts of the Standard View. 
 He can as well use the Open-Button in the right upper corner. Or he can use the standard "File->Open"-Dialog on the top.
 
 A lot of file-formats can be loaded into MITK, for example
 
 <ul>
 <li> 2D-images/3D-volumes with or without several timesteps (*.dcm, *.ima, *.pic, ...)
 <li> Surfaces (*.stl, *.vtk, ...)
 <li> Pointsets (*.mps)
 <li> ...
 </ul>
 
 The user can also load a series of 2D images (e.g. image001.png, image002.png ...) to a MITK 3D volume. 
 To do this, just drag and drop one of those 2D data files into the Datamanager by holding the ALT key.
 
 After loading one or more data into the Datamanager they appear as Data-Elements in a sorted list inside the Datamanager. 
 Data-Elements can also be sorted hierarchically as a parent-child-relation.
 For example after using the Segmentation-Module on Data-Element1 the result is created as Data-Element2, which is a child of Data-Element1 (see Screenshot1).
 The order can be changed by drag and drop.
 
 \image html Parent-Child.png "Screenshot1"
 
 The listed Data-Elements are shown in the standard view.
 Here the user can scale or rotate the medical objects or he can change the cutting planes of the object by just using the mouse inside this view.
 
 \section QmitkDataManagerSaving Saving Data
 
 There are two ways of saving data from the Datamanger. The user can either save the whole project with all Data-Elements by clicking on "File"->"Save Project"
 or he can save single Data-Elements by right-clicking->"Save", directly on a Data-Element. 
 When saving the whole project, the sorting of Data-Elements is saved as well. By contrast the sorting is lost, when saving a single Data-Element.
 
 \section QmitkDataManagerProperties Working with the Datamanager
 
 \subsection QmitkDataManagerPropertiesList List of Data-Elements
 
 The Data-Elements are listed in the Datamanager. 
 As described above the elements can be sorted hierarchically as a parent-child-relation.
 For example after using the Segmentation-Module on Data-Element1 the result is created as Data-Element2, which is a child of Data-Element1 (see Screenshot1). 
 By drag and drop the sorting of Data-Elements and their hierarchical relation can be changed.
 
 \subsection QmitkDataManagerPropertiesVisibility Visibility of Data-Elements
 
 By default all loaded Data-Elements are visible in the standard view.
 The visibility can be changed by right-clicking on the Data-Element and then choosing "Toogle visibility".
 The box in front of the Data-Element in the Datamanager shows the visibility.
 A green-filled box means a visible Data-Element, an empty box means an invisible Data-Element (see Screenshot1).
 
 \subsection QmitkDataManagerPropertiesRepresentation Representation of Data-Elements
 
 There are different types of representations how to show the Data-Element inside the standard view. By right-clicking on the Data-Element all options are listed (see Screenshot2 and Screenshot 3).
 
 <ul>
 <li> An arbitrary color can be chosen
 <li> The opacity can be changed with a slide control
 <li> In case of images a texture interpolation can be switched on or off. The texture interpolation smoothes the image, so that no single pixels are visible anymore.
 <li> In case of surfaces the surface representation can be changed between points, wireframe or surface.
 <li> Global reinit updates all windows to contain all the current data. Reinit updates a single data item fits the windows to contain this data item.
 </ul>
 
 \image html Image_properties.png "Screenshot2: Properties for images"
 \image html Surface_Properties.png "Screenshot3: Properties for surfaces"
 
 
 \subsection QmitkDataManagerPropertiesPreferences Preferences
 
 For the datamanager there are already some default hotkeys like the del-key for deleting a Data-Element. The whole list is seen in Screenshot4.
 From here the Hotkeys can also be changed. The preference page is found in "Window"->"Preferences".
 
 \image html Preferences.png "Screenshot4"
 
 \section QmitkDataManagerPropertyList Property List
 
 The Property List displays all the properties the currently selected Data-Element has. Which properties these are depends on the Data-Element. Examples are opacity, shader, visibility. These properties can be changed by clicking on the appropriate field in the "value" column.
 
 \image html PropertyList.png "Screenshot5: Property List"
 
 */
diff --git a/Plugins/org.mitk.gui.qt.datamanager/plugin.xml b/Plugins/org.mitk.gui.qt.datamanager/plugin.xml
index 90b564e87d..da42228672 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/plugin.xml
+++ b/Plugins/org.mitk.gui.qt.datamanager/plugin.xml
@@ -1,45 +1,40 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.0"?>
 <plugin>
   <extension point="org.blueberry.ui.views">
     <category 
       id="org.mitk.views.general" 
       name="MITK General"/> 
     <view 
       id="org.mitk.views.datamanager" 
       name="Datamanager" 
       category="org.mitk.views.general"
       icon="resources/DataManager_48.png"
       class="QmitkDataManagerView" />
   </extension>
   
   <extension point="org.blueberry.ui.views">
     <view 
       id="org.mitk.views.propertylistview" 
       name="Property List" 
       icon="resources/propertylist.png"
       class="QmitkPropertyListView" />
-    <view
-      id="org.mitk.views.propertytreeview"
-      name="Properties"
-      icon="resources/propertylist.png"
-      class="QmitkPropertyTreeView" />
   </extension>
 
   <extension point="org.blueberry.ui.preferencePages">
     <page id="org.mitk.gui.qt.application.DataManagerPreferencePage" name="DataManager" class="QmitkDataManagerPreferencePage">
       <keywordreference id="org.mitk.gui.qt.application.DataManagerPreferencePageKeywords"></keywordreference>
     </page>
     <page id="org.mitk.gui.qt.application.DataManagerHotkeysPrefPage" name="Hotkeys" class="QmitkDataManagerHotkeysPrefPage" category="org.mitk.gui.qt.application.DataManagerPreferencePage">
       <keywordreference id="org.mitk.gui.qt.application.DataManagerHotkeysPrefPageKeywords"></keywordreference>
     </page>
   </extension>
 
   <extension point="org.blueberry.ui.keywords">
     <keyword id="org.mitk.gui.qt.application.DataManagerPreferencePageKeywords" label="data manager"></keyword>
     <keyword id="org.mitk.gui.qt.application.DataManagerHotkeysPrefPageKeywords" label="data manager hotkeys"></keyword>
   </extension>
   
   <extension-point id="contextMenuActions" name="Context menu actions"/>
   
 </plugin>
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/internal/mitkPluginActivator.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/internal/mitkPluginActivator.cpp
index 15bf6d8490..e774ec0ae8 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/internal/mitkPluginActivator.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/internal/mitkPluginActivator.cpp
@@ -1,44 +1,42 @@
 /*===================================================================
 
 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 "mitkPluginActivator.h"
 
 #include <QtPlugin>
 
 #include "QmitkPropertyListView.h"
-#include "QmitkPropertyTreeView.h"
 #include "../QmitkDataManagerView.h"
 #include "../QmitkDataManagerPreferencePage.h"
 #include "../QmitkDataManagerHotkeysPrefPage.h"
 
 namespace mitk {
 
 void PluginActivator::start(ctkPluginContext* context)
 {
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDataManagerView, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkPropertyListView, context)
-  BERRY_REGISTER_EXTENSION_CLASS(QmitkPropertyTreeView, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDataManagerPreferencePage, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDataManagerHotkeysPrefPage, context)
 }
 
 void PluginActivator::stop(ctkPluginContext* context)
 {
   Q_UNUSED(context)
 }
 
 }
 
 Q_EXPORT_PLUGIN2(org_mitk_gui_qt_datamanager, mitk::PluginActivator)
diff --git a/Plugins/org.mitk.gui.qt.dicom/documentation/Manual/Manual.dox b/Plugins/org.mitk.gui.qt.dicom/documentation/Manual/Manual.dox
deleted file mode 100644
index 56f79ae50a..0000000000
--- a/Plugins/org.mitk.gui.qt.dicom/documentation/Manual/Manual.dox
+++ /dev/null
@@ -1,19 +0,0 @@
-/**
-\page org_mitk_gui_qt_dicom Dicom
-
-\image html icon.png "Icon of Dicom"
-
-Available sections:
-  - \ref org_mitk_gui_qt_dicomOverview
-
-\section org_mitk_gui_qt_dicomOverview
-Describe the features of your awesome plugin here
-<ul>
-<li>Increases productivity
-<li>Creates beautiful images
-<li>Generates PhD thesis
-<li>Brings world peace
-</ul>
-
-*/
-
diff --git a/Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/Manual.dox
new file mode 100644
index 0000000000..72959c3280
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/Manual.dox
@@ -0,0 +1,16 @@
+/**
+\page org_mitk_gui_qt_dicom The Dicom Plugin
+
+\image html icon.png "Icon of Dicom"
+
+\warning This plugin is experimental and not all of the described features behave as expected.
+
+Available sections:
+  - \ref org_mitk_gui_qt_dicomOverview
+
+\section org_mitk_gui_qt_dicomOverview Overview
+
+The DICOM editor is an experimental editor which allows for loading of DICOM images as well as server communication. It features a highly experimental query/retrieve (you need to configure your PACS correspondingly) as well as a DICOM browser. The DICOM browser allows you to navigate the DICOM folder/cd depending on its metadata (patient/study/series) and import selected series for viewing in your MITK based application.
+
+It is based on the <a href="http://www.commontk.org/index.php/Documentation/Dicom_Overview">commonTK (CTK) DICOM funcionality</a>.
+*/
diff --git a/Plugins/org.mitk.gui.qt.dicom/documentation/Manual/icon.png b/Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/icon.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.dicom/documentation/Manual/icon.png
rename to Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/icon.png
diff --git a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomDirectoryListener.cpp b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomDirectoryListener.cpp
index 51ae0ed5a5..993a39b8a7 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomDirectoryListener.cpp
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomDirectoryListener.cpp
@@ -1,142 +1,148 @@
 /*===================================================================
 
 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 "QmitkDicomDirectoryListener.h"
 
 #include <QString>
 #include <QFile>
 #include <mitkLogMacros.h>
 #include <QFileInfoList>
 #include <QDirIterator>
 
 QmitkDicomDirectoryListener::QmitkDicomDirectoryListener()
 : m_FileSystemWatcher(new QFileSystemWatcher())
 , m_IsListening(true)
 {
     connect(m_FileSystemWatcher,SIGNAL(directoryChanged(const QString&)),this,SLOT(OnDirectoryChanged(const QString&)));
 }
 
 QmitkDicomDirectoryListener::~QmitkDicomDirectoryListener()
 {
     m_IsListening = false;
     RemoveTemporaryFiles();
     delete m_FileSystemWatcher;
 }
 
 void QmitkDicomDirectoryListener::OnDirectoryChanged(const QString&)
 {
     if(m_IsListening)
     {
         QDirIterator it( m_DicomListenerDirectory.absolutePath() , QDir::Files , QDirIterator::Subdirectories);
         QString currentPath;
 
         m_FilesToImport.clear();
         while(it.hasNext())
         {
             it.next();
             currentPath = it.fileInfo().absoluteFilePath();
             if(!m_AlreadyImportedFiles.contains(currentPath))
             {
                 m_AlreadyImportedFiles.insert( currentPath , currentPath );
                 m_FilesToImport.append(currentPath);
             }
         }
         if(!m_FilesToImport.isEmpty())
         {
             emit SignalStartDicomImport(m_FilesToImport);
         }
     }
 }
 
 void QmitkDicomDirectoryListener::OnImportFinished()
 {
     m_IsListening = false;
     RemoveTemporaryFiles();
     m_AlreadyImportedFiles.clear();
     m_IsListening = true;
 }
 
 void QmitkDicomDirectoryListener::OnDicomNetworkError(const QString& errorMsg)
 {
     m_IsListening = false;
     m_AlreadyImportedFiles.clear();
     m_IsListening = true;
 }
 
 void QmitkDicomDirectoryListener::RemoveAlreadyImportedEntries(const QStringList& fileEntries)
 {
     QStringListIterator it(fileEntries);
     QString currentEntry;
     while(it.hasNext())
     {
         currentEntry = m_DicomListenerDirectory.absoluteFilePath(it.next());
         if(m_AlreadyImportedFiles.contains(currentEntry))
         {
             m_AlreadyImportedFiles.remove(currentEntry);
         }
     }
 }
 
 void QmitkDicomDirectoryListener::RemoveTemporaryFiles(const QStringList& fileEntries)
 {
+  /**
     QStringListIterator it(fileEntries);
     QString currentEntry;
     while(it.hasNext())
     {
         currentEntry = m_DicomListenerDirectory.absoluteFilePath(it.next());
         m_DicomListenerDirectory.remove(currentEntry);
     }
+  */
 }
 
 void QmitkDicomDirectoryListener::RemoveTemporaryFiles()
 {
-    QDirIterator it( m_DicomListenerDirectory.absolutePath() , QDir::AllEntries , QDirIterator::Subdirectories);
+/**
+* dangerous code !!!
+  
+  QDirIterator it( m_DicomListenerDirectory.absolutePath() , QDir::AllEntries , QDirIterator::Subdirectories);
     while(it.hasNext())
     {
         it.next();
         m_DicomListenerDirectory.remove(it.fileInfo().absoluteFilePath());
     }
+*/
 }
 
 void QmitkDicomDirectoryListener::SetDicomListenerDirectory(const QString& directory)
 {
     QDir dir(directory);
     if(dir.exists())
     {
         m_DicomListenerDirectory=dir;
         m_FileSystemWatcher->addPath(m_DicomListenerDirectory.absolutePath());
     }
     else
     {
         dir.mkpath(directory);
         m_DicomListenerDirectory=dir;
         m_FileSystemWatcher->addPath(m_DicomListenerDirectory.absolutePath());
     }
 }
 
 QString QmitkDicomDirectoryListener::GetDicomListenerDirectory()
 {
     return m_DicomListenerDirectory.absolutePath();
 }
 
 bool QmitkDicomDirectoryListener::IsListening()
 {
     return m_IsListening;
 }
 
 void QmitkDicomDirectoryListener::SetListening(bool listening)
 {
     m_IsListening = listening;
 }
diff --git a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.cpp b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.cpp
index e9434f3dee..76343944d3 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditor.cpp
@@ -1,324 +1,323 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryUIException.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryIPartListener.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkDataStorageEditorInput.h>
 #include "berryFileEditorInput.h"
 
 // Qmitk
 #include "QmitkDicomEditor.h"
 #include "mitkPluginActivator.h"
 #include <mitkDicomSeriesReader.h>
 
 //#include "mitkProgressBar.h"
 
 // Qt
 #include <QCheckBox>
 #include <QMessageBox>
 #include <QWidget>
 
 #include <QtSql>
 #include <QSqlDatabase>
 #include <QtCore/QVariant>
 #include <QtGui/QAction>
 #include <QtGui/QApplication>
 #include <QtGui/QButtonGroup>
 #include <QtGui/QGridLayout>
 #include <QtGui/QHeaderView>
 #include <QtGui/QPushButton>
 #include <QtGui/QTextEdit>
 #include <QtGui/QWidget>
 
 //CTK
 #include <ctkDICOMModel.h>
 #include <ctkDICOMAppWidget.h>
 #include <ctkDICOMQueryWidget.h>
 #include <ctkFileDialog.h>
 #include <ctkDICOMQueryRetrieveWidget.h>
 
 
 const std::string QmitkDicomEditor::EDITOR_ID = "org.mitk.editors.dicomeditor";
 
 
 QmitkDicomEditor::QmitkDicomEditor()
 : m_Thread(new QThread())
 , m_DicomDirectoryListener(new QmitkDicomDirectoryListener())
 , m_StoreSCPLauncher(new QmitkStoreSCPLauncher(&m_Builder))
 , m_Publisher(new QmitkDicomDataEventPublisher())
 {
 }
 
 QmitkDicomEditor::~QmitkDicomEditor()
 {
     m_Thread->quit();
     m_Thread->wait(1000);
     delete m_Handler;
     delete m_Publisher;
     delete m_StoreSCPLauncher;
     delete m_Thread;
     delete m_DicomDirectoryListener;
     delete m_ImportDialog;
-    delete m_ProgressDialog;
 }
 
 void QmitkDicomEditor::CreateQtPartControl(QWidget *parent )
 {   
     m_Controls.setupUi( parent );
     m_Controls.LocalStorageButton->setIcon(QIcon(":/org.mitk.gui.qt.dicom/drive-harddisk_32.png"));
     m_Controls.FolderButton->setIcon(QIcon(":/org.mitk.gui.qt.dicom/folder_32.png"));
     m_Controls.CDButton->setIcon(QIcon(":/org.mitk.gui.qt.dicom/media-optical_32.png"));
     m_Controls.QueryRetrieveButton->setIcon(QIcon(":/org.mitk.gui.qt.dicom/network-workgroup_32.png"));
     m_Controls.StoreSCPStatusLabel->setTextFormat(Qt::RichText);
     m_Controls.StoreSCPStatusLabel->setText("<img src=':/org.mitk.gui.qt.dicom/network-offline_16.png'>");
 
 
     TestHandler();
 
     SetPluginDirectory();
     SetDatabaseDirectory("DatabaseDirectory");
     SetListenerDirectory("ListenerDirectory");
     StartDicomDirectoryListener();
 
     SetupImportDialog();
     SetupProgressDialog(parent);
 
     m_Controls.m_ctkDICOMQueryRetrieveWidget->useProgressDialog(false);
 
     connect(m_Controls.externalDataWidget,SIGNAL(SignalStartDicomImport(const QStringList&)),m_Controls.internalDataWidget,SLOT(OnStartDicomImport(const QStringList&)));
     connect(m_Controls.externalDataWidget,SIGNAL(SignalDicomToDataManager(const QStringList&)),this,SLOT(OnViewButtonAddToDataManager(const QStringList&)));
     connect(m_Controls.externalDataWidget,SIGNAL(SignalChangePage(int)), this, SLOT(OnChangePage(int)));
 
     connect(m_Controls.internalDataWidget,SIGNAL(SignalFinishedImport()),this,SLOT(OnDicomImportFinished()));
     connect(m_Controls.internalDataWidget,SIGNAL(SignalDicomToDataManager(const QStringList&)),this,SLOT(OnViewButtonAddToDataManager(const QStringList&)));
 
     connect(m_Controls.CDButton, SIGNAL(clicked()), this, SLOT(OnFolderCDImport()));
     connect(m_Controls.FolderButton, SIGNAL(clicked()), this, SLOT(OnFolderCDImport()));
     connect(m_Controls.QueryRetrieveButton, SIGNAL(clicked()), this, SLOT(OnQueryRetrieve()));
     connect(m_Controls.LocalStorageButton, SIGNAL(clicked()), this, SLOT(OnLocalStorage()));
 }
 
 void QmitkDicomEditor::SetupProgressDialog(QWidget* parent)
 {
     m_ProgressDialog = new QProgressDialog("DICOM Import", "Cancel", 0, 100, parent,Qt::WindowTitleHint | Qt::WindowSystemMenuHint);
     m_ProgressDialogLabel = new QLabel(tr("Initialization..."));
     m_ProgressDialog->setLabel(m_ProgressDialogLabel);
 #ifdef Q_WS_MAC
     // BUG: avoid deadlock of dialogs on mac
     m_ProgressDialog->setWindowModality(Qt::NonModal);
 #else
     m_ProgressDialog->setWindowModality(Qt::ApplicationModal);
 #endif
 
     connect(m_ProgressDialog, SIGNAL(canceled()), m_Controls.internalDataWidget, SIGNAL(SignalCancelImport()));
     connect(m_Controls.internalDataWidget, SIGNAL(SignalProcessingFile(QString)),m_ProgressDialogLabel, SLOT(setText(QString)));
     connect(m_Controls.internalDataWidget, SIGNAL(SignalProgress(int)),m_ProgressDialog, SLOT(setValue(int)));
     connect(m_Controls.internalDataWidget, SIGNAL(SignalProgress(int)),this, SLOT(OnImportProgress(int)));
 
     connect(m_ProgressDialog, SIGNAL(canceled()), m_Controls.externalDataWidget, SIGNAL(SignalCancelImport()));
     connect(m_Controls.externalDataWidget, SIGNAL(SignalProcessingFile(QString)),m_ProgressDialogLabel, SLOT(setText(QString)));
     connect(m_Controls.externalDataWidget, SIGNAL(SignalProgress(int)),m_ProgressDialog, SLOT(setValue(int)));
     connect(m_Controls.externalDataWidget, SIGNAL(SignalProgress(int)),this, SLOT(OnImportProgress(int)));
 }
 
 void QmitkDicomEditor::SetupImportDialog()
 {
         //Initialize import widget
         m_ImportDialog = new ctkFileDialog();
         QCheckBox* importCheckbox = new QCheckBox("Copy on import", m_ImportDialog);
         m_ImportDialog->setBottomWidget(importCheckbox);
         m_ImportDialog->setFileMode(QFileDialog::Directory);
         m_ImportDialog->setLabelText(QFileDialog::Accept,"Import");
         m_ImportDialog->setWindowTitle("Import DICOM files from directory ...");
         m_ImportDialog->setWindowModality(Qt::ApplicationModal);
         connect(m_ImportDialog, SIGNAL(fileSelected(QString)),this,SLOT(OnFileSelected(QString)));
 }
 
 void QmitkDicomEditor::OnImportProgress(int progress)
 {
   Q_UNUSED(progress);
   QApplication::processEvents();
 }
 
 void QmitkDicomEditor::Init(berry::IEditorSite::Pointer site, berry::IEditorInput::Pointer input)
 {
     this->SetSite(site);
     this->SetInput(input);
 }
 
 void QmitkDicomEditor::SetFocus()
 {
 }
 
 berry::IPartListener::Events::Types QmitkDicomEditor::GetPartEventTypes() const
 {
     return Events::CLOSED | Events::HIDDEN | Events::VISIBLE;
 }
 
 void QmitkDicomEditor::OnQueryRetrieve()
 {
     OnChangePage(2);
     QString storagePort = m_Controls.m_ctkDICOMQueryRetrieveWidget->getServerParameters()["StoragePort"].toString();
     QString storageAET = m_Controls.m_ctkDICOMQueryRetrieveWidget->getServerParameters()["StorageAETitle"].toString();
      if(!((m_Builder.GetAETitle()->compare(storageAET,Qt::CaseSensitive)==0)&&
          (m_Builder.GetPort()->compare(storagePort,Qt::CaseSensitive)==0)))
      {
          StopStoreSCP();
          StartStoreSCP();
      }
 }
 
 void QmitkDicomEditor::OnFileSelected(QString directory)
 {
     if (QDir(directory).exists())
     {
         QCheckBox* copyOnImport = qobject_cast<QCheckBox*>(m_ImportDialog->bottomWidget());
 
         if (copyOnImport->isChecked())
         {
             connect(this,SIGNAL(SignalStartDicomImport(const QString&)),m_Controls.internalDataWidget,SLOT(OnStartDicomImport(const QString&)));
             disconnect(this,SIGNAL(SignalStartDicomImport(const QString&)),m_Controls.externalDataWidget,SLOT(OnStartDicomImport(const QString&)));
             OnChangePage(0);
         }
         else
         {
             disconnect(this,SIGNAL(SignalStartDicomImport(const QString&)),m_Controls.internalDataWidget,SLOT(OnStartDicomImport(const QString&)));
             connect(this,SIGNAL(SignalStartDicomImport(const QString&)),m_Controls.externalDataWidget,SLOT(OnStartDicomImport(const QString&)));
             OnChangePage(1);
         }
 
         m_ProgressDialog->setMinimumDuration(0);
         m_ProgressDialog->setValue(0);
         m_ProgressDialog->show();
         emit SignalStartDicomImport(directory);
     }
 }
 
 void QmitkDicomEditor::OnFolderCDImport()
 {
     m_ImportDialog->show();
     m_ImportDialog->raise();
 }
 
 void QmitkDicomEditor::OnLocalStorage()
 {
     OnChangePage(0);
 }
 
 void QmitkDicomEditor::OnChangePage(int page)
 {
     try{
         m_Controls.stackedWidget->setCurrentIndex(page);
     }catch(std::exception e){
         MITK_ERROR <<"error: "<< e.what();
         return;
     }
 }
 
 void QmitkDicomEditor::OnDicomImportFinished()
 {
 }
 
 void QmitkDicomEditor::StartDicomDirectoryListener()
 {
     if(!m_Thread->isRunning())
     {
         m_DicomDirectoryListener->SetDicomListenerDirectory(m_ListenerDirectory);
         connect(m_DicomDirectoryListener,SIGNAL(SignalStartDicomImport(const QStringList&)),m_Controls.internalDataWidget,SLOT(OnStartDicomImport(const QStringList&)),Qt::DirectConnection);
         //connect(m_Controls.internalDataWidget,SIGNAL(SignalFinishedImport()),m_DicomDirectoryListener,SLOT(OnImportFinished()),Qt::DirectConnection);
         m_DicomDirectoryListener->moveToThread(m_Thread);
         m_Thread->start();
     }
 }
 
 
 void QmitkDicomEditor::TestHandler()
 {
     m_Handler = new DicomEventHandler();
     m_Handler->SubscribeSlots();
 }
 
 void QmitkDicomEditor::OnViewButtonAddToDataManager(const QStringList& eventProperties)
 {
     ctkDictionary properties;
     properties["PatientName"] = eventProperties.at(0);
     properties["StudyUID"] = eventProperties.at(1);
     properties["StudyName"] = eventProperties.at(2);
     properties["SeriesUID"] = eventProperties.at(3);
     properties["SeriesName"] = eventProperties.at(4);
     properties["Path"] = eventProperties.at(5);
 
     m_Publisher->PublishSignals(mitk::PluginActivator::getContext());
     m_Publisher->AddSeriesToDataManagerEvent(properties);
 }
 
 
 void QmitkDicomEditor::StartStoreSCP()
 {
     QString storagePort = m_Controls.m_ctkDICOMQueryRetrieveWidget->getServerParameters()["StoragePort"].toString();
     QString storageAET = m_Controls.m_ctkDICOMQueryRetrieveWidget->getServerParameters()["StorageAETitle"].toString();
     m_Builder.AddPort(storagePort)->AddAETitle(storageAET)->AddTransferSyntax()->AddOtherNetworkOptions()->AddMode()->AddOutputDirectory(m_ListenerDirectory);
     m_StoreSCPLauncher = new QmitkStoreSCPLauncher(&m_Builder);
     connect(m_StoreSCPLauncher, SIGNAL(SignalStatusOfStoreSCP(const QString&)), this, SLOT(OnStoreSCPStatusChanged(const QString&)));
     connect(m_StoreSCPLauncher ,SIGNAL(SignalStartImport(const QStringList&)),m_Controls.internalDataWidget,SLOT(OnStartDicomImport(const QStringList&)));
     connect(m_StoreSCPLauncher ,SIGNAL(SignalStoreSCPError(const QString&)),m_Controls.internalDataWidget,SLOT(SignalCancelImport()));
     connect(m_StoreSCPLauncher ,SIGNAL(SignalStoreSCPError(const QString&)),m_DicomDirectoryListener,SLOT(OnDicomNetworkError(const QString&)),Qt::DirectConnection);
     connect(m_StoreSCPLauncher ,SIGNAL(SignalStoreSCPError(const QString&)),this,SLOT(OnDicomNetworkError(const QString&)),Qt::DirectConnection);
     m_StoreSCPLauncher->StartStoreSCP();
 
 }
 
 void QmitkDicomEditor::OnStoreSCPStatusChanged(const QString& status)
 {
     m_Controls.StoreSCPStatusLabel->setText("<img src=':/org.mitk.gui.qt.dicom/network-idle_16.png'> "+status);
 }
 
 void QmitkDicomEditor::OnDicomNetworkError(const QString& status)
 {
     m_Controls.StoreSCPStatusLabel->setText("<img src=':/org.mitk.gui.qt.dicom/network-error_16.png'> "+status);
 }
 
 void QmitkDicomEditor::StopStoreSCP()
 {
     delete m_StoreSCPLauncher;
 }
 
 void QmitkDicomEditor::SetPluginDirectory()
 {
      m_PluginDirectory = mitk::PluginActivator::getContext()->getDataFile("").absolutePath();
      m_PluginDirectory.append("/");
 }
 
 void QmitkDicomEditor::SetDatabaseDirectory(const QString& databaseDirectory)
 {
     m_DatabaseDirectory.clear();
     m_DatabaseDirectory.append(m_PluginDirectory);
     m_DatabaseDirectory.append(databaseDirectory);
     m_Controls.internalDataWidget->SetDatabaseDirectory(m_DatabaseDirectory);
 }
 
 void QmitkDicomEditor::SetListenerDirectory(const QString& listenerDirectory)
 {
     m_ListenerDirectory.clear();
     m_ListenerDirectory.append(m_PluginDirectory);
     m_ListenerDirectory.append(listenerDirectory);
 }
diff --git a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditorControls.ui b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditorControls.ui
index ec8d717b6f..d7954fbf11 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditorControls.ui
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditorControls.ui
@@ -1,264 +1,274 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkDicomEditorControls</class>
  <widget class="QWidget" name="QmitkDicomEditorControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>752</width>
     <height>696</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="acceptDrops">
    <bool>false</bool>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_8">
    <item>
     <widget class="QFrame" name="frame">
      <property name="frameShape">
       <enum>QFrame::StyledPanel</enum>
      </property>
      <property name="frameShadow">
       <enum>QFrame::Raised</enum>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
+      <item>
+       <widget class="QLabel" name="label">
+        <property name="text">
+         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;WARNING: this plugin is highly experimental!&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+        </property>
+        <property name="textFormat">
+         <enum>Qt::AutoText</enum>
+        </property>
+       </widget>
+      </item>
       <item>
        <widget class="QFrame" name="frame_3">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Plain</enum>
         </property>
         <property name="lineWidth">
          <number>0</number>
         </property>
         <layout class="QHBoxLayout" name="horizontalLayout_6">
          <property name="margin">
           <number>0</number>
          </property>
          <item>
           <widget class="QPushButton" name="LocalStorageButton">
            <property name="toolTip">
             <string>Local storage you can find your dicom data here.</string>
            </property>
            <property name="text">
             <string>Local Storage</string>
            </property>
            <property name="iconSize">
             <size>
              <width>32</width>
              <height>32</height>
             </size>
            </property>
            <property name="checkable">
             <bool>false</bool>
            </property>
            <property name="flat">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="CDButton">
            <property name="toolTip">
             <string>Imports dicom data to your local storage from CD.</string>
            </property>
            <property name="text">
             <string>Import CD</string>
            </property>
            <property name="iconSize">
             <size>
              <width>32</width>
              <height>32</height>
             </size>
            </property>
            <property name="flat">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="FolderButton">
            <property name="toolTip">
             <string>Imports dicom data to your local storage from a folder.</string>
            </property>
            <property name="text">
             <string>Import Folder</string>
            </property>
            <property name="iconSize">
             <size>
              <width>32</width>
              <height>32</height>
             </size>
            </property>
            <property name="flat">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="QueryRetrieveButton">
            <property name="toolTip">
             <string>Query dicom data from a PACS and retrieve it to your system.</string>
            </property>
            <property name="text">
             <string>Query Retrieve</string>
            </property>
            <property name="iconSize">
             <size>
              <width>32</width>
              <height>32</height>
             </size>
            </property>
            <property name="flat">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer_5">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QStackedWidget" name="stackedWidget">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="currentIndex">
          <number>0</number>
         </property>
         <widget class="QWidget" name="page">
          <layout class="QVBoxLayout" name="verticalLayout_3">
           <item>
            <widget class="QmitkDicomLocalStorageWidget" name="internalDataWidget" native="true"/>
           </item>
          </layout>
         </widget>
         <widget class="QWidget" name="importWidgetPage">
          <layout class="QVBoxLayout" name="verticalLayout_9">
           <item>
            <widget class="QmitkDicomExternalDataWidget" name="externalDataWidget" native="true"/>
           </item>
          </layout>
         </widget>
         <widget class="QWidget" name="queryRetrieveWidgetPage">
          <layout class="QVBoxLayout" name="verticalLayout_12">
           <item>
            <widget class="ctkDICOMQueryRetrieveWidget" name="m_ctkDICOMQueryRetrieveWidget" native="true"/>
           </item>
          </layout>
         </widget>
        </widget>
       </item>
       <item>
        <widget class="QFrame" name="frame_2">
         <property name="frameShape">
          <enum>QFrame::StyledPanel</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QHBoxLayout" name="horizontalLayout">
          <property name="spacing">
           <number>0</number>
          </property>
          <property name="margin">
           <number>0</number>
          </property>
          <item>
           <spacer name="horizontalSpacer_2">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeType">
             <enum>QSizePolicy::Minimum</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>4</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QLabel" name="StoreSCPStatusLabel">
            <property name="text">
             <string/>
            </property>
            <property name="textFormat">
             <enum>Qt::RichText</enum>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>ctkDICOMQueryRetrieveWidget</class>
    <extends>QWidget</extends>
    <header>ctkDICOMQueryRetrieveWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkDicomLocalStorageWidget</class>
    <extends>QWidget</extends>
    <header>Qmitk/QmitkDicomLocalStorageWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkDicomExternalDataWidget</class>
    <extends>QWidget</extends>
    <header>Qmitk/QmitkDicomExternalDataWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
  <slots>
   <slot>OnChangePage(int)</slot>
  </slots>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkStoreSCPLauncher.cpp b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkStoreSCPLauncher.cpp
index 31ee48ea02..ddd9c54abb 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkStoreSCPLauncher.cpp
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkStoreSCPLauncher.cpp
@@ -1,215 +1,221 @@
 /*===================================================================
 
 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 "QmitkStoreSCPLauncher.h"
 #include <QMessageBox>
 #include <QProcessEnvironment>
 #include <mitkLogMacros.h>
 
 #include <fstream>
 #include <iostream>
 #include <QFile>
 #include <QTextStream>
 #include <QIODevice>
 #include <QDir>
 #include <QDirIterator>
 #include <QCoreApplication>
 #include "org_mitk_gui_qt_dicom_config.h"
 
 QmitkStoreSCPLauncher::QmitkStoreSCPLauncher(QmitkStoreSCPLauncherBuilder* builder) 
 : m_StoreSCP(new QProcess())
 {
     connect( m_StoreSCP, SIGNAL(error(QProcess::ProcessError)),this, SLOT(OnProcessError(QProcess::ProcessError)));
     connect( m_StoreSCP, SIGNAL(stateChanged(QProcess::ProcessState)),this, SLOT(OnStateChanged(QProcess::ProcessState)));
     //connect( m_StoreSCP, SIGNAL(readyReadStandardError()),this, SLOT(OnReadyProcessError()));
     connect( m_StoreSCP, SIGNAL(readyReadStandardOutput()),this, SLOT(OnReadyProcessOutput()));
     SetArgumentList(builder);
     //m_StoreSCP->setStandardOutputFile("OutputLog.log");
     //m_StoreSCP->setStandardErrorFile("ErrorLog.log");
 }
 
 QmitkStoreSCPLauncher::~QmitkStoreSCPLauncher()
 {
     m_StoreSCP->close();
     m_StoreSCP->waitForFinished(1000);
     DeleteTemporaryData();
     delete m_StoreSCP;
 }
 
 void QmitkStoreSCPLauncher::StartStoreSCP()
 {
     FindPathToStoreSCP();
     MITK_INFO << m_PathToStoreSCP.toStdString();
     MITK_INFO << m_ArgumentList[7].toStdString();
     m_StoreSCP->start(m_PathToStoreSCP,m_ArgumentList);
 }
 
 void QmitkStoreSCPLauncher::FindPathToStoreSCP()
 {
     QString appPath= QCoreApplication::applicationDirPath();
     if(m_PathToStoreSCP.isEmpty())
     {
         QString fileName;
 #ifdef _WIN32
         fileName = "/storescp.exe";
 #else
         fileName = "/storescp";
 #endif
 
         m_PathToStoreSCP = fileName;
 
         //In developement the storescp isn't copied into bin directory
         if(!QFile::exists(m_PathToStoreSCP))
         {
             m_PathToStoreSCP = static_cast<QString>(MITK_STORESCP);
         }
     }
 }
 
 void QmitkStoreSCPLauncher::OnReadyProcessOutput()
 {
     QString out(m_StoreSCP->readAllStandardOutput());
     QStringList allDataList,importList;
 
     allDataList = out.split("\n",QString::SkipEmptyParts);
     QStringListIterator it(allDataList);
 
     while(it.hasNext())
     {
         QString output = it.next();
         if (output.contains("E: "))
         {
             output.replace("E: ","");
             m_ErrorText = output;
             OnProcessError(QProcess::UnknownError);
             return;
         }
         if(output.contains("I: storing DICOM file: "))
         {
             output.replace("I: storing DICOM file: ","");
             importList += output;
         }
     }
     if(!importList.isEmpty())
     {
         emit SignalStartImport(importList);
     }
 }
 
 void QmitkStoreSCPLauncher::OnProcessError(QProcess::ProcessError err)
 {
     switch(err)
     {
     case QProcess::FailedToStart:
         m_ErrorText.prepend("Failed to start storage provider: ");
         m_ErrorText.append(m_StoreSCP->errorString());
         emit SignalStoreSCPError(m_ErrorText);
         m_ErrorText.clear();
         break;
     case QProcess::Crashed:
         m_ErrorText.prepend("Storage provider closed: ");
         m_ErrorText.append(m_StoreSCP->errorString());
         emit SignalStoreSCPError(m_ErrorText);
         m_ErrorText.clear();
         break;
     case QProcess::Timedout:
         m_ErrorText.prepend("Storage provider timeout: ");
         m_ErrorText.append(m_StoreSCP->errorString());
         emit SignalStoreSCPError(m_ErrorText);
         m_ErrorText.clear();
         break;
     case QProcess::WriteError:
         m_ErrorText.prepend("Storage provider write error: ");
         m_ErrorText.append(m_StoreSCP->errorString());
         emit SignalStoreSCPError(m_ErrorText);
         m_ErrorText.clear();
         break;
     case QProcess::ReadError:
         m_ErrorText.prepend("Storage provider read error: ");
         m_ErrorText.append(m_StoreSCP->errorString());
         emit SignalStoreSCPError(m_ErrorText);
         m_ErrorText.clear();
         break;
     case QProcess::UnknownError:
         m_ErrorText.prepend("Storage provider unknown error: ");
         m_ErrorText.append(m_StoreSCP->errorString());
         emit SignalStoreSCPError(m_ErrorText);
         m_ErrorText.clear();
         break;
     default:
         m_ErrorText.prepend("Storage provider unknown error: ");
         m_ErrorText.append(m_StoreSCP->errorString());
         emit SignalStoreSCPError(m_ErrorText);
         m_ErrorText.clear();
         break;
     }
 }
 
 void QmitkStoreSCPLauncher::OnStateChanged(QProcess::ProcessState status)
 {
     switch(status)
     {
     case QProcess::NotRunning:
         m_StatusText.prepend("Storage provider not running!");
         emit SignalStatusOfStoreSCP(m_StatusText);
         m_StatusText.clear();
         break;
     case QProcess::Starting:
         m_StatusText.prepend("Starting storage provider!");
         emit SignalStatusOfStoreSCP(m_StatusText);
         m_StatusText.clear();
         break;
     case QProcess::Running:
         m_StatusText.prepend(m_ArgumentList[0]).prepend(" Port: ").prepend(m_ArgumentList[2]).prepend(" AET: ").prepend("Storage provider running! ");
         emit SignalStatusOfStoreSCP(m_StatusText);
         m_StatusText.clear();
         break;
     default:
         m_StatusText.prepend("Storage provider unknown error!");
         emit SignalStatusOfStoreSCP(m_StatusText);
         m_StatusText.clear();
         break;
     }
 }
 
 void QmitkStoreSCPLauncher::SetArgumentList(QmitkStoreSCPLauncherBuilder* builder)
 {
     m_ArgumentList << *builder->GetPort() << QString("-aet") <<*builder->GetAETitle() << *builder->GetTransferSyntax()
         << *builder->GetOtherNetworkOptions() << *builder->GetMode() << QString("-od") << *builder->GetOutputDirectory();
 }
 
 void QmitkStoreSCPLauncher::DeleteTemporaryData()
 {
-    MITK_INFO << m_ArgumentList[7].toStdString();
-    QDir dir(m_ArgumentList[7]);
+    MITK_INFO << "About to delete: " << m_ArgumentList[7].toStdString();
+    
+    /* 
+     * Dangerous code, see bug 13021
+     *
+
+     QDir dir(m_ArgumentList[7]);
     QDirIterator it(dir);
     while(it.hasNext())
     {
         it.next();
         dir.remove(it.fileInfo().absoluteFilePath());
     }
+    */
 }
 
 QString QmitkStoreSCPLauncher::ArgumentListToQString()
 {
     QString argumentString;
     QStringListIterator argumentIterator(m_ArgumentList);
     while(argumentIterator.hasNext())
     {
         argumentString.append(" ");
         argumentString.append(argumentIterator.next());
     }
     return argumentString;
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkBrainNetworkAnalysis.dox b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkBrainNetworkAnalysis.dox
index 81963a008a..5a754a6cc2 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkBrainNetworkAnalysis.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkBrainNetworkAnalysis.dox
@@ -1,69 +1,69 @@
 /**
-\page org_brainnetworkanalysis The Brain Network Analysis Module
+\page org_mitk_views_brainnetworkanalysis The Brain Network Analysis View
 
-\image html QmitkBrainNetworkAnalysisViewIcon_64.png "Icon of the Module"
+\image html QmitkBrainNetworkAnalysisViewIcon_64.png "Icon of the View"
 
 \section QmitkBrainNetworkAnalysisUserManualSummary Summary
 
-This module can be used to create a network from a parcellation and a fiber image as well as to calculate and display network statistics.
+This view can be used to create a network from a parcellation and a fiber image as well as to calculate and display network statistics.
 
-This document will tell you how to use this module, but it is assumed that you already know how to use MITK in general.
+This document will tell you how to use this view, but it is assumed that you already know how to use MITK in general.
 
 Please see \ref QmitkBrainNetworkAnalysisUserManualDetails for more detailed information on usage and supported filters.
-If you encounter problems using the module, please have a look at the \ref QmitkBrainNetworkAnalysisUserManualTrouble page.
+If you encounter problems using the view, please have a look at the \ref QmitkBrainNetworkAnalysisUserManualTrouble page.
 
 \section QmitkBrainNetworkAnalysisUserManualDetails Details
 
 Manual sections:
 
 - \ref QmitkBrainNetworkAnalysisUserManualOverview 
 - \ref QmitkBrainNetworkAnalysisUserManualUsage
 - \ref QmitkBrainNetworkAnalysisUserManualTrouble
 
 \section QmitkBrainNetworkAnalysisUserManualOverview Overview
 
-This module is currently under heavy development and as such the interface as well as the capabilities are likely to change significantly between different versions.
+This view is currently under heavy development and as such the interface as well as the capabilities are likely to change significantly between different versions.
 
 This documentation describes the features of this current version.
 
 \image html QmitkBrainNetworkAnalysisInterface.png "The interface"
 
 \section QmitkBrainNetworkAnalysisUserManualUsage Usage
 
-To create a network select first a parcellation of the brain (e.g. as provided by <a href="http://surfer.nmr.mgh.harvard.edu/">freesurfer</a>  ) by CTRL+Leftclick and secondly a fiber image ( as created using tractography module). Then click on the "Create Network" button.
+To create a network select first a parcellation of the brain (e.g. as provided by <a href="http://surfer.nmr.mgh.harvard.edu/">freesurfer</a>  ) by CTRL+Leftclick and secondly a fiber image ( as created using tractography view). Then click on the "Create Network" button.
 
 To calculate network statistics select a network in the datamanager. At this time the following statistics are calculated for the entire network:
 
 <ul>
   <li> The number of vertices in the network
   <li> The number of edges in the network
   <li> The number of edges which have the same vertex as beginning and end point
   <li> The average degree of the nodes in the network
   <li> The connection density the network (the number of edges divided by the number of possible edges)
   <li> The unweighted efficiency of the network ( 1 divided by average path length, this is zero for disconnected graphs)
   <li> The global clustering
 </ul>
 
 Furthermore some statistics are calculated on a per node basis and displayed as histograms:
 
 <ul>
   <li> The degree of each node
   <li> The (unweighted) betweenness centrality of each node
   <li> The spread of shortest paths between each pair of nodes (For disconnected graphs the shortest paths with infinite length are omitted for readability)
 </ul>
 
 Additionally you have the option to create artificial networks, for testing purposes. Currently choices are:
 <ul>
   <li> A regular lattice, where each node is placed in a cubic pattern and only connected to its neighbours
   <li> A heterogenic sphere, where one node is placed in the center and connected to all nodes on the shell
   <li> A random network, where nodes are randomly placed on a spherical shell and randomly connected
 </ul>
 
 \section QmitkBrainNetworkAnalysisUserManualTrouble Troubleshooting
 
 No known problems.
 
 <B>All other problems.</B><BR>
 Please report to the MITK mailing list.
 See http://www.mitk.org/wiki/Mailinglist on how to do this.
 */
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkDiffusionImagingUserManual.dox b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkDiffusionImagingUserManual.dox
index 6f6906ec64..5124408e30 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkDiffusionImagingUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkDiffusionImagingUserManual.dox
@@ -1,122 +1,122 @@
 /**
-\page org_diffusion MITK Diffusion Imaging (MITK-DI)
+\page org_mitk_gui_qt_diffusionimaging MITK Diffusion Imaging (MITK-DI)
 
 This module provides means to diffusion weighted image reconstruction, visualization and quantification. Diffusion tensors as well as different q-ball reconstruction schemes are supported. Q-ball imaging aims at recovering more detailed information about the orientations of fibers from diffusion MRI measurements and, in particular, to resolve the orientations of crossing fibers.
 
 Available sections:
   - \ref QmitkDiffusionImagingUserManualIssues
   - \ref QmitkDiffusionImagingUserManualPreprocessing
   - \ref QmitkDiffusionImagingUserManualTensorReconstruction
   - \ref QmitkDiffusionImagingUserManualQBallReconstruction
   - \ref QmitkDiffusionImagingUserManualDicomImport
   - \ref QmitkDiffusionImagingUserManualQuantification
   - \ref QmitkDiffusionImagingUserManualVisualizationSettings
   - \ref QmitkDiffusionImagingUserManualReferences
   - \ref QmitkDiffusionImagingUserManualTechnicalDetail
   - \ref QmitkDiffusionImagingUserManualSubManuals
 
 \section QmitkDiffusionImagingUserManualIssues Known Issues
 
 \li <b>Dicom Import:</b> The dicom import has so far only been implemented for Siemens dicom images. MITK-DI is capable of reading the nrrd format, which is documented elsewhere [1, 2]. These files can be created by combining the raw image data with a corresponding textual header file. The file extension should be changed from *.nrrd to *.dwi or from *.nhdr to *.hdwi respectively in order to let MITK-DI recognize the diffusion related header information provided in the files.
 
 \section QmitkDiffusionImagingUserManualPreprocessing Preprocessing
 
 The preprocessing view gives an overview over the important features of a diffusion weighted image like the number of gradient directions, b-value and the measurement frame. Additionally it allows the extraction of the B0 image, reduction of gradient directions and the generation of a binary brain mask. The image volume can be modified by applying a new mesurement frame, which is useful if the measurement frame is not set correctly in the image header, or by averaging redundant gradient directions.
 
 \image html prepro1.png Preprocessing
 
 \section QmitkDiffusionImagingUserManualTensorReconstruction Tensor Reconstruction
 
 The tensor reconstruction view allows ITK based tensor reconstruction [3]. The advanced settings for ITK reconstruction let you configure a manual threshold on the non-diffusion weighted image. All voxels below this threshold will not be reconstructed and left blank. It is also possible to check for negative eigenvalues. The according voxels are also left blank.
 
 \image html tensor1.png ITK tensor reconstruction
 
 A few seconds (depending on the image size) after the reconstruction button is hit, a colored image should appear in the main window.
 
 \image html tensor4.png Tensor image after reconstruction
 
 The view also allows the generation of artificial diffusion weighted or Q-Ball images from the selected tensor image. The ODFs of the Q-Ball image are directly initialized from the tensor values and afterwards normalized. The diffusion weighted image is estimated using the l2-norm image of the tensor image as B0. The gradient images are afterwards generated using the standard tensor equation.
 
 \section QmitkDiffusionImagingUserManualQBallReconstruction Q-Ball Reconstruction
 
-The q-ball reonstruction bundle implements a variety of reconstruction methods. The different reconstruction methods are described in the following:
+The q-ball reonstruction view implements a variety of reconstruction methods. The different reconstruction methods are described in the following:
 \li <b>Numerical:</b> The original, numerical q-ball reconstruction presented by Tuch et al. [5]
 \li <b>Standard (SH):</b> Descoteaux's reconstruction based on spherical harmonic basis functions [6]
 \li <b>Solid Angle (SH):</b> Aganj's reconstruction with solid angle consideration [7]
 \li <b>ADC-profile only:</b> The ADC-profile reconstructed with spherical harmonic basis functions
 \li <b>Raw signal only:</b> The raw signal reconstructed with spherical harmonic basis functions
 
 \image html qballs1.png The q-ball resonstruction view
 
 B0 threshold works the same as in tensor reconstruction. The maximum l-level configures the size of the spherical harmonics basis. Larger l-values (e.g. l=8) allow higher levels of detail, lower levels are more stable against noise (e.g. l=4). Lambda is a regularisation parameter. Set it to 0 for no regularisation. lambda = 0.006 has proven to be a stable choice under various settings.
 
 \image html qballs2.png Advanced q-ball reconstruction settings
 
 This is how a q-ball image should initially look after reconstruction. Standard q-balls feature a relatively low GFA and thus appear rather dark. Adjust the level-window to solve this.
 
 \image html qballs3.png q-ball image after reconstruction
 
 \section QmitkDiffusionImagingUserManualDicomImport Dicom Import
 
 The dicom import does not cover all hardware manufacturers but only Siemens dicom images. MITK-DI is also capable of reading the nrrd format, which is documented elsewhere [1, 2]. These files can be created by combining the raw image data with a corresponding textual header file. The file extension should be changed from *.nrrd to *.dwi or from *.nhdr to *.hdwi respectively in order to let MITK-DI recognize the diffusion related header information provided in the files.
 
 In case your dicom images are readable by MITK-DI, select one or more input dicom folders and click import. Each input folder must only contain DICOM-images that can be combined into one vector-valued 3D output volume. Different patients must be loaded from different input-folders. The folders must not contain other acquisitions (e.g. T1,T2,localizer).
 
 In case many imports are performed at once, it is recommended to set the the optional output folder argument. This prevents the images from being kept in memory.
 
 \image html dicom1.png Dicom import
 
 The option "Average duplicate gradients" accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a "blur radius" > 0 is configured.
 
 \section QmitkDiffusionImagingUserManualQuantification Quantification
 
 The quantification view allows the derivation of different scalar anisotropy measures for the reconstructed tensors (Fractional Anisotropy, Relative Anisotropy, Axial Diffusivity, Radial Diffusivity) or q-balls (Generalized Fractional Anisotropy).
 
 \image html quantification.png Anisotropy quantification
 
 \section QmitkDiffusionImagingUserManualVisualizationSettings ODF Visualization Setting
 
 In this small view, the visualization of ODFs and diffusion images can be configured. Depending on the selected image in the data storage, different options are shown here.
 
 For tensor or q-ball images, the visibility of glyphs in the different render windows (T)ransversal, (S)agittal, and (C)oronal can be configured here. The maximal number of glyphs to display can also be configured here for. This is usefull to keep the system response time during rendering feasible. The other options configure normalization and scaling of the glyphs.
 
 In diffusion images, a slider lets you choose the desired image channel from the vector of images (each gradient direction one image) for rendering. Furthermore reinit can be performed and texture interpolation toggled.
 
 This is how a visualization with activated glyphs should look like:
 
 \image html visualization3.png Q-ball image with ODF glyph visibility toggled ON
 
 \section QmitkDiffusionImagingUserManualReferences References
 
 1. http://teem.sourceforge.net/nrrd/format.html
 
 2. http://www.cmake.org/Wiki/Getting_Started_with_the_NRRD_Format
 
 3. C.F.Westin, S.E.Maier, H.Mamata, A.Nabavi, F.A.Jolesz, R.Kikinis, "Processing and visualization for Diffusion tensor MRI", Medical image Analysis, 2002, pp 93-108
 
 5. Tuch, D.S., 2004. Q-ball imaging. Magn Reson Med 52, 1358-1372.
 
 6. Descoteaux, M., Angelino, E., Fitzgibbons, S., Deriche, R., 2007. Regularized, fast, and robust analytical Q-ball imaging. Magn Reson Med 58, 497-510.
 
 7. Aganj, I., Lenglet, C., Sapiro, G., 2009. ODF reconstruction in q-ball imaging with solid angle consideration. Proceedings of the Sixth IEEE International Symposium on Biomedical Imaging Boston, MA.
 
 8. Goh, A., Lenglet, C., Thompson, P.M., Vidal, R., 2009. Estimating Orientation Distribution Functions with Probability Density Constraints and Spatial Regularity. Med Image Comput Comput Assist Interv Int Conf Med Image Comput Comput Assist Interv LNCS 5761, 877 ff.
 
 \section QmitkDiffusionImagingUserManualTechnicalDetail Technical Information for Developers
 
-The diffusion imaging module uses additional properties beside the ones in use in other modules, for further information see \subpage DiffusionImagingPropertiesPage .
+The diffusion imaging module uses additional properties beside the ones in use in other modules, for further information see \ref DiffusionImagingPropertiesPage .
 
 \section QmitkDiffusionImagingUserManualSubManuals Manuals of componentes
 
 The MITK Diffusion tools consist of further components, which have their own documentation, see:
 
-  \li \subpage org_fiberprocessing
-  \li \subpage org_gibbstracking
-  \li \subpage org_odfdetails
-  \li \subpage org_pvanalysis
-  \li \subpage screenshot_maker
-  \li \subpage org_stochastictracking
-  \li \subpage org_ivim
-  \li \subpage org_brainnetworkanalysis
-  \li \subpage org_tractbasedspatialstatistics
+  \li \subpage org_mitk_views_fiberprocessing
+  \li \subpage org_mitk_views_gibbstracking
+  \li \subpage org_mitk_views_odfdetails
+  \li \subpage org_mitk_views_partialvolumeanalysisview
+  \li \subpage org_mitk_views_screenshotmaker
+  \li \subpage org_mitk_views_stochasticfibertracking
+  \li \subpage org_mitk_views_ivim
+  \li \subpage org_mitk_views_brainnetworkanalysis
+  \li \subpage org_mitk_views_tractbasedspatialstatistics
 */
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkFiberProcessingViewUserManual.dox b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkFiberProcessingViewUserManual.dox
index 9c1e982b69..6f1f6d6963 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkFiberProcessingViewUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkFiberProcessingViewUserManual.dox
@@ -1,23 +1,23 @@
 /**
-\page org_fiberprocessing Fiber Processing View
+\page org_mitk_views_fiberprocessing Fiber Processing View
 
 This view provides everything needed to process fiber bundles.
 
 \image html fiberprocessing.png The Fiber Processing View
 
 Fiber extraction:
 Place ROIs in the 2D render widgets (cricles or polygons) and extract fibers from the bundle that pass through these ROIs by selecting the according ROI and fiber bundle in the datamanger and starting the extraction. The ROIs can be combined via logical operations. All fibers that pass through the thus generated composite ROI are extracted. The extraction can also be performed using 3D ROIs represented as closed surface meshes. In this extraction method, the logical operations are not implemented at the moment.
 
 The selected fiber bundle can be smoothed by interpolating the fiber points using Kochanek splines with the specified number of points per cm. 
 
 If a float image with pixel values between 0 and 1 is selcted, the fiber bundle can be colored according to the pixel values.
 
 Generation of additional data from fiber bundles:
 \li Tract density image: generate a 2D heatmap from a fiber bundle
 \li Binary envelope: generate a binary image from a fiber bundle
 \li Fiber bundle image: generate a 2D rgba image representation of the fiber bundle
 \li Fiber endings image: generate a 2D binary image showing the locations of fiber endpoints
 \li Fiber endings pointset: generate a poinset containing the locations of fiber endpoints
 
 
 */
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkGibbsTrackingViewUserManual.dox b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkGibbsTrackingViewUserManual.dox
index 433c4e7775..8424ea110f 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkGibbsTrackingViewUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkGibbsTrackingViewUserManual.dox
@@ -1,44 +1,44 @@
 /**
-\page org_gibbstracking Gibbs Tracking View
+\page org_mitk_views_gibbstracking Gibbs Tracking View
 
 This view provides the user interface for the Gibbs Tracking algorithm, a global fiber tracking algorithm, originally proposed by Reisert et.al. [1].
 
 Available sections:
   - \ref QmitkGibbsTrackingUserManualInputData
   - \ref QmitkGibbsTrackingUserManualParameters
   - \ref QmitkGibbsTrackingUserManualTrackingSurveillance
   - \ref QmitkGibbsTrackingUserManualReferences
 
 \image html gibbstrackingview.png The Gibbs Tracking View
 
 \section QmitkGibbsTrackingUserManualInputData Input Data
 
 Mandatory Input:
 \li One Q-Ball image selected in the datamanager
 
 Optional Input:
 \li Mask Image: Float image used as probability mask for the generation of fiber segments. Usually used as binary brain mask to reduce the searchspace of the algorithm and to avoid fibers resulting from noise outside of the brain.
 
 \section QmitkGibbsTrackingUserManualParameters Q-Ball Reconstruction
 
 \li Number of iterations: More iterations causes the algorithm to be more stable but also to take longer to finish the tracking. Rcommended: 10�-10� iterations.
 \li Particle length/width/weight controlling the contribution of each particle to the model M
 \li Start and end temperature controlling how fast the process reaches a stable state. (usually no change needed)
 \li Weighting between the internal (affinity of the model to long and straigt fibers) and external energy (affinity of the model towards the data). (usually no change needed).
 \li Minimum fiber length constraint (in mm). Shorter fibers are discarded after the tracking.
 
 The automatic selection of parameters for the particle length/width and weight are determined directly from the input image using information about the image spacing and GFA.
 
 \image html gibbstrackingviewadvanced.png Advanced Tracking Parameters
 
 \section QmitkGibbsTrackingUserManualTrackingSurveillance Surveilance of the tracking process
 
 Once started, the tracking can be monitored via the textual output that informs about the tracking progress and several stats of the current state of the algorithm. 
 If enabled, the intermediate tracking results are displayed in the renderwindows each second. This live visualization should usually be disabled for performance reasons. It can be turned on and off during the tracking process via the according checkbox. The button next to this checkbox allows the visualization of only the next iteration step.
 
 \section QmitkGibbsTrackingUserManualReferences References
 
 [1] Reisert, M., Mader, I., Anastasopoulos, C., Weigel, M., Schnell, S., Kiselev, V.: Global fiber reconstruction becomes practical. Neuroimage 54 (2011) 955-962
 
 
 */
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkOdfDetailsViewUserManual.dox b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkOdfDetailsViewUserManual.dox
index 7885ebd5dc..f54439baa9 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkOdfDetailsViewUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkOdfDetailsViewUserManual.dox
@@ -1,8 +1,8 @@
 /**
-\page org_odfdetails ODF Details View
+\page org_mitk_views_odfdetails ODF Details View
 
 This view provides detailed information about the orentation distribution function at the current crosshair position (if a Tensor/Q-Ball image is selected). A visualization of the ODF as well as statistical information are displayed.
 
 \image html odfdetails.png The Gibbs Tracking View
 
 */
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkPartialVolumeAnalysisViewManual.dox b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkPartialVolumeAnalysisViewManual.dox
index a515ad40fc..7308a7018d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkPartialVolumeAnalysisViewManual.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkPartialVolumeAnalysisViewManual.dox
@@ -1,23 +1,23 @@
 /**
-\page org_pvanalysis Partial Volume Analysis
+\page org_mitk_views_partialvolumeanalysisview Partial Volume Analysis
 
 The "Partial Volume Analysis" view can be found in the "Quantification" perspective. It allows for robust quantification of diffusion or other scalar measures in the presents of two classes (e.g. fiber vs. non-fiber) and partial volume between them. The algorithm estimates a probabilistic segmentation of the three classes and returns a weighted average of the measure of interest within the each class. 
 
 \image html pvanalysisview.png The Partial Volume Analysis View
 
 \section QmitkPVAAnalysisUserManualExport  Export
 
 All measures are automatically written to the clipboard once the estimation is updated. The histogram export is provided by the button underneath the histogram. The values can be pasted to excel or any text editor. 
 
 \section QmitkPVAAnalysisUserManualAdvancedSettings  Advanced Settings
 
 Are not recommended for use yet.
 
 \section QmitkPVAAnalysisUserManualSuggestedReadings  Suggested Readings
 
 Diffusion tensor imaging in primary brain tumors: reproducible quantitative analysis of corpus callosum infiltration and contralateral involvement using a probabilistic mixture model.
 Stieltjes B, Schlüter M, Didinger B, Weber MA, Hahn HK, Parzer P, Rexilius J, Konrad-Verse O, Peitgen HO, Essig M.
 Neuroimage. 2006 Jun;31(2):531-42. Epub 2006 Feb 14.
 PMID: 16478665
 
 */
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkStochasticTrackingViewUserManual.dox b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkStochasticTrackingViewUserManual.dox
index 7573738c5e..0ed40d2add 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkStochasticTrackingViewUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkStochasticTrackingViewUserManual.dox
@@ -1,31 +1,31 @@
 /**
-\page org_stochastictracking Stochastic Tracking View
+\page org_mitk_views_stochasticfibertracking Stochastic Tracking View
 
 This view provides the user interface for the Stochastic Fibertracking algorithm, proposed by Ngo [1]. 
 
 Available sections:
   - \ref QmitkStochasticTrackingUserManualInputData
   - \ref QmitkStochasticTrackingUserManualParameters
   - \ref QmitkStochasticTrackingUserManualReferences
 
 \image html stochastictrackingview.png Stochastic Tracking View
 
 \section QmitkStochasticTrackingUserManualInputData Input Data
 
 Mandatory Input:
 
 \li One DWI Image image selected in the datamanager
 \li One or more ROIs selected in the datamanager
 
 For a successful execution of the stochastic tractography filter, a DWI input and a binary image defining the desired ROI are required. The ROI serves as the origin from where on the fibers are beeing tracked. To generate the seed ROI the segmentation view in the quantification perspective can be used or a binary image can be loaded.
 
 \section QmitkStochasticTrackingUserManualParameters Input Parameters
 
 \li Parameters such as max. tract length, number of seeds per voxel and likelihood cache size in MB can be controlled individually.
 \li After successfully setting necessary Input and Parameter, pressing the command button executes the algorithm.
 
 \section QmitkStochasticTrackingUserManualReferences References
 
 [1] Tri M. Ngo, Polina Golland, and Tri M. Ngo. A stochastic tractography system and applications, 2007
 
 */
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkTbssViewUserManual.dox b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkTbssViewUserManual.dox
index 26b49bbb0a..af6cbc7de5 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkTbssViewUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkTbssViewUserManual.dox
@@ -1,59 +1,59 @@
 /**
-\page org_tractbasedspatialstatistics The TBSS Module
+\page org_mitk_views_tractbasedspatialstatistics The TBSS View
 
-\image html tbss.png "Icon of the Module"
+\image html tbss.png "Icon of the View"
 
 \section QmitkTractbasedSpatialStatistics Summary
 
-This module can be used to locally explore data resulting from preprocessing with the TBSS module of FSL
+This view can be used to locally explore data resulting from preprocessing with the TBSS view of FSL
 
-This document will tell you how to use this module, but it is assumed that you already know how to use MITK in general and how to work with the TBSS module of FSL.
+This document will tell you how to use this view, but it is assumed that you already know how to use MITK in general and how to work with the TBSS view of FSL.
 
-If you encounter problems using the module, please have a look at the \ref QmitkTractbasedSpatialStatisticsUserManualTrouble page.
+If you encounter problems using the view, please have a look at the \ref QmitkTractbasedSpatialStatisticsUserManualTrouble page.
 
 Sections:
 
 - \ref QmitkTractbasedSpatialStatisticsUserManualOverview 
 - \ref QmitkTractbasedSpatialStatisticsUserManualFSLImport
 - \ref QmitkTractbasedSpatialStatisticsUserManualRois
 - \ref QmitkTractbasedSpatialStatisticsUserManualProfiles
 - \ref QmitkTractbasedSpatialStatisticsUserManualTroubleshooting
 - \ref QmitkTractbasedSpatialStatisticsUserManualReferences
 
 \section QmitkTractbasedSpatialStatisticsUserManualOverview Overview
 
-This module is currently under development and as such the interface as well as the capabilities are likely to change significantly between different versions. 
+This view is currently under development and as such the interface as well as the capabilities are likely to change significantly between different versions. 
 
 This documentation describes the features of this current version.
 
 
 
 \section QmitkTractbasedSpatialStatisticsUserManualFSLImport FSL Import
 The FSL import allows to import data that has been preprocessed by FSL. FSL creates output images that typically have names like all_FA_skeletonized.nii.gz that are 4-dimensional images that contain registered images of all subjects. By loading this 4D image into the datamanager and listing the groups with the correct number of subjects, in the order of occurrence in the 4D image, in the TBSS-View using the Add button and clicking the import subject data a TBSS file is created that contains all the information needed for tract analysis. The diffusion measure of the image can be set as well.
 
 \image html fslimport.png "FSL Import"
 
 \section QmitkTractbasedSpatialStatisticsUserManualRois Regions of Interest (ROIs)
 To create a ROI the mean FA skeleton (typically called mean_FA_skeleton.nii.gz) that is created by FSL should be loaded in to the datamanager and selected. By using the Pointlistwidget points should be set on the skeleton (make sure to select points with relatively high FA values). Points are set by first selecting the button with the '+' and than shift-leftclick in the image. When the correct image is selected in the datamanager the Create ROI button is enabled. Clicking this will create a region of interest that passes through the previously selected points. The roi appears in the datamanager. Before doing so, the name of the roi and the information on the structure on which the ROI lies can be set. This will be saved as extra information in the roi-image. Before the ROI is calculated, a pop-up window will ask the user to provide a threshold value. This should be the same threshold that was previously used in FSL to create a binary mask of the FA skeleton. When this is not done correctly, the region of interest will possible contain zero-valued voxels.
 
 \image html tbssRoi.png "Regions of Interest (ROIs)"
 
 
 \section QmitkTractbasedSpatialStatisticsUserManualProfiles
 
 y selecting a tbss image with group information and a region of interest image (as was created in a previous stap). A profile plot is drawn in the plot canvas. By clicking in the graph the crosshairs jump to the corresponding location in the image.
 
 \image html profiles.png "Profile plots"
 
 \section QmitkTractbasedSpatialStatisticsUserManualTroubleshooting Troubleshooting
 
 Please report to the MITK mailing list.
 See http://www.mitk.org/wiki/Mailinglist on how to do this.
 
 
 
 \section QmitkTractbasedSpatialStatisticsUserManualReferences References
 1. S.M. Smith, M. Jenkinson, H. Johansen-Berg, D. Rueckert, T.E. Nichols, C.E. Mackay, K.E. Watkins, O. Ciccarelli, M.Z. Cader, P.M. Matthews, and T.E.J. Behrens. Tract-based spatial statistics: Voxelwise analysis of multi-subject diffusion data. NeuroImage, 31:1487-1505, 2006.
 
 2. S.M. Smith, M. Jenkinson, M.W. Woolrich, C.F. Beckmann, T.E.J. Behrens, H. Johansen-Berg, P.R. Bannister, M. De Luca, I. Drobnjak, D.E. Flitney, R. Niazy, J. Saunders, J. Vickers, Y. Zhang, N. De Stefano, J.M. Brady, and P.M. Matthews. Advances in functional and structural MR image analysis and implementation as FSL. NeuroImage, 23(S1):208-219, 2004.
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkUserIVIMViewManual.dox b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkUserIVIMViewManual.dox
index 1ed8f2af10..b46d32f9dd 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkUserIVIMViewManual.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkUserIVIMViewManual.dox
@@ -1,41 +1,41 @@
 /**
-\page org_ivim Intra-voxel incoherent motion estimation (IVIM)
+\page org_mitk_views_ivim Intra-voxel incoherent motion estimation (IVIM)
 
 The required input for the "Intra-voxel incoherent motion estimation" (IVIM) is a diffusion weighted image (.dwi or .hdwi) that was acquired with several different b-values.
 
 \image html ivimview.png The IVIM View
 
 Once an input image is selected in the datamanager, the IVIM view allows for interactive exploration of the dataset (click around in the image and watch the estimated parameters in the figure of the view) as well as generation of f-, D-, and D*-maps (activate the checkmarks and press "Generate Output Images").
 
 The "neglect b<" threshold allows you to ignore b-values smaller then a threshold for the initial fit of f and D. D* is then estimated using all measurements.
 
 The exact values of the current fit are always given in the legend underneath the figure.
 
 \section QmitkDiffusionImagingUserManualInputData Region of interest analysis
 
 Create region of interest: To create a new segmentatin, open the "quantification" perspective, select the tab "Segmentation", and create a segmentation of the structure of interest. Alternatively, of course, you may also load a binary image from file or generate your segmentation in any other possible way. 
 
 IVIM in region of interset: Go back to the "IVIM" perspective and select both, the diffusion image and the segmentation (holding the CTRL key). A red message should appear "Averaging N voxels". 
 
 \section QmitkDiffusionImagingUserManualInputData Export
 
 All model parameters and corresponding curves can be exported to clipboard using the buttons underneath the figure.
 
 \section QmitkDiffusionImagingUserManualInputData Advanced Settings
 
 Advanced users, that know what they are doing, can change the method for the model-fit under "Advanced Settings" on the very bottom of the view. 3-param fit, linear fit of f/D, and fix D* are among the options.
 
 \section QmitkDiffusionImagingUserManualInputData Suggested Readings
 
 Toward an optimal distribution of b values for intravoxel incoherent motion imaging.
 Lemke A, Stieltjes B, Schad LR, Laun FB.
 Magn Reson Imaging. 2011 Jul;29(6):766-76. Epub 2011 May 5.
 PMID: 21549538
 
 Differentiation of pancreas carcinoma from healthy pancreatic tissue using multiple b-values: comparison of apparent diffusion coefficient and intravoxel incoherent motion derived parameters.
 Lemke A, Laun FB, Klauss M, Re TJ, Simon D, Delorme S, Schad LR, Stieltjes B.
 Invest Radiol. 2009 Dec;44(12):769-75.
 PMID: 19838121
 
 
 */
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
index a1c109e4b0..9bde8497bf 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
@@ -1,2138 +1,2138 @@
 /*===================================================================
 
 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 "QmitkPartialVolumeAnalysisView.h"
 
 #include <limits>
 
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qlineedit.h>
 #include <qclipboard.h>
 #include <qfiledialog.h>
 
 #include <berryIEditorPart.h>
 #include <berryIWorkbenchPage.h>
 #include <berryPlatform.h>
 
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkStdMultiWidgetEditor.h"
 #include "QmitkSliderNavigatorWidget.h"
 #include <QMessageBox>
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateOr.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkProperties.h"
 #include "mitkProgressBar.h"
 #include "mitkImageCast.h"
 #include "mitkImageToItk.h"
 #include "mitkITKImageImport.h"
 #include "mitkDataNodeObject.h"
 #include "mitkNodePredicateData.h"
 #include "mitkPlanarFigureInteractor.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkTensorImage.h"
 #include "mitkPlanarCircle.h"
 #include "mitkPlanarRectangle.h"
 #include "mitkPlanarPolygon.h"
 #include "mitkPartialVolumeAnalysisClusteringCalculator.h"
 #include "mitkDiffusionImage.h"
 
 #include <itkVectorImage.h>
 #include "itkTensorDerivedMeasurementsFilter.h"
 #include "itkDiffusionTensor3D.h"
 #include "itkCartesianToPolarVectorImageFilter.h"
 #include "itkPolarToCartesianVectorImageFilter.h"
 #include "itkBinaryThresholdImageFilter.h"
 #include "itkMaskImageFilter.h"
 #include "itkCastImageFilter.h"
 #include "itkImageMomentsCalculator.h"
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 
 #include <vnl/vnl_vector.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 #define PVA_PI M_PI
 
 const std::string QmitkPartialVolumeAnalysisView::VIEW_ID =
     "org.mitk.views.partialvolumeanalysisview";
 
 class QmitkRequestStatisticsUpdateEvent : public QEvent
 {
 public:
   enum Type
   {
     StatisticsUpdateRequest = QEvent::MaxUser - 1025
   };
 
   QmitkRequestStatisticsUpdateEvent()
     : QEvent( (QEvent::Type) StatisticsUpdateRequest ) {};
 };
 
 
 
 typedef itk::Image<short, 3>                 ImageType;
 typedef itk::Image<float, 3>                 FloatImageType;
 typedef itk::Image<itk::Vector<float,3>, 3>  VectorImageType;
 
 inline bool my_isnan(float x)
 {
   volatile float d = x;
 
   if(d!=d)
     return true;
 
   if(d==d)
     return false;
   return d != d;
 
 }
 
 QmitkPartialVolumeAnalysisView::QmitkPartialVolumeAnalysisView(QObject * /*parent*/, const char * /*name*/)
   : //QmitkFunctionality(),
     m_Controls( NULL ),
     m_TimeStepperAdapter( NULL ),
     m_MeasurementInfoRenderer(0),
     m_MeasurementInfoAnnotation(0),
     m_SelectedImageNodes(  ),
     m_SelectedImage( NULL ),
     m_SelectedMaskNode( NULL ),
     m_SelectedImageMask( NULL ),
     m_SelectedPlanarFigureNodes(0),
     m_SelectedPlanarFigure( NULL ),
     m_IsTensorImage(false),
     m_FAImage(0),
     m_RDImage(0),
     m_ADImage(0),
     m_MDImage(0),
     m_CAImage(0),
     //  m_DirectionImage(0),
     m_DirectionComp1Image(0),
     m_DirectionComp2Image(0),
     m_AngularErrorImage(0),
     m_SelectedRenderWindow(NULL),
     m_LastRenderWindow(NULL),
     m_ImageObserverTag( -1 ),
     m_ImageMaskObserverTag( -1 ),
     m_PlanarFigureObserverTag( -1 ),
     m_CurrentStatisticsValid( false ),
     m_StatisticsUpdatePending( false ),
     m_GaussianSigmaChangedSliding(false),
     m_NumberBinsSliding(false),
     m_UpsamplingChangedSliding(false),
     m_ClusteringResult(NULL),
     m_EllipseCounter(0),
     m_RectangleCounter(0),
     m_PolygonCounter(0),
     m_CurrentFigureNodeInitialized(false),
     m_QuantifyClass(2),
     m_IconTexOFF(new QIcon(":/QmitkPartialVolumeAnalysisView/texIntOFFIcon.png")),
     m_IconTexON(new QIcon(":/QmitkPartialVolumeAnalysisView/texIntONIcon.png")),
     m_TexIsOn(true),
     m_Visible(false)
 {
 
 }
 
 
 QmitkPartialVolumeAnalysisView::~QmitkPartialVolumeAnalysisView()
 {
   if ( m_SelectedImage.IsNotNull() )
     m_SelectedImage->RemoveObserver( m_ImageObserverTag );
   if ( m_SelectedImageMask.IsNotNull() )
     m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
   if ( m_SelectedPlanarFigure.IsNotNull() )
   {
     m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
     m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
   }
 
   this->GetDataStorage()->AddNodeEvent -= mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
       , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage );
 
   m_SelectedPlanarFigureNodes->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                            , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
   m_SelectedPlanarFigureNodes->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                            , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
   m_SelectedPlanarFigureNodes->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                                , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 
   m_SelectedImageNodes->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                     , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
   m_SelectedImageNodes->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                     , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
   m_SelectedImageNodes->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                         , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 }
 
 
 void QmitkPartialVolumeAnalysisView::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == NULL)
   {
     m_Controls = new Ui::QmitkPartialVolumeAnalysisViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
   }
 
   SetHistogramVisibility();
 
   m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
 
   m_Controls->m_SimilarAnglesFrame->setVisible(false);
   m_Controls->m_SimilarAnglesLabel->setVisible(false);
 
   vtkTextProperty *textProp = vtkTextProperty::New();
   textProp->SetColor(1.0, 1.0, 1.0);
 
   m_MeasurementInfoAnnotation = vtkCornerAnnotation::New();
   m_MeasurementInfoAnnotation->SetMaximumFontSize(12);
   m_MeasurementInfoAnnotation->SetTextProperty(textProp);
 
   m_MeasurementInfoRenderer = vtkRenderer::New();
   m_MeasurementInfoRenderer->AddActor(m_MeasurementInfoAnnotation);
 
   m_SelectedPlanarFigureNodes = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
 
   m_SelectedPlanarFigureNodes->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                         , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
   m_SelectedPlanarFigureNodes->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                         , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
   m_SelectedPlanarFigureNodes->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                             , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 
   m_SelectedImageNodes = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
 
   m_SelectedImageNodes->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                      , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 
   m_SelectedImageNodes->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                  , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
   m_SelectedImageNodes->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                  , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
   this->GetDataStorage()->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                     , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage ) );
 
   Select(NULL,true,true);
 
   SetAdvancedVisibility();
 }
 
 void QmitkPartialVolumeAnalysisView::SetHistogramVisibility()
 {
   m_Controls->m_HistogramWidget->setVisible(m_Controls->m_DisplayHistogramCheckbox->isChecked());
 }
 
 void QmitkPartialVolumeAnalysisView::SetAdvancedVisibility()
 {
   m_Controls->frame_7->setVisible(m_Controls->m_AdvancedCheckbox->isChecked());
 }
 
 void QmitkPartialVolumeAnalysisView::CreateConnections()
 {
   if ( m_Controls )
   {
 
     connect( m_Controls->m_DisplayHistogramCheckbox, SIGNAL( clicked() )
              , this, SLOT( SetHistogramVisibility() ) );
 
     connect( m_Controls->m_AdvancedCheckbox, SIGNAL( clicked() )
              , this, SLOT( SetAdvancedVisibility() ) );
 
 
     connect( m_Controls->m_NumberBinsSlider, SIGNAL( sliderReleased () ),
              this, SLOT( NumberBinsReleasedSlider( ) ) );
     connect( m_Controls->m_UpsamplingSlider, SIGNAL( sliderReleased(  ) ),
              this, SLOT( UpsamplingReleasedSlider( ) ) );
     connect( m_Controls->m_GaussianSigmaSlider, SIGNAL( sliderReleased(  ) ),
              this, SLOT( GaussianSigmaReleasedSlider(  ) ) );
     connect( m_Controls->m_SimilarAnglesSlider, SIGNAL( sliderReleased(  ) ),
              this, SLOT( SimilarAnglesReleasedSlider(  ) ) );
 
     connect( m_Controls->m_NumberBinsSlider, SIGNAL( valueChanged (int) ),
              this, SLOT( NumberBinsChangedSlider( int ) ) );
     connect( m_Controls->m_UpsamplingSlider, SIGNAL( valueChanged( int ) ),
              this, SLOT( UpsamplingChangedSlider( int ) ) );
     connect( m_Controls->m_GaussianSigmaSlider, SIGNAL( valueChanged( int ) ),
              this, SLOT( GaussianSigmaChangedSlider( int ) ) );
     connect( m_Controls->m_SimilarAnglesSlider, SIGNAL( valueChanged( int ) ),
              this, SLOT( SimilarAnglesChangedSlider(int) ) );
 
     connect( m_Controls->m_OpacitySlider, SIGNAL( valueChanged( int ) ),
              this, SLOT( OpacityChangedSlider(int) ) );
 
     connect( (QObject*)(m_Controls->m_ButtonCopyHistogramToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(ToClipBoard()));
 
     connect( m_Controls->m_CircleButton, SIGNAL( clicked() )
              , this, SLOT( ActionDrawEllipseTriggered() ) );
 
     connect( m_Controls->m_RectangleButton, SIGNAL( clicked() )
              , this, SLOT( ActionDrawRectangleTriggered() ) );
 
     connect( m_Controls->m_PolygonButton, SIGNAL( clicked() )
              , this, SLOT( ActionDrawPolygonTriggered() ) );
 
     connect( m_Controls->m_GreenRadio, SIGNAL( clicked(bool) )
              , this, SLOT( GreenRadio(bool) ) );
 
     connect( m_Controls->m_PartialVolumeRadio, SIGNAL( clicked(bool) )
              , this, SLOT( PartialVolumeRadio(bool) ) );
 
     connect( m_Controls->m_BlueRadio, SIGNAL( clicked(bool) )
              , this, SLOT( BlueRadio(bool) ) );
 
     connect( m_Controls->m_AllRadio, SIGNAL( clicked(bool) )
              , this, SLOT( AllRadio(bool) ) );
 
     connect( m_Controls->m_EstimateCircle, SIGNAL( clicked() )
              , this, SLOT( EstimateCircle() ) );
 
     connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
 
     connect( m_Controls->m_ExportClusteringResultsButton, SIGNAL(clicked()), this, SLOT(ExportClusteringResults()));
   }
 }
 
 void QmitkPartialVolumeAnalysisView::ExportClusteringResults()
 {
   if (m_ClusteringResult.IsNull() || m_SelectedImage.IsNull())
     return;
 
   mitk::Geometry3D* geometry = m_SelectedImage->GetGeometry();
 
   itk::Image< short, 3>::Pointer referenceImage = itk::Image< short, 3>::New();
 
   mitk::Vector3D newSpacing = geometry->GetSpacing();
   mitk::Point3D newOrigin = geometry->GetOrigin();
   mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
   newOrigin[0] += bounds.GetElement(0);
   newOrigin[1] += bounds.GetElement(2);
   newOrigin[2] += bounds.GetElement(4);
   itk::Matrix<double, 3, 3> newDirection;
   itk::ImageRegion<3> imageRegion;
   for (int i=0; i<3; i++)
     for (int j=0; j<3; j++)
       newDirection[j][i] = geometry->GetMatrixColumn(i)[j]/newSpacing[j];
   imageRegion.SetSize(0, geometry->GetExtent(0));
   imageRegion.SetSize(1, geometry->GetExtent(1));
   imageRegion.SetSize(2, geometry->GetExtent(2));
 
   // apply new image parameters
   referenceImage->SetSpacing( newSpacing );
   referenceImage->SetOrigin( newOrigin );
   referenceImage->SetDirection( newDirection );
   referenceImage->SetRegions( imageRegion );
   referenceImage->Allocate();
 
   typedef itk::Image< float, 3 > OutType;
   mitk::Image::Pointer mitkInImage = dynamic_cast<mitk::Image*>(m_ClusteringResult->GetData());
 
   typedef itk::Image< itk::RGBAPixel<unsigned char>, 3 > ItkRgbaImageType;
   typedef mitk::ImageToItk< ItkRgbaImageType > CasterType;
 
   CasterType::Pointer caster = CasterType::New();
   caster->SetInput(mitkInImage);
   caster->Update();
   ItkRgbaImageType::Pointer itkInImage = caster->GetOutput();
 
   typedef itk::ExtractChannelFromRgbaImageFilter< itk::Image< short, 3>, OutType > ExtractionFilterType;
   ExtractionFilterType::Pointer filter = ExtractionFilterType::New();
   filter->SetInput(itkInImage);
   filter->SetChannel(ExtractionFilterType::ALPHA);
   filter->SetReferenceImage(referenceImage);
   filter->Update();
   OutType::Pointer outImg = filter->GetOutput();
 
   mitk::Image::Pointer img = mitk::Image::New();  img->InitializeByItk(outImg.GetPointer());
   img->SetVolume(outImg->GetBufferPointer());
 
   // init data node
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   node->SetData(img);
   node->SetName("Clustering Result");
   GetDataStorage()->Add(node);
 }
 
 void QmitkPartialVolumeAnalysisView::EstimateCircle()
 {
   typedef itk::Image<unsigned char, 3> SegImageType;
   SegImageType::Pointer mask_itk = SegImageType::New();
 
   typedef mitk::ImageToItk<SegImageType> CastType;
   CastType::Pointer caster = CastType::New();
   caster->SetInput(m_SelectedImageMask);
   caster->Update();
 
   typedef itk::ImageMomentsCalculator< SegImageType > MomentsType;
   MomentsType::Pointer momentsCalc = MomentsType::New();
   momentsCalc->SetImage(caster->GetOutput());
   momentsCalc->Compute();
   MomentsType::VectorType cog = momentsCalc->GetCenterOfGravity();
   MomentsType::MatrixType axes = momentsCalc->GetPrincipalAxes();
   MomentsType::VectorType moments = momentsCalc->GetPrincipalMoments();
 
   // moments-coord conversion
   // third coordinate min oder max?
 
   // max-min = extent
 
   MomentsType::AffineTransformPointer trafo = momentsCalc->GetPhysicalAxesToPrincipalAxesTransform();
 
   itk::ImageRegionIterator<SegImageType>
       itimage(caster->GetOutput(), caster->GetOutput()->GetLargestPossibleRegion());
   itimage = itimage.Begin();
 
   double max = -9999999999.0;
   double min =  9999999999.0;
 
   while( !itimage.IsAtEnd() )
   {
     if(itimage.Get())
     {
       ImageType::IndexType index = itimage.GetIndex();
 
       itk::Point<float,3> point;
       caster->GetOutput()->TransformIndexToPhysicalPoint(index,point);
 
       itk::Point<float,3> newPoint;
       newPoint = trafo->TransformPoint(point);
 
       if(newPoint[2]<min)
         min = newPoint[2];
 
       if(newPoint[2]>max)
         max = newPoint[2];
     }
     ++itimage;
   }
 
   double extent = max - min;
   MITK_INFO << "EXTENT = " << extent;
 
   mitk::Point3D origin;
   mitk::Vector3D right, bottom, normal;
 
   double factor = 1000.0;
   mitk::FillVector3D(origin, cog[0]-factor*axes[1][0]-factor*axes[2][0],
                      cog[1]-factor*axes[1][1]-factor*axes[2][1],
                      cog[2]-factor*axes[1][2]-factor*axes[2][2]);
   //          mitk::FillVector3D(normal, axis[0][0],axis[0][1],axis[0][2]);
   mitk::FillVector3D(bottom, 2*factor*axes[1][0], 2*factor*axes[1][1], 2*factor*axes[1][2]);
   mitk::FillVector3D(right,  2*factor*axes[2][0], 2*factor*axes[2][1], 2*factor*axes[2][2]);
 
   mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
   planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector());
   planegeometry->SetOrigin(origin);
 
   double len1 = sqrt(axes[1][0]*axes[1][0] + axes[1][1]*axes[1][1] + axes[1][2]*axes[1][2]);
   double len2 = sqrt(axes[2][0]*axes[2][0] + axes[2][1]*axes[2][1] + axes[2][2]*axes[2][2]);
 
   mitk::Point2D point1;
   point1[0] = factor*len1;
   point1[1] = factor*len2;
 
   mitk::Point2D point2;
   point2[0] = factor*len1+extent*.5;
   point2[1] = factor*len2;
 
   mitk::PlanarCircle::Pointer circle = mitk::PlanarCircle::New();
   circle->SetGeometry2D(planegeometry);
   circle->PlaceFigure( point1 );
   circle->SetControlPoint(0,point1);
   circle->SetControlPoint(1,point2);
   //circle->SetCurrentControlPoint( point2 );
 
   mitk::PlanarFigure::PolyLineType polyline = circle->GetPolyLine( 0 );
   MITK_INFO << "SIZE of planar figure polyline: " << polyline.size();
 
   AddFigureToDataStorage(circle, "Circle");
 
 }
 
 bool QmitkPartialVolumeAnalysisView::AssertDrawingIsPossible(bool checked)
 {
   if (m_SelectedImageNodes->GetNode().IsNull())
   {
     checked = false;
     this->HandleException("Please select an image!", dynamic_cast<QWidget *>(this->parent()), true);
     return false;
   }
 
   //this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(false);
 
   return checked;
 }
 
 void QmitkPartialVolumeAnalysisView::ActionDrawEllipseTriggered()
 {
   bool checked = m_Controls->m_CircleButton->isChecked();
   if(!this->AssertDrawingIsPossible(checked))
     return;
 
   mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
   this->AddFigureToDataStorage(figure, QString("Circle%1").arg(++m_EllipseCounter));
 
   MITK_INFO << "PlanarCircle created ...";
 }
 
 void QmitkPartialVolumeAnalysisView::ActionDrawRectangleTriggered()
 {
   bool checked = m_Controls->m_RectangleButton->isChecked();
   if(!this->AssertDrawingIsPossible(checked))
     return;
 
   mitk::PlanarRectangle::Pointer figure = mitk::PlanarRectangle::New();
   this->AddFigureToDataStorage(figure, QString("Rectangle%1").arg(++m_RectangleCounter));
 
   MITK_INFO << "PlanarRectangle created ...";
 }
 
 void QmitkPartialVolumeAnalysisView::ActionDrawPolygonTriggered()
 {
   bool checked = m_Controls->m_PolygonButton->isChecked();
   if(!this->AssertDrawingIsPossible(checked))
     return;
 
   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
   figure->ClosedOn();
   this->AddFigureToDataStorage(figure, QString("Polygon%1").arg(++m_PolygonCounter));
 
   MITK_INFO << "PlanarPolygon created ...";
 }
 
 void QmitkPartialVolumeAnalysisView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name,
                                                             const char *propertyKey, mitk::BaseProperty *property )
 {
 
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetName(name.toStdString());
   newNode->SetData(figure);
 
   // Add custom property, if available
   if ( (propertyKey != NULL) && (property != NULL) )
   {
     newNode->AddProperty( propertyKey, property );
   }
 
   // figure drawn on the topmost layer / image
   this->GetDataStorage()->Add(newNode, m_SelectedImageNodes->GetNode() );
 
   QList<mitk::DataNode::Pointer> selectedNodes = this->GetDataManagerSelection();
   for(unsigned int i = 0; i < selectedNodes.size(); i++)
   {
     selectedNodes[i]->SetSelected(false);
   }
 
   std::vector<mitk::DataNode *> selectedPFNodes = m_SelectedPlanarFigureNodes->GetNodes();
   for(unsigned int i = 0; i < selectedPFNodes.size(); i++)
   {
     selectedPFNodes[i]->SetSelected(false);
   }
   newNode->SetSelected(true);
 
   Select(newNode);
 }
 
 void QmitkPartialVolumeAnalysisView::PlanarFigureInitialized()
 {
   if(m_SelectedPlanarFigureNodes->GetNode().IsNull())
     return;
 
   m_CurrentFigureNodeInitialized = true;
 
   this->Select(m_SelectedPlanarFigureNodes->GetNode());
 
   m_Controls->m_CircleButton->setChecked(false);
   m_Controls->m_RectangleButton->setChecked(false);
   m_Controls->m_PolygonButton->setChecked(false);
 
   //this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(true);
   this->RequestStatisticsUpdate();
 
 }
 
 void QmitkPartialVolumeAnalysisView::PlanarFigureFocus(mitk::DataNode* node)
 {
   mitk::PlanarFigure* _PlanarFigure = 0;
   _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
   if (_PlanarFigure)
   {
 
     FindRenderWindow(node);
 
     const mitk::PlaneGeometry
         * _PlaneGeometry =
         dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
 
     // make node visible
     if (m_SelectedRenderWindow)
     {
       mitk::Point3D centerP = _PlaneGeometry->GetOrigin();
       m_SelectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
             centerP, _PlaneGeometry->GetNormal());
       m_SelectedRenderWindow->GetSliceNavigationController()->SelectSliceByPoint(
             centerP);
     }
   }
 }
 
 void QmitkPartialVolumeAnalysisView::FindRenderWindow(mitk::DataNode* node)
 {
   if (node && dynamic_cast<mitk::PlanarFigure*> (node->GetData()))
   {
     m_SelectedRenderWindow = 0;
     bool PlanarFigureInitializedWindow = false;
 
-    foreach(QmitkRenderWindow * window, this->GetRenderWindowPart()->GetRenderWindows().values())
+    foreach(QmitkRenderWindow * window, this->GetRenderWindowPart()->GetQmitkRenderWindows().values())
     {
       if (!m_SelectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, window->GetRenderer()))
       {
         m_SelectedRenderWindow = window;
       }
     }
   }
 }
 
 
 void QmitkPartialVolumeAnalysisView::OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes)
 {
 
   if ( !m_Visible )
   {
     return;
   }
 
   if ( nodes.empty() || nodes.size() > 1 )
   {
     // Nothing to do: invalidate image, clear statistics, histogram, and GUI
     return;
   }
 
   Select(nodes.front());
 
 }
 
 void QmitkPartialVolumeAnalysisView::Select( mitk::DataNode::Pointer node, bool clearMaskOnFirstArgNULL, bool clearImageOnFirstArgNULL )
 {
   // Clear any unreferenced images
   this->RemoveOrphanImages();
 
   bool somethingChanged = false;
   if(node.IsNull())
   {
     somethingChanged = true;
 
     if(clearMaskOnFirstArgNULL)
     {
       if ( (m_SelectedImageMask.IsNotNull()) && (m_ImageMaskObserverTag >= 0) )
       {
         m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
         m_ImageMaskObserverTag = -1;
       }
 
       if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_PlanarFigureObserverTag >= 0) )
       {
         m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
         m_PlanarFigureObserverTag = -1;
       }
 
       if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_InitializedObserverTag >= 0) )
       {
         m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
         m_InitializedObserverTag = -1;
       }
 
       m_SelectedPlanarFigure = NULL;
       m_SelectedPlanarFigureNodes->RemoveAllNodes();
       m_CurrentFigureNodeInitialized = false;
       m_SelectedRenderWindow = 0;
 
       m_SelectedMaskNode = NULL;
       m_SelectedImageMask = NULL;
 
     }
 
     if(clearImageOnFirstArgNULL)
     {
       if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
       {
         m_SelectedImage->RemoveObserver( m_ImageObserverTag );
         m_ImageObserverTag = -1;
       }
 
       m_SelectedImageNodes->RemoveAllNodes();
       m_SelectedImage = NULL;
 
       m_IsTensorImage = false;
       m_FAImage = NULL;
       m_RDImage = NULL;
       m_ADImage = NULL;
       m_MDImage = NULL;
       m_CAImage = NULL;
       m_DirectionComp1Image = NULL;
       m_DirectionComp2Image = NULL;
       m_AngularErrorImage = NULL;
 
       m_Controls->m_SimilarAnglesFrame->setVisible(false);
       m_Controls->m_SimilarAnglesLabel->setVisible(false);
     }
   }
   else
   {
     typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
     ITKCommandType::Pointer changeListener;
     changeListener = ITKCommandType::New();
     changeListener->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::RequestStatisticsUpdate );
 
     // Get selected element
     mitk::TensorImage *selectedTensorImage = dynamic_cast< mitk::TensorImage * >( node->GetData() );
     mitk::Image *selectedImage = dynamic_cast< mitk::Image * >( node->GetData() );
     mitk::PlanarFigure *selectedPlanar = dynamic_cast< mitk::PlanarFigure * >( node->GetData() );
 
     bool isMask = false;
     bool isImage = false;
     bool isPlanar = false;
     bool isTensorImage = false;
 
     if (selectedTensorImage != NULL)
     {
       isTensorImage = true;
     }
     else if(selectedImage != NULL)
     {
       node->GetPropertyValue("binary", isMask);
       isImage = !isMask;
     }
     else if ( (selectedPlanar != NULL) )
     {
       isPlanar = true;
     }
 
     // image
     if(isImage && selectedImage->GetDimension()==3)
     {
       if(selectedImage != m_SelectedImage.GetPointer())
       {
         somethingChanged = true;
 
         if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
         {
           m_SelectedImage->RemoveObserver( m_ImageObserverTag );
           m_ImageObserverTag = -1;
         }
 
         *m_SelectedImageNodes = node;
         m_SelectedImage = selectedImage;
         m_IsTensorImage = false;
         m_FAImage = NULL;
         m_RDImage = NULL;
         m_ADImage = NULL;
         m_MDImage = NULL;
         m_CAImage = NULL;
         m_DirectionComp1Image = NULL;
         m_DirectionComp2Image = NULL;
         m_AngularErrorImage = NULL;
 
         // Add change listeners to selected objects
         m_ImageObserverTag = m_SelectedImage->AddObserver(
               itk::ModifiedEvent(), changeListener );
 
         m_Controls->m_SimilarAnglesFrame->setVisible(false);
         m_Controls->m_SimilarAnglesLabel->setVisible(false);
 
         m_Controls->m_SelectedImageLabel->setText( m_SelectedImageNodes->GetNode()->GetName().c_str() );
       }
     }
 
     //planar
     if(isPlanar)
     {
       if(selectedPlanar != m_SelectedPlanarFigure.GetPointer())
       {
         MITK_INFO << "Planar selection changed";
         somethingChanged = true;
 
         // Possibly previous change listeners
         if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_PlanarFigureObserverTag >= 0) )
         {
           m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
           m_PlanarFigureObserverTag = -1;
         }
 
         if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_InitializedObserverTag >= 0) )
         {
           m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
           m_InitializedObserverTag = -1;
         }
 
         m_SelectedPlanarFigure = selectedPlanar;
         *m_SelectedPlanarFigureNodes = node;
         m_CurrentFigureNodeInitialized = selectedPlanar->IsPlaced();
 
         m_SelectedMaskNode = NULL;
         m_SelectedImageMask = NULL;
 
         m_PlanarFigureObserverTag = m_SelectedPlanarFigure->AddObserver(
               mitk::EndInteractionPlanarFigureEvent(), changeListener );
 
         if(!m_CurrentFigureNodeInitialized)
         {
           typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
           ITKCommandType::Pointer initializationCommand;
           initializationCommand = ITKCommandType::New();
 
           // set the callback function of the member command
           initializationCommand->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::PlanarFigureInitialized );
 
           // add an observer
           m_InitializedObserverTag = selectedPlanar->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
         }
 
         m_Controls->m_SelectedMaskLabel->setText( m_SelectedPlanarFigureNodes->GetNode()->GetName().c_str() );
         PlanarFigureFocus(node);
       }
     }
 
     //mask
     if(isMask && selectedImage->GetDimension()==3)
     {
       if(selectedImage != m_SelectedImage.GetPointer())
       {
         somethingChanged = true;
 
         if ( (m_SelectedImageMask.IsNotNull()) && (m_ImageMaskObserverTag >= 0) )
         {
           m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
           m_ImageMaskObserverTag = -1;
         }
 
         m_SelectedMaskNode = node;
         m_SelectedImageMask = selectedImage;
         m_SelectedPlanarFigure = NULL;
         m_SelectedPlanarFigureNodes->RemoveAllNodes();
 
         m_ImageMaskObserverTag = m_SelectedImageMask->AddObserver(
               itk::ModifiedEvent(), changeListener );
 
         m_Controls->m_SelectedMaskLabel->setText( m_SelectedMaskNode->GetName().c_str() );
 
       }
     }
 
     //tensor image
     if(isTensorImage && selectedTensorImage->GetDimension()==3)
     {
       if(selectedImage != m_SelectedImage.GetPointer())
       {
         somethingChanged = true;
 
         if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
         {
           m_SelectedImage->RemoveObserver( m_ImageObserverTag );
           m_ImageObserverTag = -1;
         }
 
         *m_SelectedImageNodes = node;
         m_SelectedImage = selectedImage;
 
         m_IsTensorImage = true;
 
         ExtractTensorImages(selectedImage);
 
         // Add change listeners to selected objects
         m_ImageObserverTag = m_SelectedImage->AddObserver(
               itk::ModifiedEvent(), changeListener );
 
         m_Controls->m_SimilarAnglesFrame->setVisible(true);
         m_Controls->m_SimilarAnglesLabel->setVisible(true);
 
         m_Controls->m_SelectedImageLabel->setText( m_SelectedImageNodes->GetNode()->GetName().c_str() );
       }
     }
   }
 
   if(somethingChanged)
   {
     this->SetMeasurementInfoToRenderWindow("");
 
     if(m_SelectedPlanarFigure.IsNull() && m_SelectedImageMask.IsNull() )
     {
       m_Controls->m_SelectedMaskLabel->setText( "-" );
       m_Controls->m_ResampleOptionsFrame->setEnabled(false);
       m_Controls->m_HistogramWidget->setEnabled(false);
       m_Controls->m_ClassSelector->setEnabled(false);
       m_Controls->m_DisplayHistogramCheckbox->setEnabled(false);
       m_Controls->m_AdvancedCheckbox->setEnabled(false);
       m_Controls->frame_7->setEnabled(false);
     }
     else
     {
       m_Controls->m_ResampleOptionsFrame->setEnabled(true);
       m_Controls->m_HistogramWidget->setEnabled(true);
       m_Controls->m_ClassSelector->setEnabled(true);
       m_Controls->m_DisplayHistogramCheckbox->setEnabled(true);
       m_Controls->m_AdvancedCheckbox->setEnabled(true);
       m_Controls->frame_7->setEnabled(true);
     }
 
     // Clear statistics / histogram GUI if nothing is selected
     if ( m_SelectedImage.IsNull() )
     {
       m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
       m_Controls->m_OpacityFrame->setEnabled(false);
       m_Controls->m_SelectedImageLabel->setText( "-" );
     }
     else
     {
       m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
       m_Controls->m_OpacityFrame->setEnabled(true);
     }
 
     if( m_SelectedImage.IsNull()
         || (m_SelectedPlanarFigure.IsNull() && m_SelectedImageMask.IsNull()) )
     {
       m_Controls->m_HistogramWidget->ClearItemModel();
       m_CurrentStatisticsValid = false;
     }
     else
     {
       this->RequestStatisticsUpdate();
     }
   }
 }
 
 
 void QmitkPartialVolumeAnalysisView::ShowClusteringResults()
 {
 
   typedef itk::Image<unsigned char, 3> MaskImageType;
   mitk::Image::Pointer mask = 0;
   MaskImageType::Pointer itkmask = 0;
 
   if(m_IsTensorImage && m_Controls->m_SimilarAnglesSlider->value() != 0)
   {
     typedef itk::Image<float, 3> AngularErrorImageType;
     typedef mitk::ImageToItk<AngularErrorImageType> CastType;
     CastType::Pointer caster = CastType::New();
     caster->SetInput(m_AngularErrorImage);
     caster->Update();
 
     typedef itk::BinaryThresholdImageFilter< AngularErrorImageType, MaskImageType > ThreshType;
     ThreshType::Pointer thresh = ThreshType::New();
     thresh->SetUpperThreshold((90-m_Controls->m_SimilarAnglesSlider->value())*(PVA_PI/180.0));
     thresh->SetInsideValue(1.0);
     thresh->SetInput(caster->GetOutput());
     thresh->Update();
     itkmask = thresh->GetOutput();
 
     mask = mitk::Image::New();
     mask->InitializeByItk(itkmask.GetPointer());
     mask->SetVolume(itkmask->GetBufferPointer());
 
     //    GetDefaultDataStorage()->Remove(m_newnode);
     //    m_newnode = mitk::DataNode::New();
     //    m_newnode->SetData(mask);
     //    m_newnode->SetName("masking node");
     //    m_newnode->SetIntProperty( "layer", 1002 );
     //    GetDefaultDataStorage()->Add(m_newnode, m_SelectedImageNodes->GetNode());
 
   }
 
   mitk::Image::Pointer clusteredImage;
   ClusteringType::Pointer clusterer = ClusteringType::New();
 
   if(m_QuantifyClass==3)
   {
 
     if(m_IsTensorImage)
     {
       double *green_fa, *green_rd, *green_ad, *green_md;
       //double *greengray_fa, *greengray_rd, *greengray_ad, *greengray_md;
       double *gray_fa, *gray_rd, *gray_ad, *gray_md;
       //double *redgray_fa, *redgray_rd, *redgray_ad, *redgray_md;
       double *red_fa, *red_rd, *red_ad, *red_md;
 
       mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(0);
       mitk::Image::ConstPointer imgToCluster = tmpImg;
 
       red_fa   = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
       green_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
       gray_fa  = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
       tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(3);
       mitk::Image::ConstPointer imgToCluster3 = tmpImg;
 
       red_rd   = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
       green_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
       gray_rd  = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
       tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(4);
       mitk::Image::ConstPointer imgToCluster4 = tmpImg;
 
       red_ad   = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
       green_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
       gray_ad  = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
       tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(5);
       mitk::Image::ConstPointer imgToCluster5 = tmpImg;
 
       red_md   = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
       green_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
       gray_md  = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
       // clipboard
       QString clipboardText("FA\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
       clipboardText = clipboardText
           .arg(red_fa[0]).arg(red_fa[1])
           .arg(gray_fa[0]).arg(gray_fa[1])
           .arg(green_fa[0]).arg(green_fa[1]);
       QString clipboardText3("RD\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
       clipboardText3 = clipboardText3
           .arg(red_rd[0]).arg(red_rd[1])
           .arg(gray_rd[0]).arg(gray_rd[1])
           .arg(green_rd[0]).arg(green_rd[1]);
       QString clipboardText4("AD\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
       clipboardText4 = clipboardText4
           .arg(red_ad[0]).arg(red_ad[1])
           .arg(gray_ad[0]).arg(gray_ad[1])
           .arg(green_ad[0]).arg(green_ad[1]);
       QString clipboardText5("MD\t%1\t%2\t\t%3\t%4\t\t%5\t%6");
       clipboardText5 = clipboardText5
           .arg(red_md[0]).arg(red_md[1])
           .arg(gray_md[0]).arg(gray_md[1])
           .arg(green_md[0]).arg(green_md[1]);
 
       QApplication::clipboard()->setText(clipboardText+clipboardText3+clipboardText4+clipboardText5, QClipboard::Clipboard);
 
       // now paint infos also on renderwindow
       QString plainInfoText("%1  %2  %3        \n");
       plainInfoText = plainInfoText
           .arg("Red  ", 20)
           .arg("Gray ", 20)
           .arg("Green", 20);
 
       QString plainInfoText0("FA:%1 ± %2%3 ± %4%5 ± %6\n");
       plainInfoText0 = plainInfoText0
           .arg(red_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(red_fa[1], -10, 'g', 2, QLatin1Char( ' ' ))
           .arg(gray_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(gray_fa[1], -10, 'g', 2, QLatin1Char( ' ' ))
           .arg(green_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(green_fa[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
       QString plainInfoText3("RDx10³:%1 ± %2%3 ± %4%5 ± %6\n");
       plainInfoText3 = plainInfoText3
           .arg(1000.0 * red_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_rd[1], -10, 'g', 2, QLatin1Char( ' ' ))
           .arg(1000.0 * gray_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_rd[1], -10, 'g', 2, QLatin1Char( ' ' ))
           .arg(1000.0 * green_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_rd[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
       QString plainInfoText4("ADx10³:%1 ± %2%3 ± %4%5 ± %6\n");
       plainInfoText4 = plainInfoText4
           .arg(1000.0 * red_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_ad[1], -10, 'g', 2, QLatin1Char( ' ' ))
           .arg(1000.0 * gray_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_ad[1], -10, 'g', 2, QLatin1Char( ' ' ))
           .arg(1000.0 * green_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_ad[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
       QString plainInfoText5("MDx10³:%1 ± %2%3 ± %4%5 ± %6");
       plainInfoText5 = plainInfoText5
           .arg(1000.0 * red_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_md[1], -10, 'g', 2, QLatin1Char( ' ' ))
           .arg(1000.0 * gray_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_md[1], -10, 'g', 2, QLatin1Char( ' ' ))
           .arg(1000.0 * green_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_md[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
       this->SetMeasurementInfoToRenderWindow(plainInfoText+plainInfoText0+plainInfoText3+plainInfoText4+plainInfoText5);
 
     }
     else
     {
       double* green;
       double* gray;
       double* red;
 
       mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
       mitk::Image::ConstPointer imgToCluster = tmpImg;
 
       red = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->r);
       green = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->g);
       gray = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->b);
 
       // clipboard
       QString clipboardText("%1\t%2\t\t%3\t%4\t\t%5\t%6");
       clipboardText = clipboardText.arg(red[0]).arg(red[1])
           .arg(gray[0]).arg(gray[1])
           .arg(green[0]).arg(green[1]);
       QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 
       // now paint infos also on renderwindow
       QString plainInfoText("Red: %1 ± %2\nGray: %3 ± %4\nGreen: %5 ± %6");
       plainInfoText = plainInfoText.arg(red[0]).arg(red[1])
           .arg(gray[0]).arg(gray[1])
           .arg(green[0]).arg(green[1]);
 
       this->SetMeasurementInfoToRenderWindow(plainInfoText);
 
     }
 
 
     clusteredImage = m_CurrentRGBClusteringResults->rgb;
 
   }
   else
   {
     if(m_IsTensorImage)
     {
       double *red_fa, *red_rd, *red_ad, *red_md;
 
       mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(0);
       mitk::Image::ConstPointer imgToCluster = tmpImg;
       red_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
       tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(3);
       mitk::Image::ConstPointer imgToCluster3 = tmpImg;
       red_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
       tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(4);
       mitk::Image::ConstPointer imgToCluster4 = tmpImg;
       red_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
       tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(5);
       mitk::Image::ConstPointer imgToCluster5 = tmpImg;
       red_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
       // clipboard
       QString clipboardText("FA\t%1\t%2\t");
       clipboardText = clipboardText
           .arg(red_fa[0]).arg(red_fa[1]);
       QString clipboardText3("RD\t%1\t%2\t");
       clipboardText3 = clipboardText3
           .arg(red_rd[0]).arg(red_rd[1]);
       QString clipboardText4("AD\t%1\t%2\t");
       clipboardText4 = clipboardText4
           .arg(red_ad[0]).arg(red_ad[1]);
       QString clipboardText5("MD\t%1\t%2\t");
       clipboardText5 = clipboardText5
           .arg(red_md[0]).arg(red_md[1]);
 
       QApplication::clipboard()->setText(clipboardText+clipboardText3+clipboardText4+clipboardText5, QClipboard::Clipboard);
 
       // now paint infos also on renderwindow
       QString plainInfoText("%1        \n");
       plainInfoText = plainInfoText
           .arg("Red  ", 20);
 
       QString plainInfoText0("FA:%1 ± %2\n");
       plainInfoText0 = plainInfoText0
           .arg(red_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(red_fa[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
       QString plainInfoText3("RDx10³:%1 ± %2\n");
       plainInfoText3 = plainInfoText3
           .arg(1000.0 * red_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_rd[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
       QString plainInfoText4("ADx10³:%1 ± %2\n");
       plainInfoText4 = plainInfoText4
           .arg(1000.0 * red_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_ad[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
       QString plainInfoText5("MDx10³:%1 ± %2");
       plainInfoText5 = plainInfoText5
           .arg(1000.0 * red_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_md[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
       this->SetMeasurementInfoToRenderWindow(plainInfoText+plainInfoText0+plainInfoText3+plainInfoText4+plainInfoText5);
 
     }
     else
     {
       double* quant;
 
       mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
       mitk::Image::ConstPointer imgToCluster = tmpImg;
       quant = clusterer->PerformQuantification(imgToCluster, m_CurrentPerformClusteringResults->clusteredImage);
 
       // clipboard
       QString clipboardText("%1\t%2");
       clipboardText = clipboardText.arg(quant[0]).arg(quant[1]);
       QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 
       // now paint infos also on renderwindow
       QString plainInfoText("Measurement: %1 ± %2");
       plainInfoText = plainInfoText.arg(quant[0]).arg(quant[1]);
 
       this->SetMeasurementInfoToRenderWindow(plainInfoText);
     }
 
     clusteredImage = m_CurrentPerformClusteringResults->displayImage;
 
   }
 
   if(mask.IsNotNull())
   {
     typedef itk::Image<itk::RGBAPixel<unsigned char>,3> RGBImageType;
     typedef mitk::ImageToItk<RGBImageType> ClusterCasterType;
     ClusterCasterType::Pointer clCaster = ClusterCasterType::New();
     clCaster->SetInput(clusteredImage);
     clCaster->Update();
     clCaster->GetOutput();
 
     typedef itk::MaskImageFilter< RGBImageType, MaskImageType, RGBImageType > MaskType;
     MaskType::Pointer masker = MaskType::New();
     masker->SetInput1(clCaster->GetOutput());
     masker->SetInput2(itkmask);
     masker->Update();
 
     clusteredImage = mitk::Image::New();
     clusteredImage->InitializeByItk(masker->GetOutput());
     clusteredImage->SetVolume(masker->GetOutput()->GetBufferPointer());
   }
 
   if(m_ClusteringResult.IsNotNull())
   {
     this->GetDataStorage()->Remove(m_ClusteringResult);
   }
 
   m_ClusteringResult = mitk::DataNode::New();
   m_ClusteringResult->SetBoolProperty("helper object", true);
   m_ClusteringResult->SetIntProperty( "layer", 1000 );
   m_ClusteringResult->SetBoolProperty("texture interpolation", m_TexIsOn);
   m_ClusteringResult->SetData(clusteredImage);
   m_ClusteringResult->SetName("Clusterprobs");
   this->GetDataStorage()->Add(m_ClusteringResult, m_SelectedImageNodes->GetNode());
 
   if(m_SelectedPlanarFigure.IsNotNull() && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
   {
     m_SelectedPlanarFigureNodes->GetNode()->SetIntProperty( "layer", 1001 );
   }
 
   this->RequestRenderWindowUpdate();
 
 }
 
 
 void QmitkPartialVolumeAnalysisView::UpdateStatistics()
 {
 
   MITK_INFO << "UpdateStatistics()";
 
   if(!m_CurrentFigureNodeInitialized && m_SelectedPlanarFigure.IsNotNull())
   {
     MITK_INFO << "Selected planar figure not initialized. No stats calculation performed.";
     return;
   }
 
   // Remove any cached images that are no longer referenced elsewhere
   this->RemoveOrphanImages();
 
 
   QmitkStdMultiWidget *multiWidget = 0;
   QmitkStdMultiWidgetEditor * multiWidgetEdit = 0;
 
   multiWidgetEdit = dynamic_cast<QmitkStdMultiWidgetEditor *>(this->GetRenderWindowPart());
   if(multiWidgetEdit){
     multiWidget = multiWidgetEdit->GetStdMultiWidget();
   }
 
   if ( multiWidget == NULL )
   {
     return;
   }
 
   if ( m_SelectedImage.IsNotNull() )
   {
     // Check if a the selected image is a multi-channel image. If yes, statistics
     // cannot be calculated currently.
     if ( !m_IsTensorImage && m_SelectedImage->GetPixelType().GetNumberOfComponents() > 1 )
     {
       QMessageBox::information( NULL, "Warning", "Non-tensor multi-component images not supported.");
 
       m_Controls->m_HistogramWidget->ClearItemModel();
       m_CurrentStatisticsValid = false;
       return;
     }
 
     // Retrieve HistogramStatisticsCalculator from has map (or create a new one
     // for this image if non-existant)
     PartialVolumeAnalysisMapType::iterator it =
         m_PartialVolumeAnalysisMap.find( m_SelectedImage );
 
     if ( it != m_PartialVolumeAnalysisMap.end() )
     {
       m_CurrentStatisticsCalculator = it->second;
       MITK_INFO << "Retrieving StatisticsCalculator";
     }
     else
     {
       m_CurrentStatisticsCalculator = mitk::PartialVolumeAnalysisHistogramCalculator::New();
       m_CurrentStatisticsCalculator->SetPlanarFigureThickness(m_Controls->m_PlanarFiguresThickness->value());
       if(m_IsTensorImage)
       {
         m_CurrentStatisticsCalculator->SetImage( m_CAImage );
         m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_FAImage );
         m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_DirectionComp1Image );
         m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_DirectionComp2Image );
         m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_RDImage );
         m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_ADImage );
         m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_MDImage );
       }
       else
       {
         m_CurrentStatisticsCalculator->SetImage( m_SelectedImage );
       }
       m_PartialVolumeAnalysisMap[m_SelectedImage] = m_CurrentStatisticsCalculator;
       MITK_INFO << "Creating StatisticsCalculator";
     }
 
     std::string maskName;
     std::string maskType;
     unsigned int maskDimension;
 
     if ( m_SelectedImageMask.IsNotNull() )
     {
 
       mitk::PixelType pixelType = m_SelectedImageMask->GetPixelType();
       std::cout << pixelType.GetItkTypeAsString() << std::endl;
 
       if(pixelType.GetBitsPerComponent() == 16)
       {
         //convert from short to uchar
         typedef itk::Image<short, 3> ShortImageType;
         typedef itk::Image<unsigned char, 3> CharImageType;
 
         CharImageType::Pointer charImage;
         ShortImageType::Pointer shortImage;
         mitk::CastToItkImage(m_SelectedImageMask, shortImage);
 
         typedef itk::CastImageFilter<ShortImageType, CharImageType> ImageCasterType;
 
         ImageCasterType::Pointer caster = ImageCasterType::New();
         caster->SetInput( shortImage );
         caster->Update();
         charImage = caster->GetOutput();
 
 
         mitk::CastToMitkImage(charImage, m_SelectedImageMask);
       }
 
       m_CurrentStatisticsCalculator->SetImageMask( m_SelectedImageMask );
 
 
       m_CurrentStatisticsCalculator->SetMaskingModeToImage();
 
       maskName = m_SelectedMaskNode->GetName();
       maskType = m_SelectedImageMask->GetNameOfClass();
       maskDimension = 3;
 
       std::stringstream maskLabel;
       maskLabel << maskName;
       if ( maskDimension > 0 )
       {
         maskLabel << "  [" << maskDimension << "D " << maskType << "]";
       }
       m_Controls->m_SelectedMaskLabel->setText( maskLabel.str().c_str() );
     }
     else if ( m_SelectedPlanarFigure.IsNotNull() && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
     {
       m_CurrentStatisticsCalculator->SetPlanarFigure( m_SelectedPlanarFigure );
       m_CurrentStatisticsCalculator->SetMaskingModeToPlanarFigure();
 
       maskName = m_SelectedPlanarFigureNodes->GetNode()->GetName();
       maskType = m_SelectedPlanarFigure->GetNameOfClass();
       maskDimension = 2;
     }
     else
     {
       m_CurrentStatisticsCalculator->SetMaskingModeToNone();
 
       maskName = "-";
       maskType = "";
       maskDimension = 0;
     }
 
     bool statisticsChanged = false;
     bool statisticsCalculationSuccessful = false;
 
     // Initialize progress bar
     mitk::ProgressBar::GetInstance()->AddStepsToDo( 100 );
 
     // Install listener for progress events and initialize progress bar
     typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
     ITKCommandType::Pointer progressListener;
     progressListener = ITKCommandType::New();
     progressListener->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::UpdateProgressBar );
     unsigned long progressObserverTag = m_CurrentStatisticsCalculator
         ->AddObserver( itk::ProgressEvent(), progressListener );
 
     ClusteringType::ParamsType *cparams = 0;
     ClusteringType::ClusterResultType *cresult = 0;
     ClusteringType::HistType *chist = 0;
 
     try
     {
       m_CurrentStatisticsCalculator->SetNumberOfBins(m_Controls->m_NumberBins->text().toInt());
       m_CurrentStatisticsCalculator->SetUpsamplingFactor(m_Controls->m_Upsampling->text().toDouble());
       m_CurrentStatisticsCalculator->SetGaussianSigma(m_Controls->m_GaussianSigma->text().toDouble());
 
       // Compute statistics
       statisticsChanged =
           m_CurrentStatisticsCalculator->ComputeStatistics( );
 
       mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
       mitk::Image::ConstPointer imgToCluster = tmpImg;
       if(imgToCluster.IsNotNull())
       {
 
         // perform clustering
         const HistogramType *histogram = m_CurrentStatisticsCalculator->GetHistogram( );
 
         if(histogram != NULL)
         {
           ClusteringType::Pointer clusterer = ClusteringType::New();
           clusterer->SetStepsNumIntegration(200);
           clusterer->SetMaxIt(1000);
 
           mitk::Image::Pointer pFiberImg;
           if(m_QuantifyClass==3)
           {
             if(m_Controls->m_Quantiles->isChecked())
             {
               m_CurrentRGBClusteringResults = clusterer->PerformRGBQuantiles(imgToCluster, histogram, m_Controls->m_q1->value(),m_Controls->m_q2->value());
             }
             else
             {
               m_CurrentRGBClusteringResults = clusterer->PerformRGBClustering(imgToCluster, histogram);
             }
 
             pFiberImg = m_CurrentRGBClusteringResults->rgbChannels->r;
             cparams = m_CurrentRGBClusteringResults->params;
             cresult = m_CurrentRGBClusteringResults->result;
             chist = m_CurrentRGBClusteringResults->hist;
           }
           else
           {
             if(m_Controls->m_Quantiles->isChecked())
             {
               m_CurrentPerformClusteringResults =
                   clusterer->PerformQuantiles(imgToCluster, histogram, m_Controls->m_q1->value(),m_Controls->m_q2->value());
             }
             else
             {
               m_CurrentPerformClusteringResults =
                   clusterer->PerformClustering(imgToCluster, histogram, m_QuantifyClass);
             }
 
             pFiberImg = m_CurrentPerformClusteringResults->clusteredImage;
             cparams = m_CurrentPerformClusteringResults->params;
             cresult = m_CurrentPerformClusteringResults->result;
             chist = m_CurrentPerformClusteringResults->hist;
           }
 
           if(m_IsTensorImage)
           {
             m_AngularErrorImage = clusterer->CaculateAngularErrorImage(
                   m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(1),
                   m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(2),
                   pFiberImg);
 
             //          GetDefaultDataStorage()->Remove(m_newnode2);
             //          m_newnode2 = mitk::DataNode::New();
             //          m_newnode2->SetData(m_AngularErrorImage);
             //          m_newnode2->SetName(("AngularError"));
             //          m_newnode2->SetIntProperty( "layer", 1003 );
             //          GetDefaultDataStorage()->Add(m_newnode2, m_SelectedImageNodes->GetNode());
 
             //          newnode = mitk::DataNode::New();
             //          newnode->SetData(m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(1));
             //          newnode->SetName(("Comp1"));
             //          GetDefaultDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
 
             //          newnode = mitk::DataNode::New();
             //          newnode->SetData(m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(2));
             //          newnode->SetName(("Comp2"));
             //          GetDefaultDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
           }
           ShowClusteringResults();
         }
 
       }
 
       statisticsCalculationSuccessful = true;
     }
     catch ( const std::runtime_error &e )
     {
       QMessageBox::information( NULL, "Warning", e.what());
     }
     catch ( const std::exception &e )
     {
       MITK_ERROR << "Caught exception: " << e.what();
 
       QMessageBox::information( NULL, "Warning", e.what());
     }
 
     m_CurrentStatisticsCalculator->RemoveObserver( progressObserverTag );
 
     // Make sure that progress bar closes
     mitk::ProgressBar::GetInstance()->Progress( 100 );
 
     if ( statisticsCalculationSuccessful )
     {
       if ( statisticsChanged )
       {
         // Do not show any error messages
         m_CurrentStatisticsValid = true;
       }
 
       //      m_Controls->m_HistogramWidget->SetHistogramModeToDirectHistogram();
       m_Controls->m_HistogramWidget->SetParameters(
             cparams, cresult, chist );
       //      m_Controls->m_HistogramWidget->UpdateItemModelFromHistogram();
 
     }
     else
     {
       m_Controls->m_SelectedMaskLabel->setText( "-" );
 
       // Clear statistics and histogram
       m_Controls->m_HistogramWidget->ClearItemModel();
       m_CurrentStatisticsValid = false;
 
 
       // If a (non-closed) PlanarFigure is selected, display a line profile widget
       if ( m_SelectedPlanarFigure.IsNotNull() )
       {
         // TODO: enable line profile widget
         //m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 1 );
         //m_Controls->m_LineProfileWidget->SetImage( m_SelectedImage );
         //m_Controls->m_LineProfileWidget->SetPlanarFigure( m_SelectedPlanarFigure );
         //m_Controls->m_LineProfileWidget->UpdateItemModelFromPath();
       }
     }
   }
 
 }
 
 void QmitkPartialVolumeAnalysisView::SetMeasurementInfoToRenderWindow(const QString& text)
 {
 
   FindRenderWindow(m_SelectedPlanarFigureNodes->GetNode());
 
   if(m_LastRenderWindow != m_SelectedRenderWindow)
   {
 
     if(m_LastRenderWindow)
     {
       QObject::disconnect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
                            , this, SLOT( OnRenderWindowDelete(QObject*) ) );
     }
     m_LastRenderWindow = m_SelectedRenderWindow;
     if(m_LastRenderWindow)
     {
       QObject::connect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
                         , this, SLOT( OnRenderWindowDelete(QObject*) ) );
     }
   }
 
   if(m_LastRenderWindow && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
   {
     if (!text.isEmpty())
     {
       m_MeasurementInfoAnnotation->SetText(1, text.toLatin1().data());
       mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->InsertForegroundRenderer(
             m_MeasurementInfoRenderer, true);
     }
     else
     {
       if (mitk::VtkLayerController::GetInstance(
             m_LastRenderWindow->GetRenderWindow()) ->IsRendererInserted(
             m_MeasurementInfoRenderer))
         mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->RemoveRenderer(
               m_MeasurementInfoRenderer);
     }
   }
   else
   {
     QmitkStdMultiWidget *multiWidget = 0;
     QmitkStdMultiWidgetEditor * multiWidgetEdit = 0;
 
     multiWidgetEdit = dynamic_cast<QmitkStdMultiWidgetEditor *>(this->GetRenderWindowPart());
     if(multiWidgetEdit){
       multiWidget = multiWidgetEdit->GetStdMultiWidget();
     }
 
     if ( multiWidget == NULL )
     {
       return;
     }
 
     if (!text.isEmpty())
     {
       m_MeasurementInfoAnnotation->SetText(1, text.toLatin1().data());
       mitk::VtkLayerController::GetInstance(multiWidget->GetRenderWindow1()->GetRenderWindow())->InsertForegroundRenderer(
             m_MeasurementInfoRenderer, true);
     }
     else
     {
       if (mitk::VtkLayerController::GetInstance(
             multiWidget->GetRenderWindow1()->GetRenderWindow()) ->IsRendererInserted(
             m_MeasurementInfoRenderer))
         mitk::VtkLayerController::GetInstance(multiWidget->GetRenderWindow1()->GetRenderWindow())->RemoveRenderer(
               m_MeasurementInfoRenderer);
     }
   }
 }
 
 void QmitkPartialVolumeAnalysisView::UpdateProgressBar()
 {
   mitk::ProgressBar::GetInstance()->Progress();
 }
 
 void QmitkPartialVolumeAnalysisView::RequestStatisticsUpdate()
 {
   if ( !m_StatisticsUpdatePending )
   {
     QApplication::postEvent( this, new QmitkRequestStatisticsUpdateEvent );
     m_StatisticsUpdatePending = true;
   }
 }
 
 
 void QmitkPartialVolumeAnalysisView::RemoveOrphanImages()
 {
   PartialVolumeAnalysisMapType::iterator it = m_PartialVolumeAnalysisMap.begin();
 
   while ( it != m_PartialVolumeAnalysisMap.end() )
   {
     mitk::Image *image = it->first;
     mitk::PartialVolumeAnalysisHistogramCalculator *calculator = it->second;
     ++it;
 
     mitk::NodePredicateData::Pointer hasImage = mitk::NodePredicateData::New( image );
     if ( this->GetDataStorage()->GetNode( hasImage ) == NULL )
     {
       if ( m_SelectedImage == image )
       {
         m_SelectedImage = NULL;
         m_SelectedImageNodes->RemoveAllNodes();
       }
       if ( m_CurrentStatisticsCalculator == calculator )
       {
         m_CurrentStatisticsCalculator = NULL;
       }
       m_PartialVolumeAnalysisMap.erase( image );
       it = m_PartialVolumeAnalysisMap.begin();
     }
   }
 }
 
 void QmitkPartialVolumeAnalysisView::ExtractTensorImages(
     mitk::Image::ConstPointer tensorimage)
 {
   typedef itk::Image< itk::DiffusionTensor3D<float>, 3> TensorImageType;
 
   typedef mitk::ImageToItk<TensorImageType> CastType;
   CastType::Pointer caster = CastType::New();
   caster->SetInput(tensorimage);
   caster->Update();
   TensorImageType::Pointer image = caster->GetOutput();
 
   typedef itk::TensorDerivedMeasurementsFilter<float> MeasurementsType;
   MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
   measurementsCalculator->SetInput(image );
   measurementsCalculator->SetMeasure(MeasurementsType::FA);
   measurementsCalculator->Update();
   MeasurementsType::OutputImageType::Pointer fa = measurementsCalculator->GetOutput();
 
   m_FAImage = mitk::Image::New();
   m_FAImage->InitializeByItk(fa.GetPointer());
   m_FAImage->SetVolume(fa->GetBufferPointer());
 
   //  mitk::DataNode::Pointer node = mitk::DataNode::New();
   //  node->SetData(m_FAImage);
   //  GetDefaultDataStorage()->Add(node);
 
   measurementsCalculator = MeasurementsType::New();
   measurementsCalculator->SetInput(image );
   measurementsCalculator->SetMeasure(MeasurementsType::CA);
   measurementsCalculator->Update();
   MeasurementsType::OutputImageType::Pointer ca = measurementsCalculator->GetOutput();
 
   m_CAImage = mitk::Image::New();
   m_CAImage->InitializeByItk(ca.GetPointer());
   m_CAImage->SetVolume(ca->GetBufferPointer());
 
   //  node = mitk::DataNode::New();
   //  node->SetData(m_CAImage);
   //  GetDefaultDataStorage()->Add(node);
 
   measurementsCalculator = MeasurementsType::New();
   measurementsCalculator->SetInput(image );
   measurementsCalculator->SetMeasure(MeasurementsType::RD);
   measurementsCalculator->Update();
   MeasurementsType::OutputImageType::Pointer rd = measurementsCalculator->GetOutput();
 
   m_RDImage = mitk::Image::New();
   m_RDImage->InitializeByItk(rd.GetPointer());
   m_RDImage->SetVolume(rd->GetBufferPointer());
 
   //  node = mitk::DataNode::New();
   //  node->SetData(m_CAImage);
   //  GetDefaultDataStorage()->Add(node);
 
   measurementsCalculator = MeasurementsType::New();
   measurementsCalculator->SetInput(image );
   measurementsCalculator->SetMeasure(MeasurementsType::AD);
   measurementsCalculator->Update();
   MeasurementsType::OutputImageType::Pointer ad = measurementsCalculator->GetOutput();
 
   m_ADImage = mitk::Image::New();
   m_ADImage->InitializeByItk(ad.GetPointer());
   m_ADImage->SetVolume(ad->GetBufferPointer());
 
   //  node = mitk::DataNode::New();
   //  node->SetData(m_CAImage);
   //  GetDefaultDataStorage()->Add(node);
 
   measurementsCalculator = MeasurementsType::New();
   measurementsCalculator->SetInput(image );
   measurementsCalculator->SetMeasure(MeasurementsType::RA);
   measurementsCalculator->Update();
   MeasurementsType::OutputImageType::Pointer md = measurementsCalculator->GetOutput();
 
   m_MDImage = mitk::Image::New();
   m_MDImage->InitializeByItk(md.GetPointer());
   m_MDImage->SetVolume(md->GetBufferPointer());
 
   //  node = mitk::DataNode::New();
   //  node->SetData(m_CAImage);
   //  GetDefaultDataStorage()->Add(node);
 
   typedef DirectionsFilterType::OutputImageType DirImageType;
   DirectionsFilterType::Pointer dirFilter = DirectionsFilterType::New();
   dirFilter->SetInput(image );
   dirFilter->Update();
 
   itk::ImageRegionIterator<DirImageType>
       itd(dirFilter->GetOutput(), dirFilter->GetOutput()->GetLargestPossibleRegion());
   itd = itd.Begin();
   while( !itd.IsAtEnd() )
   {
     DirImageType::PixelType direction = itd.Get();
     direction[0] = fabs(direction[0]);
     direction[1] = fabs(direction[1]);
     direction[2] = fabs(direction[2]);
     itd.Set(direction);
     ++itd;
   }
 
   typedef itk::CartesianToPolarVectorImageFilter<
       DirImageType, DirImageType, true> C2PFilterType;
   C2PFilterType::Pointer cpFilter = C2PFilterType::New();
   cpFilter->SetInput(dirFilter->GetOutput());
   cpFilter->Update();
   DirImageType::Pointer dir = cpFilter->GetOutput();
 
   typedef itk::Image<float, 3> CompImageType;
   CompImageType::Pointer comp1 = CompImageType::New();
   comp1->SetSpacing( dir->GetSpacing() );   // Set the image spacing
   comp1->SetOrigin( dir->GetOrigin() );     // Set the image origin
   comp1->SetDirection( dir->GetDirection() );  // Set the image direction
   comp1->SetRegions( dir->GetLargestPossibleRegion() );
   comp1->Allocate();
 
   CompImageType::Pointer comp2 = CompImageType::New();
   comp2->SetSpacing( dir->GetSpacing() );   // Set the image spacing
   comp2->SetOrigin( dir->GetOrigin() );     // Set the image origin
   comp2->SetDirection( dir->GetDirection() );  // Set the image direction
   comp2->SetRegions( dir->GetLargestPossibleRegion() );
   comp2->Allocate();
 
   itk::ImageRegionConstIterator<DirImageType>
       it(dir, dir->GetLargestPossibleRegion());
 
   itk::ImageRegionIterator<CompImageType>
       it1(comp1, comp1->GetLargestPossibleRegion());
 
   itk::ImageRegionIterator<CompImageType>
       it2(comp2, comp2->GetLargestPossibleRegion());
 
   it = it.Begin();
   it1 = it1.Begin();
   it2 = it2.Begin();
 
   while( !it.IsAtEnd() )
   {
     it1.Set(it.Get()[1]);
     it2.Set(it.Get()[2]);
     ++it;
     ++it1;
     ++it2;
   }
 
   m_DirectionComp1Image = mitk::Image::New();
   m_DirectionComp1Image->InitializeByItk(comp1.GetPointer());
   m_DirectionComp1Image->SetVolume(comp1->GetBufferPointer());
 
   m_DirectionComp2Image = mitk::Image::New();
   m_DirectionComp2Image->InitializeByItk(comp2.GetPointer());
   m_DirectionComp2Image->SetVolume(comp2->GetBufferPointer());
 
 }
 
 void QmitkPartialVolumeAnalysisView::OnRenderWindowDelete(QObject * obj)
 {
   if(obj == m_LastRenderWindow)
     m_LastRenderWindow = 0;
   if(obj == m_SelectedRenderWindow)
     m_SelectedRenderWindow = 0;
 }
 
 bool QmitkPartialVolumeAnalysisView::event( QEvent *event )
 {
   if ( event->type() == (QEvent::Type) QmitkRequestStatisticsUpdateEvent::StatisticsUpdateRequest )
   {
     // Update statistics
 
     m_StatisticsUpdatePending = false;
 
     this->UpdateStatistics();
     return true;
   }
 
   return false;
 }
 
 
 bool QmitkPartialVolumeAnalysisView::IsExclusiveFunctionality() const
 {
   return true;
 }
 
 void QmitkPartialVolumeAnalysisView::Activated()
 {
 
   MITK_INFO << "QmitkPartialVolumeAnalysisView:Activated";
 
   //this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(false);
   //this->GetActiveStdMultiWidget()->GetRenderWindow1()->FullScreenMode(true);
 
   mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
   mitk::DataNode* node = 0;
   mitk::PlanarFigure* figure = 0;
   mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
 
   // finally add all nodes to the model
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
       ; it++)
   {
     node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
     figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
 
     if(figure)
     {
       figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
 
       if(figureInteractor.IsNull())
         figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", node);
 
       mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
     }
   }
 
   m_Visible = true;
 
 }
 
 void QmitkPartialVolumeAnalysisView::Deactivated()
 {
   MITK_INFO << "QmitkPartialVolumeAnalysisView:Deactivated";
 }
 
 void QmitkPartialVolumeAnalysisView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer reference)
 {
   MITK_INFO << "QmitkPartialVolumeAnalysisView:ActivatedZombieView";
 
   //this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(true);
 
   this->SetMeasurementInfoToRenderWindow("");
 
   mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
   mitk::DataNode* node = 0;
   mitk::PlanarFigure* figure = 0;
   mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
 
   // finally add all nodes to the model
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
       ; it++)
   {
     node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
     figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
 
     if(figure)
     {
       figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
 
       if(figureInteractor)
         mitk::GlobalInteraction::GetInstance()->RemoveInteractor(figureInteractor);
     }
   }
   m_Visible = false;
 }
 
 void QmitkPartialVolumeAnalysisView::Hidden()
 {
 
 }
 
 void QmitkPartialVolumeAnalysisView::Visible()
 {
   //this->OnSelectionChanged( this->Get, this->GetDataManagerSelection() );
 }
 
 void QmitkPartialVolumeAnalysisView::SetFocus()
 {
 
 }
 
 
 void QmitkPartialVolumeAnalysisView::GreenRadio(bool checked)
 {
   if(checked)
   {
     m_Controls->m_PartialVolumeRadio->setChecked(false);
     m_Controls->m_BlueRadio->setChecked(false);
     m_Controls->m_AllRadio->setChecked(false);
     m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
   }
 
   m_QuantifyClass = 0;
 
   RequestStatisticsUpdate();
 }
 
 
 void QmitkPartialVolumeAnalysisView::PartialVolumeRadio(bool checked)
 {
   if(checked)
   {
     m_Controls->m_GreenRadio->setChecked(false);
     m_Controls->m_BlueRadio->setChecked(false);
     m_Controls->m_AllRadio->setChecked(false);
     m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
   }
 
   m_QuantifyClass = 1;
 
   RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::BlueRadio(bool checked)
 {
   if(checked)
   {
     m_Controls->m_PartialVolumeRadio->setChecked(false);
     m_Controls->m_GreenRadio->setChecked(false);
     m_Controls->m_AllRadio->setChecked(false);
     m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
   }
 
   m_QuantifyClass = 2;
 
   RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::AllRadio(bool checked)
 {
   if(checked)
   {
     m_Controls->m_BlueRadio->setChecked(false);
     m_Controls->m_PartialVolumeRadio->setChecked(false);
     m_Controls->m_GreenRadio->setChecked(false);
     m_Controls->m_ExportClusteringResultsButton->setEnabled(false);
   }
 
   m_QuantifyClass = 3;
 
   RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::NumberBinsChangedSlider(int v )
 {
   m_Controls->m_NumberBins->setText(QString("%1").arg(m_Controls->m_NumberBinsSlider->value()*5.0));
 }
 
 void QmitkPartialVolumeAnalysisView::UpsamplingChangedSlider( int v)
 {
   m_Controls->m_Upsampling->setText(QString("%1").arg(m_Controls->m_UpsamplingSlider->value()/10.0));
 }
 
 void QmitkPartialVolumeAnalysisView::GaussianSigmaChangedSlider(int v )
 {
   m_Controls->m_GaussianSigma->setText(QString("%1").arg(m_Controls->m_GaussianSigmaSlider->value()/100.0));
 }
 
 void QmitkPartialVolumeAnalysisView::SimilarAnglesChangedSlider(int v )
 {
   m_Controls->m_SimilarAngles->setText(QString("%1°").arg(90-m_Controls->m_SimilarAnglesSlider->value()));
   ShowClusteringResults();
 }
 
 void QmitkPartialVolumeAnalysisView::OpacityChangedSlider(int v )
 {
 
   if(m_SelectedImageNodes->GetNode().IsNotNull())
   {
     float opacImag = 1.0f-(v-5)/5.0f;
     opacImag = opacImag < 0 ? 0 : opacImag;
     m_SelectedImageNodes->GetNode()->SetFloatProperty("opacity", opacImag);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 
   if(m_ClusteringResult.IsNotNull())
   {
     float opacClust = v/5.0f;
     opacClust = opacClust > 1 ? 1 : opacClust;
     m_ClusteringResult->SetFloatProperty("opacity", opacClust);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkPartialVolumeAnalysisView::NumberBinsReleasedSlider( )
 {
   RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::UpsamplingReleasedSlider( )
 {
   RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::GaussianSigmaReleasedSlider( )
 {
   RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::SimilarAnglesReleasedSlider( )
 {
 
 }
 
 void QmitkPartialVolumeAnalysisView::ToClipBoard()
 {
 
   std::vector<std::vector<double>* > vals  = m_Controls->m_HistogramWidget->m_Vals;
   QString clipboardText;
   for (std::vector<std::vector<double>* >::iterator it = vals.begin(); it
        != vals.end(); ++it)
   {
     for (std::vector<double>::iterator it2 = (**it).begin(); it2 != (**it).end(); ++it2)
     {
       clipboardText.append(QString("%1 \t").arg(*it2));
     }
     clipboardText.append(QString("\n"));
   }
 
   QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 }
 
 void QmitkPartialVolumeAnalysisView::PropertyChanged(const mitk::DataNode* /*node*/, const mitk::BaseProperty* /*prop*/)
 {
 }
 
 void QmitkPartialVolumeAnalysisView::NodeChanged(const mitk::DataNode* /*node*/)
 {
 }
 
 void QmitkPartialVolumeAnalysisView::NodeRemoved(const mitk::DataNode* node)
 {
   if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
     this->GetDataStorage()->Remove(m_ClusteringResult);
 
   if(  node == m_SelectedPlanarFigureNodes->GetNode().GetPointer()
        || node == m_SelectedMaskNode.GetPointer() )
   {
     this->Select(NULL,true,false);
     SetMeasurementInfoToRenderWindow("");
   }
 
   if(  node == m_SelectedImageNodes->GetNode().GetPointer() )
   {
     this->Select(NULL,false,true);
     SetMeasurementInfoToRenderWindow("");
   }
 }
 
 void QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage(const mitk::DataNode* node)
 {
   if(!m_Visible)
     return;
 
   mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
   mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(nonConstNode->GetData());
 
   if(figure)
   {
 
     // set interactor for new node (if not already set)
     mitk::PlanarFigureInteractor::Pointer figureInteractor
         = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
 
     if(figureInteractor.IsNull())
       figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", nonConstNode);
 
     mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
 
     // remove uninitialized old planars
     if( m_SelectedPlanarFigureNodes->GetNode().IsNotNull() && m_CurrentFigureNodeInitialized == false )
     {
       mitk::Interactor::Pointer oldInteractor = m_SelectedPlanarFigureNodes->GetNode()->GetInteractor();
       if(oldInteractor.IsNotNull())
         mitk::GlobalInteraction::GetInstance()->RemoveInteractor(oldInteractor);
 
       this->GetDataStorage()->Remove(m_SelectedPlanarFigureNodes->GetNode());
     }
 
   }
 }
 
 void QmitkPartialVolumeAnalysisView::TextIntON()
 {
   if(m_ClusteringResult.IsNotNull())
   {
     if(m_TexIsOn)
     {
       m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
     }
     else
     {
       m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
     }
 
     m_ClusteringResult->SetBoolProperty("texture interpolation", !m_TexIsOn);
     m_TexIsOn = !m_TexIsOn;
     this->RequestRenderWindowUpdate();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimagingapp/documentation/UserManual/QmitkDiffusionImagingAppUserManual.dox b/Plugins/org.mitk.gui.qt.diffusionimagingapp/documentation/UserManual/QmitkDiffusionImagingAppUserManual.dox
index 65b8a2a24b..9f679c8296 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimagingapp/documentation/UserManual/QmitkDiffusionImagingAppUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimagingapp/documentation/UserManual/QmitkDiffusionImagingAppUserManual.dox
@@ -1,10 +1,10 @@
 /**
-\page org_diffusionapplication Using The Diffusion Imaging Application
+\page org_mitk_gui_qt_diffusionimagingapp Using The Diffusion Imaging Application
 
 \section QMitkDiffusionApplicationManualOverview What is the Diffusion Imaging Application
 
 The Diffusion Imaging Application contains selected views for the analysis of images of the human brain. These encompass the views developed by the <a href="http://www.dkfz.de/en/mbi/projects/neuroimaging.html">Neuroimaging Group</a> of the Division Medical and Biological Informatics as well as basic image processing views such as segmentation and volumevisualization.
 
 For a basic guide to MITK see \ref MITKUserManualPage .
 
 */
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/MITKExamples.dox b/Plugins/org.mitk.gui.qt.examples/documentation/Manual/MITKExamples.dox
deleted file mode 100644
index 512a525dcd..0000000000
--- a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/MITKExamples.dox
+++ /dev/null
@@ -1,18 +0,0 @@
-/**
-\page org_mitkexamples Examples for the use of MITK
-
-
-\section QmitkExamplesUserManualSummary Summary
-
-This module is a collection of examples for developing with mitk. The following examples are included:
-
-<ul>
- <li> \subpage org_simpleexample
- <li> \subpage org_simplemeasurement
- <li> \subpage org_regiongrowing
- <li> \subpage org_isosurface
- <li> \subpage org_colourimageprocessing
- <li> \subpage org_viewinitialitzation
- <li> The Volumetry Module
-</ul>
-*/
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/ColorImageProcessing.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/ColorImageProcessing.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/ColorImageProcessing.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/ColorImageProcessing.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/IsoSurfaceGUI.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/IsoSurfaceGUI.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/IsoSurfaceGUI.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/IsoSurfaceGUI.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/IsoSurfaceIcon.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/IsoSurfaceIcon.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/IsoSurfaceIcon.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/IsoSurfaceIcon.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/MITKExamples.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/MITKExamples.dox
new file mode 100644
index 0000000000..bf7631f9a6
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/MITKExamples.dox
@@ -0,0 +1,18 @@
+/**
+\page org_mitk_gui_qt_examples Examples for the use of MITK
+
+
+\section QmitkExamplesUserManualSummary Summary
+
+This module is a collection of examples for developing with mitk. The following examples are included:
+
+<ul>
+ <li> \subpage org_mitk_views_simpleexample
+ <li> \subpage org_mitk_views_simplemeasurement
+ <li> \subpage org_mitk_views_regiongrowing
+ <li> \subpage org_mitk_views_isosurface
+ <li> \subpage org_mitk_views_colourimageprocessing
+ <li> \subpage org_mitk_views_viewinitialitzation
+ <li> The Volumetry Module
+</ul>
+*/
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkColourImageProcessing.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkColourImageProcessing.dox
similarity index 96%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkColourImageProcessing.dox
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkColourImageProcessing.dox
index 4ba970890f..dea970f477 100644
--- a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkColourImageProcessing.dox
+++ b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkColourImageProcessing.dox
@@ -1,34 +1,34 @@
 /**
-\page org_colourimageprocessing The Colour Image Processing Module
+\page org_mitk_views_colourimageprocessing The Colour Image Processing Module
 
 \image html ColorImageProcessing.png "Icon of the Module"
 
 \section QmitkColourImageProcessingUserManualSummary Summary
 
 This module allows the user to create coloured images from medical images. Generally, these coloured images would be used in presentations, research papers, or as a teaching aide. 
 
 \section QmitkColourImageProcessingUserManualOverview Overview
 
 The purpose of this module is to create coloured images, which can then be later used in presentations, research papers, or anything else the user desires. Furthermore, different body sections can be assigned a different colour.
 These images are not particularly useful for further image processing, but provide nice, clear, diagrams. Please note that ultrasound images cannot be coloured.  
 
 
 
 \section QmitkColourImageProcessingUserManualFilters Creating Coloured Images
 Open an image in mitk, then click on the colour wheel button. Make sure the image you loaded is selected. 
 
   
 <H2>\ Image -> RGBAimage</H2>
 Clicking on this button creates an RGBA image from your medical image, which should appear in your data manager. 
 
 <H2>\ Image + mask -> RGBAimage</H2>
 Before clicking on this button, a mask is needed. A mask is generally created using the segmentation tool. Make sure both the mask and image are selected, then click on the image + mask -> RGBA image button. This creates an
 RGBA image that is coloured only in section defined by the mask. 
 
 <H2>\ Image + mask + color-> RGBAimage</H2>
 This functions the same way as the Image + mask -> RGBAimage. The difference is that the user can select the colour of the section represented by the mask. This is done by clicking on the colour next to the Image + mask + color-> RGBAimage button
 If multiple RGBA images are created with different colours, they can be combined into one image. Ensure that the desired coloured images are selected, then click on the combine RGBA images button. 
 
 
 
 */
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkIsoSurfaceUserManual.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkIsoSurfaceUserManual.dox
similarity index 96%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkIsoSurfaceUserManual.dox
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkIsoSurfaceUserManual.dox
index 214e858245..1e8bb8c1f5 100644
--- a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkIsoSurfaceUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkIsoSurfaceUserManual.dox
@@ -1,37 +1,37 @@
 /**
 
-\page org_isosurface The Iso Surface Module
+\page org_mitk_views_isosurface The Iso Surface Module
 
 \image html IsoSurfaceIcon.png "Icon of the Module"
 
 Available sections:
   - \ref QmitkIsoSurfaceUserManualOverview 
   - \ref QmitkIsoSurfaceUserManualFeatures 
   - \ref QmitkIsoSurfaceUserManualUsage 
   - \ref QmitkIsoSurfaceUserManualTroubleshooting
 
 \section QmitkIsoSurfaceUserManualOverview Overview
 
 IsoSurface is a program module for creating surfaces (e.g. polygon structures) out of images. The user defines a threshold that seperates object and background inside the image. Pixels that belong to the object need grey values below the threshold. Pixles with grey values above the threshold will be ignored. The result is a polygon object 
 that can be saved as an *.stl-object. 
 
 \section QmitkIsoSurfaceUserManualFeatures Features
 
 - Creates a surface by thresholding an image
 
     
 \section QmitkIsoSurfaceUserManualUsage Usage
 How to create a surface:
 
 - Load an image into the program, for example by drag & drop 
 - Look for a meaningful threshold. All pixel grey values of the image that are lower than the threshold will be used to create the surface. All grey values that are higher than the surface will be ignored. You can find the best threshold by using the Volumetry-Functionality or by reading the grey value while clicking on a pixel (see picture 2). 
 - Insert the threshold into the GUI 
 - Press the Button "Create Surface" 
 
 
 \image html IsoSurfaceGUI.png "Graphical User Interface of Iso Surface"
 
 \section QmitkIsoSurfaceUserManualTroubleshooting Troubleshooting
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkRegionGrowingUserManual.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkRegionGrowingUserManual.dox
similarity index 72%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkRegionGrowingUserManual.dox
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkRegionGrowingUserManual.dox
index 81c517db55..2b1f8a2467 100644
--- a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkRegionGrowingUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkRegionGrowingUserManual.dox
@@ -1,29 +1,29 @@
 /**
-\page org_regiongrowing The Region Growing Module
+\page org_mitk_views_regiongrowing The Region Growing View
 
-\image html regiongrowing.png "Icon of the Module"
+\image html regiongrowing.png "Icon of the View"
 
 Available documentation sections:
 - \ref QmitkRegionGrowingUserManualOverview
 - \ref QmitkRegionGrowingUserManualUsage
 
 \section QmitkRegionGrowingUserManualOverview Overview
 
-The Region growing module provides a programming example, showing developers how to create new bundles for MITK with a graphical user interface (GUI) that also uses some ITK image filters. 
+The Region growing view provides a programming example, showing developers how to create new views for MITK with a graphical user interface (GUI) that also uses some ITK image filters. 
 
 <b>For the programmers:</b> this functionality is the result of <a href="http://docs.mitk.org/nightly/Step9Page.html">tutorial step 9</a>
 
 \section QmitkRegionGrowingUserManualUsage Usage
 
 <ul>
 
 <li> you can set a number of seed points by clicking into the render windows while holding down the shift key.
 </li>
 <li> when clicking "Start region growing", a region growing algorithm starts. This algorithm is gray values based. The gray values are determined from the gray values at all point positions plus/minus a safety margin of 30 (Hounsfield units).
 </li>
 </ul>
 
 
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkSimpleExampleUserManual.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkSimpleExampleUserManual.dox
similarity index 94%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkSimpleExampleUserManual.dox
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkSimpleExampleUserManual.dox
index a501bb12c1..12df11bc6d 100644
--- a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkSimpleExampleUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkSimpleExampleUserManual.dox
@@ -1,21 +1,21 @@
 /**
-\page org_simpleexample The Simple Example module
+\page org_mitk_views_simpleexample The Simple Example module
 
 \image html SimpleExample.png "Icon of the Module"
 
 \section QmitkSimpleExampleViewUserManualSummary Summary
 
 This module is namely a simple example for simple image interaction. 
 It offers:
 <ul>
 <li>Sliders to navigate through the different slice stacks (Axial, Sagittal, Coronal) and the time steps
 <li>A "player" for image time series. It automatically steps through all time series with a speed defined by the slider on the right.
 <li>A button "Re-Initialize Navigators" to reinitialize those sliders to their initial position (Slice and time position 0)
 <li>A button "Take Screenshot" to take a screenshot of the chosen window (1=Transveral, 2=Sagittal, 3=Coronal, 4=3D View)
 <li>A button "Take HighDef 3D Screenshot" to take an high resolution screenshot of the 3D scene
 <li>A button "Generate Movie" whichs takes a movie of the chosen window by scrolling either through all slices (Axial, Sagittal, Coronal)
 or rotating the 3D scene
 <li>A selection box where the 3D view can be transformed into either a red-blue stereo or a D4D stereo view
 </ul>
 */
 
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkSimpleMeasurementUserManual.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkSimpleMeasurementUserManual.dox
similarity index 96%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkSimpleMeasurementUserManual.dox
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkSimpleMeasurementUserManual.dox
index 72d0a53688..f3aadf2c81 100644
--- a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkSimpleMeasurementUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkSimpleMeasurementUserManual.dox
@@ -1,44 +1,44 @@
 /**
-\page org_simplemeasurement The Simple Measurement Module
+\page org_mitk_views_simplemeasurement The Simple Measurement Module
 
 \image html SimpleMeasurementIcon.png  "Icon of the Module"
 
 Available sections:
   - \ref QmitkSimpleMeasurementUserManualOverview 
   - \ref QmitkSimpleMeasurementUserManualFeatures 
   - \ref QmitkSimpleMeasurementUserManualUsage 
 
 \section QmitkSimpleMeasurementUserManualOverview Overview
 
 SimpleMeasurement is a program module that allows to measure distances, angles and paths on a dataset.
 
 \section QmitkSimpleMeasurementUserManualFeatures Features
 
 <ul>
   <li> The SimpleMeasurement Module is able to measure:
   <ul>
     <li> Distances between two points
     <li> Angles between two lines (defined by three points) 
     <li> Distances along a path 
     </ul>
 </ul>
     
 \section QmitkSimpleMeasurementUserManualUsage Usage
 To use the SimpleMeasurement Module, a data set must first be loaded. This can be done by drag & drop.
 Choose the simplemeasurement method you need by pressing the according button. 
 <ul>
   <li>Points can be set by "shift-clicking" on the place in the data set. 
   <li>Remove points by pressing the del-button on your keyboard. 
   <li>You can mark a point by clicking on it with the cursor and moving it while the mouse button is still pressed. 
 </ul>
 What the different modes mean and how to use them:
 <ul>
   <li> Distances(a): To measure the distance between two points, you have to set two points. The distance will be displayed on the line between the points.
   <li> Angles(b): Angles can be measured between two lines. For that you have to set three points. The angle will be displayed between the two lines. 
   <li> Path(c): Distances and angles along a path can be measured by setting at least two (for distance) or three (for angles) or more (for longer paths) points. The distance and the angles for each part will be displayed next to the path.
 </ul>
 
 \image html SimpleMeasurementGUI.png Graphical User Interface of SimpleMeasurement
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/SimpleExample.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/SimpleExample.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/SimpleExample.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/SimpleExample.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/SimpleMeasurementGUI.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/SimpleMeasurementGUI.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/SimpleMeasurementGUI.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/SimpleMeasurementGUI.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/SimpleMeasurementIcon.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/SimpleMeasurementIcon.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/SimpleMeasurementIcon.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/SimpleMeasurementIcon.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/org_mitk_gui_qt_viewinitialization.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/org_mitk_gui_qt_viewinitialization.dox
similarity index 80%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/org_mitk_gui_qt_viewinitialization.dox
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/org_mitk_gui_qt_viewinitialization.dox
index 11f97bd1d3..f192b11dd4 100644
--- a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/org_mitk_gui_qt_viewinitialization.dox
+++ b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/org_mitk_gui_qt_viewinitialization.dox
@@ -1,8 +1,8 @@
 /**
-\page org_viewinitialitzation The View Initialization Module
+\page org_mitk_views_viewinitialitzation The View Initialization Module
 
 \image html viewInitializationIcon.png "Icon of the Module"
 
 This view serves as a sandbox for understanding and experimenting with the geometry initialization parameters. For example, to view the axial slices from above instead of from below. It is not intended for end users, but for developers.
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/regiongrowing.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/regiongrowing.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/regiongrowing.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/regiongrowing.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/regiongrowing.xpm b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/regiongrowing.xpm
similarity index 95%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/regiongrowing.xpm
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/regiongrowing.xpm
index 45304646ee..5ba3fbe102 100644
--- a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/regiongrowing.xpm
+++ b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/regiongrowing.xpm
@@ -1,53 +1,53 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"28 26 24 1",
-" 	c None",
-".	c #000000",
-"+	c #639A31",
-"@	c #316500",
-"#	c #6B9A31",
-"$	c #94CF63",
-"%	c #396500",
-"&	c #9CCB6B",
-"*	c #94CB63",
-"=	c #9CCB63",
-"-	c #6B9639",
-";	c #316900",
-">	c #949A94",
-",	c #9C969C",
-"'	c #6B656B",
-")	c #CECBCE",
-"!	c #9C9A9C",
-"~	c #393039",
-"{	c #313431",
-"]	c #C6CFC6",
-"^	c #636963",
-"/	c #636563",
-"(	c #9C6500",
-"_	c #946500",
-"                ..          ",
-"               .+@.         ",
-"              .#$%.         ",
-"              .&+.   ....   ",
-"              .+.   .+&*@.  ",
-"               .   .=$#+%.  ",
-"                   .$....   ",
-"                    .       ",
-"     ............           ",
-"   ..+*&=+&++-+++..         ",
-"  .=-;%;@%@%;@@%;-+.   ...  ",
-"  .+@@@@%;@;%;%;@@&+. .++-. ",
-"  .%@-+=&+-++#++-*#+.  .&+@.",
-"  .>>@;@;;@;#+%+;@;-.   .&%.",
-"  .,'))>!'>'=+%;'~{+.    .;.",
-"  .>!])'!^!{-+;//{{-@.    . ",
-"  .!'))>!'{~;&@'{/~+@.      ",
-" .(>>)]'>{{/'@/{'{{+%.      ",
-"._{{{{{{~{,'^'/'/{~@@.      ",
-" .(,>))/>/!//^'^{'{..       ",
-"  .>/])>,/>'/'/~^{{.        ",
-"  .!,>>'>'>/^/^'/~{./^      ",
-"  .{{!'!!'>''''/~{{.''//'/  ",
-"  /..{{~{{~{{{{{{../^^/'^'' ",
-"   ^/............'^/''^'//  ",
-"       /'^'/^'//^//'//      "};
+/* XPM */
+static const char * icon_xpm[] = {
+"28 26 24 1",
+" 	c None",
+".	c #000000",
+"+	c #639A31",
+"@	c #316500",
+"#	c #6B9A31",
+"$	c #94CF63",
+"%	c #396500",
+"&	c #9CCB6B",
+"*	c #94CB63",
+"=	c #9CCB63",
+"-	c #6B9639",
+";	c #316900",
+">	c #949A94",
+",	c #9C969C",
+"'	c #6B656B",
+")	c #CECBCE",
+"!	c #9C9A9C",
+"~	c #393039",
+"{	c #313431",
+"]	c #C6CFC6",
+"^	c #636963",
+"/	c #636563",
+"(	c #9C6500",
+"_	c #946500",
+"                ..          ",
+"               .+@.         ",
+"              .#$%.         ",
+"              .&+.   ....   ",
+"              .+.   .+&*@.  ",
+"               .   .=$#+%.  ",
+"                   .$....   ",
+"                    .       ",
+"     ............           ",
+"   ..+*&=+&++-+++..         ",
+"  .=-;%;@%@%;@@%;-+.   ...  ",
+"  .+@@@@%;@;%;%;@@&+. .++-. ",
+"  .%@-+=&+-++#++-*#+.  .&+@.",
+"  .>>@;@;;@;#+%+;@;-.   .&%.",
+"  .,'))>!'>'=+%;'~{+.    .;.",
+"  .>!])'!^!{-+;//{{-@.    . ",
+"  .!'))>!'{~;&@'{/~+@.      ",
+" .(>>)]'>{{/'@/{'{{+%.      ",
+"._{{{{{{~{,'^'/'/{~@@.      ",
+" .(,>))/>/!//^'^{'{..       ",
+"  .>/])>,/>'/'/~^{{.        ",
+"  .!,>>'>'>/^/^'/~{./^      ",
+"  .{{!'!!'>''''/~{{.''//'/  ",
+"  /..{{~{{~{{{{{{../^^/'^'' ",
+"   ^/............'^/''^'//  ",
+"       /'^'/^'//^//'//      "};
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/viewInitializationIcon.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/viewInitializationIcon.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/viewInitializationIcon.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/viewInitializationIcon.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/viewInitializationIcon.xpm b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/viewInitializationIcon.xpm
similarity index 93%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/viewInitializationIcon.xpm
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/viewInitializationIcon.xpm
index 819882324c..11ccbcc699 100644
--- a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/viewInitializationIcon.xpm
+++ b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/viewInitializationIcon.xpm
@@ -1,17 +1,17 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"11 11 3 1",
-" 	c None",
-".	c #CBCBCB",
-"+	c #404040",
-"+++++++++++",
-"+..+...+..+",
-"+++++++++++",
-"+..+...+..+",
-"+..+...+..+",
-"+++++++++++",
-"+..+...+..+",
-"+..+...+..+",
-"+++++++++++",
-"+..+...+..+",
-"+++++++++++"};
+/* XPM */
+static const char * icon_xpm[] = {
+"11 11 3 1",
+" 	c None",
+".	c #CBCBCB",
+"+	c #404040",
+"+++++++++++",
+"+..+...+..+",
+"+++++++++++",
+"+..+...+..+",
+"+..+...+..+",
+"+++++++++++",
+"+..+...+..+",
+"+..+...+..+",
+"+++++++++++",
+"+..+...+..+",
+"+++++++++++"};
diff --git a/Plugins/org.mitk.gui.qt.ext/resources/dcm-icon.png b/Plugins/org.mitk.gui.qt.ext/resources/dcm-icon.png
new file mode 100644
index 0000000000..f1d529ee3a
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.ext/resources/dcm-icon.png differ
diff --git a/Plugins/org.mitk.gui.qt.ext/resources/org_mitk_gui_qt_ext.qrc b/Plugins/org.mitk.gui.qt.ext/resources/org_mitk_gui_qt_ext.qrc
index 9aaabf6cd5..2e85bf72fc 100644
--- a/Plugins/org.mitk.gui.qt.ext/resources/org_mitk_gui_qt_ext.qrc
+++ b/Plugins/org.mitk.gui.qt.ext/resources/org_mitk_gui_qt_ext.qrc
@@ -1,11 +1,12 @@
 <RCC>
     <qresource prefix="/org.mitk.gui.qt.ext" >
         <file>Load_48.png</file>
         <file>Redo_48.png</file>
         <file>Save_48.png</file>
         <file>Undo_48.png</file>
         <file>Remove_48.png</file>
+        <file>dcm-icon.png</file>
         <file>Slider.png</file>
         <file>index.html</file>
     </qresource>
 </RCC>
diff --git a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
index 734c11a634..b6acb9ba4d 100644
--- a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
+++ b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
@@ -1,1190 +1,1190 @@
 /*===================================================================
 
 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 "QmitkExtWorkbenchWindowAdvisor.h"
 #include "QmitkExtActionBarAdvisor.h"
 
 #include <QMenu>
 #include <QMenuBar>
 #include <QMainWindow>
 #include <QStatusBar>
 #include <QString>
 #include <QFile>
 #include <QRegExp>
 #include <QTextStream>
 #include <QSettings>
 
 #include <ctkPluginException.h>
 #include <service/event/ctkEventAdmin.h>
 
 #include <berryPlatform.h>
 #include <berryPlatformUI.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryIPerspectiveRegistry.h>
 #include <berryIPerspectiveDescriptor.h>
 #include <berryIWorkbenchPartConstants.h>
 
 #include <internal/berryQtShowViewAction.h>
 #include <internal/berryQtOpenPerspectiveAction.h>
 
 #include <QmitkFileOpenAction.h>
 #include <QmitkExtFileSaveProjectAction.h>
 #include <QmitkFileExitAction.h>
 #include <QmitkCloseProjectAction.h>
 #include <QmitkDefaultDropTargetListener.h>
 #include <QmitkStatusBar.h>
 #include <QmitkProgressBar.h>
 #include <QmitkMemoryUsageIndicatorView.h>
 #include <QmitkPreferencesDialog.h>
 #include <QmitkOpenDicomEditorAction.h>
 
 #include <itkConfigure.h>
 #include <vtkConfigure.h>
 #include <mitkVersion.h>
 #include <mitkIDataStorageService.h>
 #include <mitkIDataStorageReference.h>
 #include <mitkDataStorageEditorInput.h>
 #include <mitkWorkbenchUtil.h>
 
 // UGLYYY
 #include "internal/QmitkExtWorkbenchWindowAdvisorHack.h"
 #include "internal/QmitkCommonExtPlugin.h"
 #include "mitkUndoController.h"
 #include "mitkVerboseLimitedLinearUndo.h"
 #include <QToolBar>
 #include <QMessageBox>
 #include <QLabel>
 #include <QmitkAboutDialog/QmitkAboutDialog.h>
 
 QmitkExtWorkbenchWindowAdvisorHack
 * QmitkExtWorkbenchWindowAdvisorHack::undohack =
 new QmitkExtWorkbenchWindowAdvisorHack();
 
 QString QmitkExtWorkbenchWindowAdvisor::QT_SETTINGS_FILENAME = "QtSettings.ini";
 
 class PartListenerForTitle: public berry::IPartListener
 {
 public:
 
  PartListenerForTitle(QmitkExtWorkbenchWindowAdvisor* wa) :
    windowAdvisor(wa)
    {
    }
 
    Events::Types GetPartEventTypes() const
    {
     return Events::ACTIVATED | Events::BROUGHT_TO_TOP | Events::CLOSED
      | Events::HIDDEN | Events::VISIBLE;
    }
 
    void PartActivated(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref.Cast<berry::IEditorReference> ())
     {
      windowAdvisor->UpdateTitle(false);
     }
    }
 
    void PartBroughtToTop(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref.Cast<berry::IEditorReference> ())
     {
      windowAdvisor->UpdateTitle(false);
     }
    }
 
    void PartClosed(berry::IWorkbenchPartReference::Pointer /*ref*/)
    {
     windowAdvisor->UpdateTitle(false);
    }
 
    void PartHidden(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (!windowAdvisor->lastActiveEditor.Expired() &&
      ref->GetPart(false) == windowAdvisor->lastActiveEditor.Lock())
     {
      windowAdvisor->UpdateTitle(true);
     }
    }
 
    void PartVisible(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (!windowAdvisor->lastActiveEditor.Expired() &&
      ref->GetPart(false) == windowAdvisor->lastActiveEditor.Lock())
     {
      windowAdvisor->UpdateTitle(false);
     }
    }
 
 private:
  QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
 
 };
 
 class PartListenerForImageNavigator: public berry::IPartListener
 {
 public:
 
  PartListenerForImageNavigator(QAction* act) :
    imageNavigatorAction(act)
    {
    }
 
    Events::Types GetPartEventTypes() const
    {
     return Events::OPENED | Events::CLOSED | Events::HIDDEN |
      Events::VISIBLE;
    }
 
    void PartOpened(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
      imageNavigatorAction->setChecked(true);
     }
    }
 
    void PartClosed(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
      imageNavigatorAction->setChecked(false);
     }
    }
 
    void PartVisible(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
      imageNavigatorAction->setChecked(true);
     }
    }
 
    void PartHidden(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
      imageNavigatorAction->setChecked(false);
     }
    }
 
 private:
  QAction* imageNavigatorAction;
 
 };
 
 class PerspectiveListenerForTitle: public berry::IPerspectiveListener
 {
 public:
 
  PerspectiveListenerForTitle(QmitkExtWorkbenchWindowAdvisor* wa) :
    windowAdvisor(wa), perspectivesClosed(false)
    {
    }
 
    Events::Types GetPerspectiveEventTypes() const
    {
     return Events::ACTIVATED | Events::SAVED_AS | Events::DEACTIVATED
      // remove the following line when command framework is finished
      | Events::CLOSED | Events::OPENED;
    }
 
    void PerspectiveActivated(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*perspective*/)
    {
     windowAdvisor->UpdateTitle(false);
    }
 
    void PerspectiveSavedAs(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*oldPerspective*/,
     berry::IPerspectiveDescriptor::Pointer /*newPerspective*/)
    {
     windowAdvisor->UpdateTitle(false);
    }
 
    void PerspectiveDeactivated(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*perspective*/)
    {
     windowAdvisor->UpdateTitle(false);
    }
 
    void PerspectiveOpened(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*perspective*/)
    {
     if (perspectivesClosed)
     {
      QListIterator<QAction*> i(windowAdvisor->viewActions);
      while (i.hasNext())
      {
       i.next()->setEnabled(true);
      }
 
          //GetViewRegistry()->Find("org.mitk.views.imagenavigator");
      if(windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicomeditor"))
      {
         windowAdvisor->openDicomEditorAction->setEnabled(true);
      }
      windowAdvisor->fileSaveProjectAction->setEnabled(true);
      windowAdvisor->closeProjectAction->setEnabled(true);
      windowAdvisor->undoAction->setEnabled(true);
      windowAdvisor->redoAction->setEnabled(true);
      windowAdvisor->imageNavigatorAction->setEnabled(true);
      windowAdvisor->resetPerspAction->setEnabled(true);
      if( windowAdvisor->GetShowClosePerspectiveMenuItem() )
      {
        windowAdvisor->closePerspAction->setEnabled(true);
      }
     }
 
     perspectivesClosed = false;
    }
 
    void PerspectiveClosed(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*perspective*/)
    {
     berry::IWorkbenchWindow::Pointer wnd = windowAdvisor->GetWindowConfigurer()->GetWindow();
     bool allClosed = true;
     if (wnd->GetActivePage())
     {
      std::vector<berry::IPerspectiveDescriptor::Pointer> perspectives(wnd->GetActivePage()->GetOpenPerspectives());
      allClosed = perspectives.empty();
     }
 
     if (allClosed)
     {
      perspectivesClosed = true;
 
      QListIterator<QAction*> i(windowAdvisor->viewActions);
      while (i.hasNext())
      {
       i.next()->setEnabled(false);
      }
 
      if(windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicomeditor"))
      {
         windowAdvisor->openDicomEditorAction->setEnabled(false);
      }
      windowAdvisor->fileSaveProjectAction->setEnabled(false);
      windowAdvisor->closeProjectAction->setEnabled(false);
      windowAdvisor->undoAction->setEnabled(false);
      windowAdvisor->redoAction->setEnabled(false);
      windowAdvisor->imageNavigatorAction->setEnabled(false);
      windowAdvisor->resetPerspAction->setEnabled(false);
      if( windowAdvisor->GetShowClosePerspectiveMenuItem() )
      {
        windowAdvisor->closePerspAction->setEnabled(false);
      }
     }
    }
 
 private:
  QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
  bool perspectivesClosed;
 };
 
 class PerspectiveListenerForMenu: public berry::IPerspectiveListener
 {
 public:
 
  PerspectiveListenerForMenu(QmitkExtWorkbenchWindowAdvisor* wa) :
    windowAdvisor(wa)
    {
    }
 
    Events::Types GetPerspectiveEventTypes() const
    {
     return Events::ACTIVATED | Events::DEACTIVATED;
    }
 
    void PerspectiveActivated(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer perspective)
    {
      QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
      if (action)
      {
        action->setChecked(true);
      }
    }
 
    void PerspectiveDeactivated(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer perspective)
    {
      QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
      if (action)
      {
        action->setChecked(false);
      }
    }
 
 private:
  QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
 };
 
 
 
 QmitkExtWorkbenchWindowAdvisor::QmitkExtWorkbenchWindowAdvisor(berry::WorkbenchAdvisor* wbAdvisor,
                   berry::IWorkbenchWindowConfigurer::Pointer configurer) :
 berry::WorkbenchWindowAdvisor(configurer),
 lastInput(0),
 wbAdvisor(wbAdvisor),
 showViewToolbar(true),
 showPerspectiveToolbar(false),
 showVersionInfo(true),
 showMitkVersionInfo(true),
 showViewMenuItem(true),
 showNewWindowMenuItem(false),
 showClosePerspectiveMenuItem(true),
 dropTargetListener(new QmitkDefaultDropTargetListener)
 {
- productName = berry::Platform::GetConfiguration().getString("application.baseName");
+ productName = QCoreApplication::applicationName().toStdString();
 }
 
 berry::ActionBarAdvisor::Pointer QmitkExtWorkbenchWindowAdvisor::CreateActionBarAdvisor(
  berry::IActionBarConfigurer::Pointer configurer)
 {
  berry::ActionBarAdvisor::Pointer actionBarAdvisor(
   new QmitkExtActionBarAdvisor(configurer));
  return actionBarAdvisor;
 }
 
 void* QmitkExtWorkbenchWindowAdvisor::CreateEmptyWindowContents(void* parent)
 {
  QWidget* parentWidget = static_cast<QWidget*>(parent);
  QLabel* label = new QLabel(parentWidget);
  label->setText("<b>No perspectives are open. Open a perspective in the <i>Window->Open Perspective</i> menu.</b>");
  label->setContentsMargins(10,10,10,10);
  label->setAlignment(Qt::AlignTop);
  label->setEnabled(false);
  parentWidget->layout()->addWidget(label);
  return label;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowClosePerspectiveMenuItem(bool show)
 {
  showClosePerspectiveMenuItem = show;
 }
 
 bool QmitkExtWorkbenchWindowAdvisor::GetShowClosePerspectiveMenuItem()
 {
   return showClosePerspectiveMenuItem;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowNewWindowMenuItem(bool show)
 {
  showNewWindowMenuItem = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowViewToolbar(bool show)
 {
  showViewToolbar = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowViewMenuItem(bool show)
 {
  showViewMenuItem = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowPerspectiveToolbar(bool show)
 {
  showPerspectiveToolbar = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowVersionInfo(bool show)
 {
  showVersionInfo = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowMitkVersionInfo(bool show)
 {
  showMitkVersionInfo = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetProductName(const std::string& product)
 {
  productName = product;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetWindowIcon(const std::string& wndIcon)
 {
  windowIcon = wndIcon;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PostWindowCreate()
 {
  // very bad hack...
  berry::IWorkbenchWindow::Pointer window =
   this->GetWindowConfigurer()->GetWindow();
  QMainWindow* mainWindow =
   static_cast<QMainWindow*> (window->GetShell()->GetControl());
 
  if (!windowIcon.empty())
  {
   mainWindow->setWindowIcon(QIcon(QString::fromStdString(windowIcon)));
  }
  mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
 
  /*mainWindow->setStyleSheet("color: white;"
  "background-color: #808080;"
  "selection-color: #659EC7;"
  "selection-background-color: #808080;"
  " QMenuBar {"
  "background-color: #808080; }");*/
 
  // ==== Application menu ============================
  QMenuBar* menuBar = mainWindow->menuBar();
  menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
 
  QMenu* fileMenu = menuBar->addMenu("&File");
  fileMenu->setObjectName("FileMenu");
 
  QAction* fileOpenAction = new QmitkFileOpenAction(QIcon(":/org.mitk.gui.qt.ext/Load_48.png"), window);
  fileMenu->addAction(fileOpenAction);
  fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
  fileSaveProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Save_48.png"));
  fileMenu->addAction(fileSaveProjectAction);
  closeProjectAction = new QmitkCloseProjectAction(window);
  closeProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Remove_48.png"));
  fileMenu->addAction(closeProjectAction);
  fileMenu->addSeparator();
  QAction* fileExitAction = new QmitkFileExitAction(window);
  fileExitAction->setObjectName("QmitkFileExitAction");
  fileMenu->addAction(fileExitAction);
 
 if(this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicomeditor"))
 {
- openDicomEditorAction = new QmitkOpenDicomEditorAction(window);
+ openDicomEditorAction = new QmitkOpenDicomEditorAction(QIcon(":/org.mitk.gui.qt.ext/dcm-icon.png"),window);
 }
 
  berry::IViewRegistry* viewRegistry =
   berry::PlatformUI::GetWorkbench()->GetViewRegistry();
  const std::vector<berry::IViewDescriptor::Pointer>& viewDescriptors =
   viewRegistry->GetViews();
 
  // another bad hack to get an edit/undo menu...
  QMenu* editMenu = menuBar->addMenu("&Edit");
  undoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Undo_48.png"),
   "&Undo",
   QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
   QKeySequence("CTRL+Z"));
  undoAction->setToolTip("Undo the last action (not supported by all modules)");
  redoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Redo_48.png")
   , "&Redo",
   QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
   QKeySequence("CTRL+Y"));
  redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
 
  imageNavigatorAction = new QAction(QIcon(":/org.mitk.gui.qt.ext/Slider.png"), "&Image Navigator", NULL);
  bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
  if (imageNavigatorViewFound)
  {
    QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
    imageNavigatorAction->setCheckable(true);
 
    // add part listener for image navigator
    imageNavigatorPartListener = new PartListenerForImageNavigator(imageNavigatorAction);
    window->GetPartService()->AddPartListener(imageNavigatorPartListener);
    berry::IViewPart::Pointer imageNavigatorView =
        window->GetActivePage()->FindView("org.mitk.views.imagenavigator");
    imageNavigatorAction->setChecked(false);
    if (imageNavigatorView)
    {
      bool isImageNavigatorVisible = window->GetActivePage()->IsPartVisible(imageNavigatorView);
      if (isImageNavigatorVisible)
        imageNavigatorAction->setChecked(true);
    }
    imageNavigatorAction->setToolTip("Open image navigator for navigating through image");
  }
 
  // toolbar for showing file open, undo, redo and other main actions
  QToolBar* mainActionsToolBar = new QToolBar;
  mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
 #ifdef __APPLE__
  mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
 #else
  mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
 #endif
 
  mainActionsToolBar->addAction(fileOpenAction);
  mainActionsToolBar->addAction(fileSaveProjectAction);
  mainActionsToolBar->addAction(closeProjectAction);
  mainActionsToolBar->addAction(undoAction);
  mainActionsToolBar->addAction(redoAction);
 if(this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicomeditor"))
 {
  mainActionsToolBar->addAction(openDicomEditorAction);
 }
  if (imageNavigatorViewFound)
  {
    mainActionsToolBar->addAction(imageNavigatorAction);
  }
  mainWindow->addToolBar(mainActionsToolBar);
 
 #ifdef __APPLE__
  mainWindow->setUnifiedTitleAndToolBarOnMac(true);
 #endif
 
  // ==== Window Menu ==========================
  QMenu* windowMenu = menuBar->addMenu("Window");
  if (showNewWindowMenuItem)
  {
    windowMenu->addAction("&New Window", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onNewWindow()));
    windowMenu->addSeparator();
  }
 
  QMenu* perspMenu = windowMenu->addMenu("&Open Perspective");
 
  QMenu* viewMenu;
  if (showViewMenuItem)
  {
    viewMenu = windowMenu->addMenu("Show &View");
    viewMenu->setObjectName("Show View");
  }
  windowMenu->addSeparator();
  resetPerspAction = windowMenu->addAction("&Reset Perspective",
   QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onResetPerspective()));
 
  if(showClosePerspectiveMenuItem)
   closePerspAction = windowMenu->addAction("&Close Perspective", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onClosePerspective()));
 
  windowMenu->addSeparator();
  windowMenu->addAction("&Preferences...",
   QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onEditPreferences()),
   QKeySequence("CTRL+P"));
 
  // fill perspective menu
  berry::IPerspectiveRegistry* perspRegistry =
   window->GetWorkbench()->GetPerspectiveRegistry();
  QActionGroup* perspGroup = new QActionGroup(menuBar);
 
  std::vector<berry::IPerspectiveDescriptor::Pointer> perspectives(
   perspRegistry->GetPerspectives());
 
     bool skip = false;
     for (std::vector<berry::IPerspectiveDescriptor::Pointer>::iterator perspIt =
       perspectives.begin(); perspIt != perspectives.end(); ++perspIt)
     {
 
       // if perspectiveExcludeList is set, it contains the id-strings of perspectives, which
       // should not appear as an menu-entry in the perspective menu
       if (perspectiveExcludeList.size() > 0)
       {
         for (unsigned int i=0; i<perspectiveExcludeList.size(); i++)
         {
           if (perspectiveExcludeList.at(i) == (*perspIt)->GetId())
           {
             skip = true;
             break;
           }
         }
         if (skip)
         {
           skip = false;
           continue;
         }
       }
 
       QAction* perspAction = new berry::QtOpenPerspectiveAction(window,
         *perspIt, perspGroup);
       mapPerspIdToAction.insert(std::make_pair((*perspIt)->GetId(), perspAction));
     }
  perspMenu->addActions(perspGroup->actions());
 
  // sort elements (converting vector to map...)
  std::vector<berry::IViewDescriptor::Pointer>::const_iterator iter;
  std::map<std::string, berry::IViewDescriptor::Pointer> VDMap;
 
  skip = false;
  for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
  {
 
    // if viewExcludeList is set, it contains the id-strings of view, which
    // should not appear as an menu-entry in the menu
    if (viewExcludeList.size() > 0)
    {
      for (unsigned int i=0; i<viewExcludeList.size(); i++)
      {
        if (viewExcludeList.at(i) == (*iter)->GetId())
        {
          skip = true;
          break;
        }
      }
      if (skip)
      {
        skip = false;
        continue;
      }
    }
 
   if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
    continue;
   if ((*iter)->GetId() == "org.mitk.views.imagenavigator")
    continue;
 
   std::pair<std::string, berry::IViewDescriptor::Pointer> p(
    (*iter)->GetLabel(), (*iter));
   VDMap.insert(p);
  }
  // ==================================================
 
   // ==== Perspective Toolbar ==================================
  QToolBar* qPerspectiveToolbar = new QToolBar;
 
  if (showPerspectiveToolbar)
  {
   qPerspectiveToolbar->addActions(perspGroup->actions());
   mainWindow->addToolBar(qPerspectiveToolbar);
  }
  else
   delete qPerspectiveToolbar;
 
  // ==== View Toolbar ==================================
  QToolBar* qToolbar = new QToolBar;
 
  std::map<std::string, berry::IViewDescriptor::Pointer>::const_iterator
   MapIter;
  for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
  {
   berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window,
    (*MapIter).second);
   viewActions.push_back(viewAction);
   if(showViewMenuItem)
     viewMenu->addAction(viewAction);
   if (showViewToolbar)
   {
    qToolbar->addAction(viewAction);
   }
  }
 
  if (showViewToolbar)
  {
   mainWindow->addToolBar(qToolbar);
  }
  else
   delete qToolbar;
 
  QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
  mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
 
 
  // ====================================================
 
  // ===== Help menu ====================================
- QMenu* helpMenu = menuBar->addMenu("Help");
+ QMenu* helpMenu = menuBar->addMenu("&Help");
  helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
- helpMenu->addAction("&Contents", this, SLOT(onHelpContents()));
-  helpMenu->addAction("Context &Help",this, SLOT(onHelp()),  QKeySequence("F1"));
+ helpMenu->addAction("&Open Help Perspective", this, SLOT(onHelpOpenHelpPerspective()));
+  helpMenu->addAction("&Context Help",this, SLOT(onHelp()),  QKeySequence("F1"));
  helpMenu->addAction("&About",this, SLOT(onAbout()));
  // =====================================================
 
 
  QStatusBar* qStatusBar = new QStatusBar();
 
  //creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
  QmitkStatusBar *statusBar = new QmitkStatusBar(qStatusBar);
  //disabling the SizeGrip in the lower right corner
  statusBar->SetSizeGripEnabled(false);
 
 
 
  QmitkProgressBar *progBar = new QmitkProgressBar();
 
  qStatusBar->addPermanentWidget(progBar, 0);
  progBar->hide();
 // progBar->AddStepsToDo(2);
 // progBar->Progress(1);
 
  mainWindow->setStatusBar(qStatusBar);
 
  QmitkMemoryUsageIndicatorView* memoryIndicator =
   new QmitkMemoryUsageIndicatorView();
  qStatusBar->addPermanentWidget(memoryIndicator, 0);
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PreWindowOpen()
 {
  berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
 
  // show the shortcut bar and progress indicator, which are hidden by
  // default
  //configurer->SetShowPerspectiveBar(true);
  //configurer->SetShowFastViewBars(true);
  //configurer->SetShowProgressIndicator(true);
 
  //  // add the drag and drop support for the editor area
  //  configurer.addEditorAreaTransfer(EditorInputTransfer.getInstance());
  //  configurer.addEditorAreaTransfer(ResourceTransfer.getInstance());
  //  configurer.addEditorAreaTransfer(FileTransfer.getInstance());
  //  configurer.addEditorAreaTransfer(MarkerTransfer.getInstance());
  //  configurer.configureEditorAreaDropListener(new EditorAreaDropAdapter(
  //      configurer.getWindow()));
 
  this->HookTitleUpdateListeners(configurer);
 
  menuPerspectiveListener = new PerspectiveListenerForMenu(this);
  configurer->GetWindow()->AddPerspectiveListener(menuPerspectiveListener);
 
  configurer->AddEditorAreaTransfer(QStringList("text/uri-list"));
  configurer->ConfigureEditorAreaDropListener(dropTargetListener);
 
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PostWindowOpen()
 {
   // Force Rendering Window Creation on startup.
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
 
   ctkPluginContext* context = QmitkCommonExtPlugin::getContext();
   ctkServiceReference serviceRef = context->getServiceReference<mitk::IDataStorageService>();
   if (serviceRef)
   {
     mitk::IDataStorageService *dsService = context->getService<mitk::IDataStorageService>(serviceRef);
     if (dsService)
     {
       mitk::IDataStorageReference::Pointer dsRef = dsService->GetDataStorage();
       mitk::DataStorageEditorInput::Pointer dsInput(new mitk::DataStorageEditorInput(dsRef));
       mitk::WorkbenchUtil::OpenEditor(configurer->GetWindow()->GetActivePage(),dsInput);
     }
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onIntro()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onIntro();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onHelp()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onHelp();
 }
 
-void QmitkExtWorkbenchWindowAdvisor::onHelpContents()
+void QmitkExtWorkbenchWindowAdvisor::onHelpOpenHelpPerspective()
 {
-  QmitkExtWorkbenchWindowAdvisorHack::undohack->onHelpContents();
+  QmitkExtWorkbenchWindowAdvisorHack::undohack->onHelpOpenHelpPerspective();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onAbout()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onAbout();
 }
 
 //--------------------------------------------------------------------------------
 // Ugly hack from here on. Feel free to delete when command framework
 // and undo buttons are done.
 //--------------------------------------------------------------------------------
 
 QmitkExtWorkbenchWindowAdvisorHack::QmitkExtWorkbenchWindowAdvisorHack() : QObject()
 {
 
 }
 
 QmitkExtWorkbenchWindowAdvisorHack::~QmitkExtWorkbenchWindowAdvisorHack()
 {
 
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onUndo()
 {
  mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
  if (model)
  {
   if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>( model ))
   {
    mitk::VerboseLimitedLinearUndo::StackDescription descriptions =
     verboseundo->GetUndoDescriptions();
    if (descriptions.size() >= 1)
    {
     MITK_INFO << "Undo " << descriptions.front().second;
    }
   }
   model->Undo();
  }
  else
  {
   MITK_ERROR << "No undo model instantiated";
  }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onRedo()
 {
  mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
  if (model)
  {
   if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>( model ))
   {
    mitk::VerboseLimitedLinearUndo::StackDescription descriptions =
     verboseundo->GetRedoDescriptions();
    if (descriptions.size() >= 1)
    {
     MITK_INFO << "Redo " << descriptions.front().second;
    }
   }
   model->Redo();
  }
  else
  {
   MITK_ERROR << "No undo model instantiated";
  }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onImageNavigator()
 {
  // get ImageNavigatorView
  berry::IViewPart::Pointer imageNavigatorView =
   berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->FindView("org.mitk.views.imagenavigator");
  if (imageNavigatorView)
  {
   bool isImageNavigatorVisible = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->IsPartVisible(imageNavigatorView);
   if (isImageNavigatorVisible)
   {
    berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->HideView(imageNavigatorView);
    return;
   }
  }
  berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ShowView("org.mitk.views.imagenavigator");
  //berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ResetPerspective();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onEditPreferences()
 {
  QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
  _PreferencesDialog.exec();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onQuit()
 {
  berry::PlatformUI::GetWorkbench()->Close();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onResetPerspective()
 {
  berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ResetPerspective();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onClosePerspective()
 {
  berry::IWorkbenchPage::Pointer
   page =
   berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
  page->ClosePerspective(page->GetPerspective(), true, true);
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onNewWindow()
 {
  berry::PlatformUI::GetWorkbench()->OpenWorkbenchWindow(0);
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onIntro()
 {
  bool hasIntro =
   berry::PlatformUI::GetWorkbench()->GetIntroManager()->HasIntro();
  if (!hasIntro)
  {
 
   QRegExp reg("(.*)<title>(\\n)*");
   QRegExp reg2("(\\n)*</title>(.*)");
   QFile file(":/org.mitk.gui.qt.ext/index.html");
   file.open(QIODevice::ReadOnly | QIODevice::Text); // Als Text-Datei nur zum Lesen öffnen
 
   QString text = QString(file.readAll());
 
   file.close();
 
   QString title = text;
   title.replace(reg, "");
   title.replace(reg2, "");
 
   std::cout << title.toStdString() << std::endl;
 
   QMessageBox::information(NULL, title,
    text, "Close");
 
  }
  else
  {
   berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
    berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow(), false);
  }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onHelp()
 {
   ctkPluginContext* context = QmitkCommonExtPlugin::getContext();
   if (context == 0)
   {
     MITK_WARN << "Plugin context not set, unable to open context help";
     return;
   }
 
   // Check if the org.blueberry.ui.qt.help plug-in is installed and started
   QList<QSharedPointer<ctkPlugin> > plugins = context->getPlugins();
   foreach(QSharedPointer<ctkPlugin> p, plugins)
   {
     if (p->getSymbolicName() == "org.blueberry.ui.qt.help")
     {
       if (p->getState() != ctkPlugin::ACTIVE)
       {
         // try to activate the plug-in explicitly
         try
         {
           p->start(ctkPlugin::START_TRANSIENT);
         }
         catch (const ctkPluginException& pe)
         {
           MITK_ERROR << "Activating org.blueberry.ui.qt.help failed: " << pe.what();
           return;
         }
       }
     }
   }
 
   ctkServiceReference eventAdminRef = context->getServiceReference<ctkEventAdmin>();
   ctkEventAdmin* eventAdmin = 0;
   if (eventAdminRef)
   {
     eventAdmin = context->getService<ctkEventAdmin>(eventAdminRef);
   }
   if (eventAdmin == 0)
   {
     MITK_WARN << "ctkEventAdmin service not found. Unable to open context help";
   }
   else
   {
     ctkEvent ev("org/blueberry/ui/help/CONTEXTHELP_REQUESTED");
     eventAdmin->postEvent(ev);
   }
 }
 
-void QmitkExtWorkbenchWindowAdvisorHack::onHelpContents()
+void QmitkExtWorkbenchWindowAdvisorHack::onHelpOpenHelpPerspective()
 {
   berry::PlatformUI::GetWorkbench()->ShowPerspective("org.blueberry.perspectives.help",
                                                      berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow());
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onAbout()
 {
  QmitkAboutDialog* aboutDialog = new QmitkAboutDialog(QApplication::activeWindow(),NULL);
  aboutDialog->open();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::HookTitleUpdateListeners(
  berry::IWorkbenchWindowConfigurer::Pointer configurer)
 {
  // hook up the listeners to update the window title
  titlePartListener = new PartListenerForTitle(this);
  titlePerspectiveListener = new PerspectiveListenerForTitle(this);
  editorPropertyListener = new berry::PropertyChangeIntAdapter<
   QmitkExtWorkbenchWindowAdvisor>(this,
   &QmitkExtWorkbenchWindowAdvisor::PropertyChange);
 
  //    configurer.getWindow().addPageListener(new IPageListener() {
  //      public void pageActivated(IWorkbenchPage page) {
  //        updateTitle(false);
  //      }
  //
  //      public void pageClosed(IWorkbenchPage page) {
  //        updateTitle(false);
  //      }
  //
  //      public void pageOpened(IWorkbenchPage page) {
  //        // do nothing
  //      }
  //    });
 
  configurer->GetWindow()->AddPerspectiveListener(titlePerspectiveListener);
  configurer->GetWindow()->GetPartService()->AddPartListener(titlePartListener);
 }
 
 std::string QmitkExtWorkbenchWindowAdvisor::ComputeTitle()
 {
  berry::IWorkbenchWindowConfigurer::Pointer configurer =
   GetWindowConfigurer();
  berry::IWorkbenchPage::Pointer currentPage =
   configurer->GetWindow()->GetActivePage();
  berry::IEditorPart::Pointer activeEditor;
  if (currentPage)
  {
   activeEditor = lastActiveEditor.Lock();
  }
 
  std::string title;
  //TODO Product
  //    IProduct product = Platform.getProduct();
  //    if (product != null) {
  //      title = product.getName();
  //    }
  // instead of the product name, we use a custom variable for now
  title = productName;
 
  if(showMitkVersionInfo)
  {
    title += std::string(" ") + MITK_VERSION_STRING;
  }
 
  if (showVersionInfo)
  {
   // add version informatioin
   QString versions = QString(" (ITK %1.%2.%3  VTK %4.%5.%6 Qt %7 MITK %8)")
    .arg(ITK_VERSION_MAJOR).arg(ITK_VERSION_MINOR).arg(ITK_VERSION_PATCH)
    .arg(VTK_MAJOR_VERSION).arg(VTK_MINOR_VERSION).arg(VTK_BUILD_VERSION)
    .arg(QT_VERSION_STR)
    .arg(MITK_VERSION_STRING);
 
   title += versions.toStdString();
  }
 
  if (currentPage)
  {
   if (activeEditor)
   {
    lastEditorTitle = activeEditor->GetTitleToolTip();
    if (!lastEditorTitle.empty())
     title = lastEditorTitle + " - " + title;
   }
   berry::IPerspectiveDescriptor::Pointer persp =
    currentPage->GetPerspective();
   std::string label = "";
   if (persp)
   {
    label = persp->GetLabel();
   }
   berry::IAdaptable* input = currentPage->GetInput();
   if (input && input != wbAdvisor->GetDefaultPageInput())
   {
    label = currentPage->GetLabel();
   }
   if (!label.empty())
   {
    title = label + " - " + title;
   }
  }
 
  title += " (Not for use in diagnosis or treatment of patients)";
 
  return title;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::RecomputeTitle()
 {
  berry::IWorkbenchWindowConfigurer::Pointer configurer =
   GetWindowConfigurer();
  std::string oldTitle = configurer->GetTitle();
  std::string newTitle = ComputeTitle();
  if (newTitle != oldTitle)
  {
   configurer->SetTitle(newTitle);
  }
 }
 
 void QmitkExtWorkbenchWindowAdvisor::UpdateTitle(bool editorHidden)
 {
  berry::IWorkbenchWindowConfigurer::Pointer configurer =
   GetWindowConfigurer();
  berry::IWorkbenchWindow::Pointer window = configurer->GetWindow();
  berry::IEditorPart::Pointer activeEditor;
  berry::IWorkbenchPage::Pointer currentPage = window->GetActivePage();
  berry::IPerspectiveDescriptor::Pointer persp;
  berry::IAdaptable* input = 0;
 
  if (currentPage)
  {
   activeEditor = currentPage->GetActiveEditor();
   persp = currentPage->GetPerspective();
   input = currentPage->GetInput();
  }
 
  if (editorHidden)
  {
   activeEditor = 0;
  }
 
  // Nothing to do if the editor hasn't changed
  if (activeEditor == lastActiveEditor.Lock() && currentPage == lastActivePage.Lock()
   && persp == lastPerspective.Lock() && input == lastInput)
  {
   return;
  }
 
  if (!lastActiveEditor.Expired())
  {
   lastActiveEditor.Lock()->RemovePropertyListener(editorPropertyListener);
  }
 
  lastActiveEditor = activeEditor;
  lastActivePage = currentPage;
  lastPerspective = persp;
  lastInput = input;
 
  if (activeEditor)
  {
   activeEditor->AddPropertyListener(editorPropertyListener);
  }
 
  RecomputeTitle();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PropertyChange(berry::Object::Pointer /*source*/, int propId)
 {
  if (propId == berry::IWorkbenchPartConstants::PROP_TITLE)
  {
   if (!lastActiveEditor.Expired())
   {
    std::string newTitle = lastActiveEditor.Lock()->GetPartName();
    if (lastEditorTitle != newTitle)
    {
     RecomputeTitle();
    }
   }
  }
 }
 
 
 void QmitkExtWorkbenchWindowAdvisor::SetPerspectiveExcludeList(std::vector<std::string> v)
 {
   this->perspectiveExcludeList = v;
 }
 
 std::vector<std::string> QmitkExtWorkbenchWindowAdvisor::GetPerspectiveExcludeList()
 {
   return this->perspectiveExcludeList;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetViewExcludeList(std::vector<std::string> v)
 {
   this->viewExcludeList = v;
 }
 
 std::vector<std::string> QmitkExtWorkbenchWindowAdvisor::GetViewExcludeList()
 {
   return this->viewExcludeList;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PostWindowClose()
 {
   berry::IWorkbenchWindow::Pointer window = this->GetWindowConfigurer()->GetWindow();
   QMainWindow* mainWindow = static_cast<QMainWindow*> (window->GetShell()->GetControl());
 
   QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
   settings.setValue("ToolbarPosition", mainWindow->saveState());
 }
 
 QString QmitkExtWorkbenchWindowAdvisor::GetQSettingsFile() const
 {
   QFileInfo settingsInfo = QmitkCommonExtPlugin::getContext()->getDataFile(QT_SETTINGS_FILENAME);
   return settingsInfo.canonicalFilePath();
 }
diff --git a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.h b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.h
index c2c8d9ee64..75642fa30c 100644
--- a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.h
+++ b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.h
@@ -1,168 +1,168 @@
 /*===================================================================
 
 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 QMITKEXTWORKBENCHWINDOWADVISOR_H_
 #define QMITKEXTWORKBENCHWINDOWADVISOR_H_
 
 #include <berryWorkbenchWindowAdvisor.h>
 
 #include <berryIPartListener.h>
 #include <berryIEditorPart.h>
 #include <berryIWorkbenchPage.h>
 #include <berryWorkbenchAdvisor.h>
 #include <berryWorkbenchWindowAdvisor.h>
 
 #include <org_mitk_gui_qt_ext_Export.h>
 
 #include <QList>
 
 class QAction;
 class QMenu;
 
 class MITK_QT_COMMON_EXT_EXPORT QmitkExtWorkbenchWindowAdvisor : public QObject, public berry::WorkbenchWindowAdvisor
 {
   Q_OBJECT
 
 public:
 
     QmitkExtWorkbenchWindowAdvisor(berry::WorkbenchAdvisor* wbAdvisor,
         berry::IWorkbenchWindowConfigurer::Pointer configurer);
 
     berry::ActionBarAdvisor::Pointer CreateActionBarAdvisor(
         berry::IActionBarConfigurer::Pointer configurer);
 
     void* CreateEmptyWindowContents(void* parent);
 
     void PostWindowCreate();
 
     void PreWindowOpen();
 
     void PostWindowOpen();
 
     void PostWindowClose();
 
     void ShowViewToolbar(bool show);
 
     void ShowPerspectiveToolbar(bool show);
 
     void ShowVersionInfo(bool show);
 
     void ShowMitkVersionInfo(bool show);
 
     void ShowViewMenuItem(bool show);
 
     void ShowNewWindowMenuItem(bool show);
 
     void ShowClosePerspectiveMenuItem(bool show);
 
     bool GetShowClosePerspectiveMenuItem();
 
     //TODO should be removed when product support is here
     void SetProductName(const std::string& product);
     void SetWindowIcon(const std::string& wndIcon);
 
     void SetPerspectiveExcludeList(std::vector<std::string> v);
     std::vector<std::string> GetPerspectiveExcludeList();
 
     void SetViewExcludeList(std::vector<std::string> v);
     std::vector<std::string> GetViewExcludeList();
 
 protected slots:
 
     virtual void onIntro();
     virtual void onHelp();
-    virtual void onHelpContents();
+    virtual void onHelpOpenHelpPerspective();
     virtual void onAbout();
 
 private:
 
   /**
    * Hooks the listeners needed on the window
    *
    * @param configurer
    */
   void HookTitleUpdateListeners(berry::IWorkbenchWindowConfigurer::Pointer configurer);
 
   std::string ComputeTitle();
 
   void RecomputeTitle();
 
   QString GetQSettingsFile() const;
 
   /**
    * Updates the window title. Format will be: [pageInput -]
    * [currentPerspective -] [editorInput -] [workspaceLocation -] productName
    * @param editorHidden TODO
    */
   void UpdateTitle(bool editorHidden);
 
   void PropertyChange(berry::Object::Pointer /*source*/, int propId);
 
   static QString QT_SETTINGS_FILENAME;
 
   berry::IPartListener::Pointer titlePartListener;
   berry::IPerspectiveListener::Pointer titlePerspectiveListener;
   berry::IPerspectiveListener::Pointer menuPerspectiveListener;
   berry::IPartListener::Pointer imageNavigatorPartListener;
   berry::IPropertyChangeListener::Pointer editorPropertyListener;
   friend struct berry::PropertyChangeIntAdapter<QmitkExtWorkbenchWindowAdvisor>;
   friend class PartListenerForTitle;
   friend class PerspectiveListenerForTitle;
   friend class PerspectiveListenerForMenu;
   friend class PartListenerForImageNavigator;
 
   berry::IEditorPart::WeakPtr lastActiveEditor;
   berry::IPerspectiveDescriptor::WeakPtr lastPerspective;
   berry::IWorkbenchPage::WeakPtr lastActivePage;
   std::string lastEditorTitle;
   berry::IAdaptable* lastInput;
 
   berry::WorkbenchAdvisor* wbAdvisor;
   bool showViewToolbar;
   bool showPerspectiveToolbar;
   bool showVersionInfo;
   bool showMitkVersionInfo;
   bool showViewMenuItem;
   bool showNewWindowMenuItem;
   bool showClosePerspectiveMenuItem;
   std::string productName;
   std::string windowIcon;
 
   // enables DnD on the editor area
   berry::IDropTargetListener::Pointer dropTargetListener;
 
   // stringlist for excluding perspectives from the perspective menu entry (e.g. Welcome Perspective)
   std::vector<std::string> perspectiveExcludeList;
 
   // stringlist for excluding views from the menu entry
   std::vector<std::string> viewExcludeList;
 
   // maps perspective ids to QAction objects
   std::map<std::string, QAction*> mapPerspIdToAction;
 
   // actions which will be enabled/disabled depending on the application state
   QList<QAction*> viewActions;
   QAction* fileSaveProjectAction;
   QAction* closeProjectAction;
   QAction* undoAction;
   QAction* redoAction;
   QAction* imageNavigatorAction;
   QAction* resetPerspAction;
   QAction* closePerspAction;
   QAction* openDicomEditorAction;
 };
 
 #endif /*QMITKEXTWORKBENCHWINDOWADVISOR_H_*/
diff --git a/Plugins/org.mitk.gui.qt.ext/src/internal/QmitkExtWorkbenchWindowAdvisorHack.h b/Plugins/org.mitk.gui.qt.ext/src/internal/QmitkExtWorkbenchWindowAdvisorHack.h
index c594cc84bd..e81302d99e 100644
--- a/Plugins/org.mitk.gui.qt.ext/src/internal/QmitkExtWorkbenchWindowAdvisorHack.h
+++ b/Plugins/org.mitk.gui.qt.ext/src/internal/QmitkExtWorkbenchWindowAdvisorHack.h
@@ -1,58 +1,58 @@
 /*===================================================================
 
 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 <QObject>
 
 class ctkPluginContext;
 class QmitkPreferencesDialog;
 
 class QmitkExtWorkbenchWindowAdvisorHack : public QObject
 {
   Q_OBJECT
 
   public slots:
 
     void onUndo();
     void onRedo();
     void onImageNavigator();
     void onEditPreferences();
     void onQuit();
 
     void onResetPerspective();
     void onClosePerspective();
     void onNewWindow();
     void onIntro();
     
     /**
      * @brief This slot is called if the user klicks the menu item "help->context help" or presses F1.
      * The help page is shown in a workbench editor.
      */
     void onHelp();
 
-    void onHelpContents();
+    void onHelpOpenHelpPerspective();
     
     /**
      * @brief This slot is called if the user clicks in help menu the about button
      */
     void onAbout();
 
   public:
 
     QmitkExtWorkbenchWindowAdvisorHack();
     ~QmitkExtWorkbenchWindowAdvisorHack();
 
     static QmitkExtWorkbenchWindowAdvisorHack* undohack;
 };
diff --git a/Plugins/org.mitk.gui.qt.extapplication/CMakeLists.txt b/Plugins/org.mitk.gui.qt.extapplication/CMakeLists.txt
index 64a92f7cab..50c9d87cc7 100644
--- a/Plugins/org.mitk.gui.qt.extapplication/CMakeLists.txt
+++ b/Plugins/org.mitk.gui.qt.extapplication/CMakeLists.txt
@@ -1,6 +1,13 @@
+set(QT_USE_QTWEBKIT TRUE)
+include(${QT_USE_FILE})
+
+if(QT_QTWEBKIT_FOUND)
+  add_definitions(-DQT_WEBKIT)
+endif(QT_QTWEBKIT_FOUND)
+
 project(org_mitk_gui_qt_extapplication)
 
 MACRO_CREATE_MITK_CTK_PLUGIN(
   EXPORT_DIRECTIVE MITK_QT_EXTAPP
   EXPORTED_INCLUDE_SUFFIXES src
 )
diff --git a/Plugins/org.mitk.gui.qt.extapplication/documentation/UserManual/QmitkExtapplicationUserManual.dox b/Plugins/org.mitk.gui.qt.extapplication/documentation/UserManual/QmitkExtapplicationUserManual.dox
deleted file mode 100644
index 9a55ff4361..0000000000
--- a/Plugins/org.mitk.gui.qt.extapplication/documentation/UserManual/QmitkExtapplicationUserManual.dox
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
-\page org_extapplication Using The Ext Application
-
-\section QMitkExtApplicationManualOverview  What is the Ext App
-
-The MITK Ext Application is used by developers. As such the kind and number of views it contains is highly variable and dependent on the specific build. Typically it contains no special perspectives and whatever views the developer deemed desirable. Be aware, that it may contain views which are work in progress and may behave erratically.
-
-If you have been given such an executable by someone, please refer to the appropriate section of the online documentation for up to date usage information on any module. 
-
-<a href="http://docs.mitk.org/nightly-qt4/ModuleListPage.html">Nightly online documentation</a>
-
-
-If you are using a nightly installer, the Ext Application will contain nearly all views available in MITK and as such most likely will seem confusing. Again the list of modules might be a good starting point if you want to have a rough idea of what could be of interest to you. 
-
-For a basic guide to MITK see \ref MITKUserManualPage .
-
-*/
diff --git a/Plugins/org.mitk.gui.qt.extapplication/documentation/UserManual/QmitkMITKWorkbenchUserManual.dox b/Plugins/org.mitk.gui.qt.extapplication/documentation/UserManual/QmitkMITKWorkbenchUserManual.dox
new file mode 100644
index 0000000000..1854351290
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.extapplication/documentation/UserManual/QmitkMITKWorkbenchUserManual.dox
@@ -0,0 +1,17 @@
+/**
+\page org_mitkworkbench Using The MITK Workbench
+
+\section QMitkMitkWorkbenchManualOverview  What is the MITK Workbench
+
+The MITK Workbench is used by developers. As such the kind and number of views it contains is highly variable and dependent on the specific build. Typically it contains no special perspectives and whatever views the developer deemed desirable. Be aware, that it may contain views which are work in progress and may behave erratically.
+
+If you have been given such an executable by someone, please refer to the appropriate section of the online documentation for up to date usage information on any module. 
+
+<a href="http://docs.mitk.org/nightly-qt4/PluginListPage.html">Nightly online documentation</a>
+
+
+If you are using a nightly installer, the MITK Workbench will contain nearly all views available in MITK and as such most likely will seem confusing. Again the list of modules might be a good starting point if you want to have a rough idea of what could be of interest to you. 
+
+For a basic guide to MITK see \ref MITKUserManualPage .
+
+*/
diff --git a/Plugins/org.mitk.gui.qt.extapplication/documentation/doxygen/modules.dox b/Plugins/org.mitk.gui.qt.extapplication/documentation/doxygen/modules.dox
index 3002d63e30..4172a9d45b 100644
--- a/Plugins/org.mitk.gui.qt.extapplication/documentation/doxygen/modules.dox
+++ b/Plugins/org.mitk.gui.qt.extapplication/documentation/doxygen/modules.dox
@@ -1,16 +1,16 @@
 /**
-  \defgroup org_mitk_gui_qt_extapplication org.mitk.gui.qt.extapplication
+  \defgroup org_mitk_gui_qt_mitkworkbench org.mitk.gui.qt.mitkworkbench
   \ingroup MITKPlugins
 
   \brief This plug-in is responsible for initializing the MITK Workbench.
   
 */
 
 /**
-  \defgroup org_mitk_gui_qt_extapplication_internal Internal
-  \ingroup org_mitk_gui_qt_extapplication
+  \defgroup org_mitk_gui_qt_mitkworkbench_internal Internal
+  \ingroup org_mitk_gui_qt_mitkworkbench
 
-  \brief This subcategory includes the internal classes of the org.mitk.gui.qt.extapplication plugin. Other
+  \brief This subcategory includes the internal classes of the org.mitk.gui.qt.mitkworkbench plugin. Other
   plugins must not rely on these classes. They contain implementation details and their interface
   may change at any time. We mean it.
 */
diff --git a/Plugins/org.mitk.gui.qt.extapplication/files.cmake b/Plugins/org.mitk.gui.qt.extapplication/files.cmake
index 77328988e7..e7bcaae435 100644
--- a/Plugins/org.mitk.gui.qt.extapplication/files.cmake
+++ b/Plugins/org.mitk.gui.qt.extapplication/files.cmake
@@ -1,40 +1,49 @@
 set(SRC_CPP_FILES
 )
 
 set(INTERNAL_CPP_FILES
   QmitkExtApplication.cpp
   QmitkExtApplicationPlugin.cpp
   QmitkExtAppWorkbenchAdvisor.cpp
-  QmitkExtDefaultPerspective.cpp
+  QmitkMitkWorkbenchIntroPart.cpp
+  perspectives/QmitkEditorPerspective.cpp
+  perspectives/QmitkExtDefaultPerspective.cpp
 )
 
 set(MOC_H_FILES
   src/internal/QmitkExtApplication.h
   src/internal/QmitkExtApplicationPlugin.h
-  src/internal/QmitkExtDefaultPerspective.h
+  src/internal/QmitkMitkWorkbenchIntroPart.h
+  src/internal/perspectives/QmitkEditorPerspective.h
+  src/internal/perspectives/QmitkExtDefaultPerspective.h
+)
+
+set(UI_FILES
+  src/internal/perspectives/QmitkWelcomeScreenViewControls.ui
 )
 
 set(CACHED_RESOURCE_FILES
 # list of resource files which can be used by the plug-in
 # system without loading the plug-ins shared library,
 # for example the icon used in the menu and tabs for the
 # plug-in views in the workbench
   plugin.xml
   resources/icon_research.xpm
 )
 
 set(QRC_FILES
 # uncomment the following line if you want to use Qt resources
 #  resources/QmitkExtApplication.qrc
+resources/welcome/QmitkWelcomeScreenView.qrc
 )
 
 set(CPP_FILES )
 
 foreach(file ${SRC_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 foreach(file ${INTERNAL_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
 
diff --git a/Plugins/org.mitk.gui.qt.extapplication/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.extapplication/manifest_headers.cmake
index 0462ac1ab9..b951506aa9 100644
--- a/Plugins/org.mitk.gui.qt.extapplication/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.extapplication/manifest_headers.cmake
@@ -1,5 +1,5 @@
-set(Plugin-Name "MITK Ext Application")
+set(Plugin-Name "MITK Workbench")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "DKFZ, Medical and Biological Informatics")
 set(Plugin-ContactAddress "http://www.mitk.org")
 set(Require-Plugin org.mitk.gui.qt.ext)
diff --git a/Plugins/org.mitk.gui.qt.extapplication/plugin.xml b/Plugins/org.mitk.gui.qt.extapplication/plugin.xml
index a9777eeb61..4cb8e70b51 100644
--- a/Plugins/org.mitk.gui.qt.extapplication/plugin.xml
+++ b/Plugins/org.mitk.gui.qt.extapplication/plugin.xml
@@ -1,18 +1,33 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.0"?>
 <plugin>
   <extension point="org.blueberry.osgi.applications">
     <application id="org.mitk.qt.extapplication">
       <run class="QmitkExtApplication"/>
     </application>
   </extension>
   
+  <extension point="org.blueberry.ui.intro">
+    <intro id="org.mitk.qt.extapplicationintro"
+      class="QmitkMitkWorkbenchIntroPart"
+      role="editor"/>
+    <introProductBinding
+      productId=""
+      introId="org.mitk.qt.extapplicationintro"/>
+  </extension>
+  
   <extension point="org.blueberry.ui.perspectives">
     <perspective
       id="org.mitk.extapp.defaultperspective"
       name="Research"
       class="QmitkExtDefaultPerspective"
-	  icon="resources/icon_research.xpm">
+      icon="resources/icon_research.xpm">
+    </perspective>
+    <perspective 
+      id="org.mitk.mitkworkbench.perspectives.editor"
+      name="Viewer"
+      class="QmitkEditorPerspective"
+      icon="resources/perspectives/icon_home.png">
     </perspective>
   </extension>
 </plugin>
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/QmitkWelcomeScreenView.qrc b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/QmitkWelcomeScreenView.qrc
new file mode 100644
index 0000000000..c24d388671
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/QmitkWelcomeScreenView.qrc
@@ -0,0 +1,12 @@
+<RCC>
+    <qresource prefix="/org.mitk.gui.qt.welcomescreen">
+        <file>style.css</file>
+        <file>function.js</file>
+        <file>pics/background.jpg</file>
+        <file>pics/popup_bttn_close.png</file>
+        <file>pics/experimental.png</file>
+        <file>pics/button_mitka.png</file>
+        <file>pics/button_mitk.png</file>
+        <file>mitkworkbenchwelcomeview.html</file>
+    </qresource>
+</RCC>
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/function.js b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/function.js
new file mode 100644
index 0000000000..504df84362
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/function.js
@@ -0,0 +1,259 @@
+// If you want to create a new button you have to add some data (strings) to the following five arrays.
+// Make sure that you add your data at the same position in each array.
+// The buttons will be generated in order to the array's index. e.g. data at array's index '0' will generate the first button.
+
+// enter the name of your module here
+var moduleNames = new Array("MITK Website");
+
+// add the MITK-link to your module
+var moduleLinks = new Array("http://www.mitk.org/");
+
+// add the filename of your icon for the module. Place the picture in subdirectory "pics".
+// The picture's width should be 136 pixel; the height 123 pixel.
+var picFilenames = new Array("button_mitk.png");
+
+// if you want to create an animated icon, add the name of your animated gif (placed in subdirectory "pics"). Otherwise enter an empty string "".
+// The animation's width should be 136 pixel; the height 123 pixel.
+var aniFilenames = new Array("button_mitka.png");
+
+// if your module is not stable, you can mark it as experimental.
+// just set true for experimental or false for stable.
+var experimental = new Array(false);
+
+// add the description for your module. The description is displayed in a PopUp-window.
+var moduleDescriptions = new Array("");
+
+var bttns = new Array();
+
+var d = document, da = d.all;
+
+// holds id of current mouseover-HTML-element
+var currentTarget;
+
+// get the id of current mouseover-HTML-element
+d.onmouseover = function(o){
+  var e = da ? event.srcElement : o.target;
+  currentTarget = e.id;
+}
+
+
+// build-function called by onload-event in HTML-document
+function createButtons(){
+
+  for (i=0; i < moduleNames.length; i++){
+    bttns[i] = new Button(moduleNames[i],moduleLinks[i], picFilenames[i], aniFilenames[i],moduleDescriptions[i]);
+    bttns[i].createButton();
+  }
+
+  for (i=0; i < moduleNames.length; i++){
+
+    if(experimental[i]){
+      setExperimental(i);
+    }
+  }
+
+  createClearFloat();
+}
+
+// Class Button
+function Button(moduleName, moduleLink, picFilename, aniFilename, moduleDescr){
+
+  // Properties
+  this.bttnID = "bttn" + moduleName;
+  this.modName = moduleName;
+  this.modLink = moduleLink;
+  this.picPath = "pics/" + picFilename;
+  this.aniPath = "pics/" + aniFilename;
+  this.modDescr = moduleDescr;
+
+  // Methods
+  this.createButton = function(){
+
+    // get DIV-wrapper for Button and append it to HTML-document
+    bttnWrapper = this.createWrapper();
+    document.getElementById("bttnField").appendChild(bttnWrapper);
+
+    // get link-element for picture and append it to DIV-wrapper
+    bttnPicLink = this.createPicLink();
+    bttnWrapper.appendChild(bttnPicLink);
+
+    // set HTML attributes for button-element
+    bttn = document.createElement("img");
+    bttn.src = this.picPath;
+    bttn.id = this.bttnID;
+    bttn.className = "modBttn";
+    bttn.height = 123;
+    bttn.width = 136;
+    bttn.onmouseover = function(){startAni(this.id);};
+    bttn.onmouseout = function(){stopAni(this.id);};
+
+    // append button to link-element
+    bttnPicLink.appendChild(bttn);
+
+    // create text-link and add it to DIV-wrapper
+    bttnTxtLink = document.createElement("a");
+    bttnTxtLink.href = this.modLink;
+    bttnTxtLink.className = "txtLink";
+    bttnTxtLink.appendChild(document.createTextNode(this.modName));
+    bttnWrapper.appendChild(bttnTxtLink);
+
+    // create pop-up link for module description
+    if (this.modDescr.length != 0) {
+      bttnPopUpLink = document.createElement("a");
+      modName = this.modName;
+      modDescr = this.modDescr;
+      bttnPopUpLink.onclick = function(){showPopUpWindow();};
+      bttnPopUpLink.className = "popUpLink";
+      bttnPopUpLink.id = "popup" + this.modName;
+      bttnPopUpLink.appendChild(document.createTextNode("more info >>"));
+      bttnWrapper.appendChild(document.createElement("br"));
+      bttnWrapper.appendChild(bttnPopUpLink);
+    }
+
+    return bttn;
+  }
+
+  this.createWrapper = function(){
+    bttnWrapper = document.createElement("div");
+    bttnWrapper.id = "wrapper" + this.modName;
+    bttnWrapper.className = "bttnWrap";
+
+    return bttnWrapper;
+  }
+
+  this.createPicLink = function(){
+    picLink = document.createElement("a");
+    picLink.href = this.modLink;
+    picLink.id = "link" + this.modName;
+
+    return picLink;
+  }
+
+}
+
+
+function showPopUpWindow(){
+
+  // modules position in array?
+  modulePos = getPos(currentTarget,"popup");
+
+  // get reference to anchor-element in HTML-document
+  popUpAnchor = document.getElementById("popupAnchor");
+
+  // check if a popUp is open
+  if(popUpAnchor.hasChildNodes()){
+    // if a popUp is open, remove it!
+    popUpAnchor.removeChild(document.getElementById("popup"));
+  }
+
+  // create new container for popUp
+  container = document.createElement("div");
+  container.id = "popup";
+  container.align = "right";
+
+  // append popUp-container to HTML-document
+  popUpAnchor.appendChild(container);
+
+  // create close-button and append it to popUp-container
+  bttnClose = document.createElement("img");
+  bttnClose.src = "pics/popup_bttn_close.png";
+  bttnClose.id = "bttnClose";
+  bttnClose.onclick = function(){closeInfoWindow();};
+  container.appendChild(bttnClose);
+
+  // create container for content-elements
+  contHeadline = document.createElement("div");
+  contHeadline.id = "contHeadline";
+  contDescription = document.createElement("div");
+  contDescription.id = "contDescription";
+  contModLink = document.createElement("div");
+  contModLink.id = "contModLink";
+
+  // append content-container to popUp-container
+  container.appendChild(contHeadline);
+  container.appendChild(contDescription);
+  container.appendChild(contModLink);
+
+  // create text-elements with content
+  headline = document.createTextNode(moduleNames[modulePos] + " ");
+  description = document.createTextNode(moduleDescriptions[modulePos]);
+  moduleLink = document.createElement("a");
+  moduleLink.href = moduleLinks[modulePos] ;
+  moduleLink.className = 'moduleLink';
+  moduleLinkTxt = document.createTextNode("Click here to open '" + moduleNames[modulePos].toLowerCase() + "'");
+  moduleLink.appendChild(moduleLinkTxt);
+
+  // append text-elements to their container
+  contHeadline.appendChild(headline);
+  contDescription.appendChild(description);
+  contModLink.appendChild(moduleLink);
+}
+
+function getPos(id,prefix){
+
+  if(prefix == "popup"){
+    targetID = id.slice(5);
+  }else{
+    if(prefix == "bttn"){
+      targetID = id.slice(4);
+    }
+  }
+
+  for(i=0; i < moduleNames.length; i++ ){
+    if(moduleNames[i] == targetID){
+      return i;
+    }
+  }
+}
+
+function setExperimental(modPos){
+  linkID = "link" + moduleNames[modPos];
+
+  expPic = document.createElement("img");
+  expPic.src = "pics/experimental.png";
+  expPic.className = "expPic";
+  //alert(bttns[modPos].bttnID);
+  expPic.onmouseover = function(){startAni(bttns[modPos].bttnID);changeToHover(bttns[modPos].bttnID);};
+  expPic.onmouseout = function(){stopAni(bttns[modPos].bttnID);changeToNormal(bttns[modPos].bttnID);};
+
+  document.getElementById(linkID).appendChild(expPic);
+}
+
+function changeToHover(targetId){
+  bttn = document.getElementById(targetId);
+  bttn.className = "modBttnHover";
+}
+
+function changeToNormal(targetId){
+  bttn = document.getElementById(targetId);
+  bttn.className = "modBttn";
+}
+
+// function to close PopUp-window
+function closeInfoWindow(){
+  popUpAnchor = document.getElementById("popupAnchor");
+  popUpAnchor.removeChild(document.getElementById("popup"));
+}
+
+function createClearFloat(){
+  cf = document.createElement("div");
+  cf.className = "clearfloat";
+  document.getElementById("bttnField").appendChild(cf);
+}
+
+startAni = function(targetId){
+  modulePos = getPos(targetId,"bttn");
+
+  if(aniFilenames[modulePos] != ''){
+    bttn = document.getElementById(targetId);
+    bttn.src = "pics/" + aniFilenames[modulePos];
+  }
+}
+
+stopAni = function(targetId){
+  modulePos = getPos(targetId,"bttn");
+
+  bttn = document.getElementById(targetId);
+  bttn.src = "pics/" + picFilenames[modulePos];
+}
+
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/mitkworkbenchwelcomeview.html b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/mitkworkbenchwelcomeview.html
new file mode 100644
index 0000000000..1db8a05d1d
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/mitkworkbenchwelcomeview.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>MITK Workbench</title>
+    <link rel="stylesheet" type="text/css" href="style.css">
+  <script language="javascript" src="function.js"></script>
+  </head>
+
+  <body onload="createButtons()" oncontextmenu="return false;">
+
+    <div id="screen">
+
+      <!-- Welcome headline and introduction -->
+      <div id="welcome">
+
+        <h1>Welcome to MITK Workbench!</h1>
+
+        <!-- PopUps with module description generated by js are placed in here -->
+        <div id="popupAnchor"></div>
+
+        <div id="welcomeText">
+          This application was developed at the German Cancer Research Center (DKFZ). It is based on the well established, free open source Medical Imaging Interaction Toolkit (MITK). Check the help pages or visit our website for additional information:
+        </div>
+
+      </div>
+
+      <!-- area for module buttons -->
+      <div id="bttnField">
+        <!-- Buttons created by js-fucntion are placed in here -->
+      </div>
+
+    </div>
+  </body>
+</html>
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/background.jpg b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/background.jpg
new file mode 100644
index 0000000000..c93f36df92
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/background.jpg differ
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/button_mitk.png b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/button_mitk.png
new file mode 100644
index 0000000000..821e041d36
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/button_mitk.png differ
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/button_mitka.png b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/button_mitka.png
new file mode 100644
index 0000000000..baf4f14a46
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/button_mitka.png differ
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/experimental.png b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/experimental.png
new file mode 100644
index 0000000000..b05093ea2e
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/experimental.png differ
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bg.png b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bg.png
new file mode 100644
index 0000000000..9fef73a742
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bg.png differ
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bg_bottom.png b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bg_bottom.png
new file mode 100644
index 0000000000..f181fb97e2
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bg_bottom.png differ
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bg_middle.png b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bg_middle.png
new file mode 100644
index 0000000000..fd477da298
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bg_middle.png differ
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bg_top.png b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bg_top.png
new file mode 100644
index 0000000000..99424cbbb7
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bg_top.png differ
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bttn_close.png b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bttn_close.png
new file mode 100644
index 0000000000..279e340beb
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/popup_bttn_close.png differ
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/shadow.png b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/shadow.png
new file mode 100644
index 0000000000..83eda7b89e
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/pics/shadow.png differ
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/style.css b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/style.css
new file mode 100644
index 0000000000..55dc94a56b
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/style.css
@@ -0,0 +1,174 @@
+@charset "utf-8";
+
+body{
+  margin:0px 0px;
+  padding: 0px 0px;
+}
+
+h1{
+  margin:0px 0px;
+  padding: 0px 0px;
+  font-family:"Times New Roman", Times, serif;  
+  color:#333;
+}
+
+img{border:none;}
+
+#screen{
+  width:100%;
+  min-height:1060px;
+  height:100%;
+  padding-top:15px;
+  background-color:#888888;
+  background-image:url(pics/background.jpg);
+  background-repeat:repeat-x;
+}
+
+#welcome{
+  min-width:150px;
+  max-width:690px;
+  margin: 0 auto;
+  padding-left:5px;
+  font-family:"Times New Roman", Times, serif;
+  color:#333;
+}
+
+#welcomeText{
+  margin-top:15px;
+  margin-bottom:15px;
+  z-index:1;
+}
+
+#bttnField{
+  min-width:150px;
+  max-width:690px;
+  margin: 0 auto;
+  padding-left:5px;
+}
+
+.bttnWrap{
+  position:relative;
+  float:left;
+  width:140px;
+  height:190px;
+  margin-right:32px;
+  margin-top:5px;
+  z-index:2;
+}
+
+.modBttn{
+  margin-bottom:8px;
+  border: solid 2px #000;
+ -webkit-box-shadow: 5px 5px 6px rgba(0,0,0,0.6);
+}
+
+.modBttn:hover{
+  border: solid 2px #FFF;
+  cursor:pointer;
+ -webkit-box-shadow: none;
+}
+
+.modBttnHover{
+  margin-bottom:8px;
+  border: solid 2px #FFF;
+  cursor:pointer;
+ -webkit-box-shadow: none;
+}
+
+.txtLink{
+  font-family:"Times New Roman", Times, serif;
+  font-size:16px;
+  font-weight:bold;
+  text-decoration:none;
+  cursor:pointer;
+  color:#333;
+}
+
+.txtLink:hover{
+  text-decoration:underline;
+}
+
+.popUpLink{
+  font-family:"Times New Roman", Times, serif;
+  font-size:14px;
+  font-weight:normal;
+  line-height:16px;
+  color:#333;
+}
+
+.popUpLink:hover{
+  text-decoration:underline;
+  cursor:pointer;
+}
+
+#popup{
+  position:fixed;
+  max-width:690px;
+  min-width:150px;
+  background-color:#000000;
+  opacity: 0.8;
+  -webkit-border-radius: 1em;
+  z-index:3;
+  font-family:Arial, Helvetica, sans-serif;  
+  color:#FFF;
+}
+
+#bttnClose{
+  position:relative;
+  right:10px;
+  top:10px;
+  cursor:pointer;
+}
+
+#contHeadline{
+  max-width:690px;
+  min-width:150px;
+  margin-left:10px;
+  margin-right:10px;
+  font-weight:bold;
+  font-size:14px;
+  text-align:left;
+}
+
+#contDescription{
+  max-width:690px;
+  min-width:150px;
+  margin-top:15px;
+  margin-bottom:15px;
+  margin-left:10px;
+  margin-right:10px;
+  line-height:21px;
+  font-family:Arial, Helvetica, sans-serif;  
+  font-weight:normal;
+  font-size:14px;
+  text-align:left;
+}
+
+#contModLink{
+  max-width:690px;
+  min-width:150px;
+  height:50px;
+  margin-left:10px;
+  margin-right:10px;
+  text-align:left;
+}
+
+.moduleLink{
+  font-family:Arial, Helvetica, sans-serif;  
+  color:#FFF;
+}
+
+.expPic{
+  margin-top:-126px;  
+}
+
+.clearfloat{clear:both;}
+
+
+
+
+
+
+
+
+
diff --git a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtApplicationPlugin.cpp b/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtApplicationPlugin.cpp
index 47786d687d..c2411123d7 100644
--- a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtApplicationPlugin.cpp
+++ b/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtApplicationPlugin.cpp
@@ -1,84 +1,88 @@
 /*===================================================================
 
 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 "QmitkExtApplicationPlugin.h"
-#include "QmitkExtDefaultPerspective.h"
+#include "perspectives/QmitkExtDefaultPerspective.h"
+#include "perspectives/QmitkEditorPerspective.h"
+#include "QmitkMitkWorkbenchIntroPart.h"
 #include "QmitkExtApplication.h"
 
 #include <mitkVersion.h>
 #include <mitkLogMacros.h>
 
 #include <service/cm/ctkConfigurationAdmin.h>
 #include <service/cm/ctkConfiguration.h>
 
 #include <QFileInfo>
 #include <QDateTime>
 #include <QtPlugin>
 
 QmitkExtApplicationPlugin* QmitkExtApplicationPlugin::inst = 0;
 
 QmitkExtApplicationPlugin::QmitkExtApplicationPlugin()
 {
   inst = this;
 }
 
 QmitkExtApplicationPlugin::~QmitkExtApplicationPlugin()
 {
 }
 
 QmitkExtApplicationPlugin* QmitkExtApplicationPlugin::GetDefault()
 {
   return inst;
 }
 
 void QmitkExtApplicationPlugin::start(ctkPluginContext* context)
 {
   berry::AbstractUICTKPlugin::start(context);
   
   this->context = context;
   
   BERRY_REGISTER_EXTENSION_CLASS(QmitkExtDefaultPerspective, context);
+  BERRY_REGISTER_EXTENSION_CLASS(QmitkEditorPerspective, context);
+  BERRY_REGISTER_EXTENSION_CLASS(QmitkMitkWorkbenchIntroPart, context);
   BERRY_REGISTER_EXTENSION_CLASS(QmitkExtApplication, context);
 
 
   ctkServiceReference cmRef = context->getServiceReference<ctkConfigurationAdmin>();
   ctkConfigurationAdmin* configAdmin = 0;
   if (cmRef)
   {
     configAdmin = context->getService<ctkConfigurationAdmin>(cmRef);
   }
 
   // Use the CTK Configuration Admin service to configure the BlueBerry help system
   if (configAdmin)
   {
     ctkConfigurationPtr conf = configAdmin->getConfiguration("org.blueberry.services.help", QString());
     ctkDictionary helpProps;
     helpProps.insert("homePage", "qthelp://org.mitk.gui.qt.extapplication/bundle/index.html");
     conf->update(helpProps);
     context->ungetService(cmRef);
   }
   else
   {
     MITK_WARN << "Configuration Admin service unavailable, cannot set home page url.";
   }
 }
 
 ctkPluginContext* QmitkExtApplicationPlugin::GetPluginContext() const
 {
   return context;
 }
 
 Q_EXPORT_PLUGIN2(org_mitk_gui_qt_extapplication, QmitkExtApplicationPlugin)
diff --git a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkMitkWorkbenchIntroPart.cpp b/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkMitkWorkbenchIntroPart.cpp
new file mode 100644
index 0000000000..8e90bca52e
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkMitkWorkbenchIntroPart.cpp
@@ -0,0 +1,203 @@
+/*===================================================================
+
+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 "QmitkMitkWorkbenchIntroPart.h"
+
+#include <berryIWorkbenchWindow.h>
+#include <berryIWorkbench.h>
+#include <berryIWorkbenchPage.h>
+#include <berryIPerspectiveRegistry.h>
+#include <berryWorkbenchPreferenceConstants.h>
+#include <berryIPreferences.h>
+
+#include <berryIEditorReference.h>
+#include <berryIEditorInput.h>
+
+#include <mitkIDataStorageService.h>
+#include <mitkDataStorageEditorInput.h>
+
+#include <mitkLogMacros.h>
+
+#include <QLabel>
+#include <QMessageBox>
+#include <QtCore/qconfig.h>
+#ifdef QT_WEBKIT
+#include <QWebView>
+#include <QWebPage>
+#endif
+#include <QString>
+#include <QStringList>
+#include <QRegExp>
+#include <QChar>
+#include <QByteArray>
+#include <QDesktopServices>
+
+#include "QmitkExtApplicationPlugin.h"
+#include "mitkDataStorageEditorInput.h"
+#include <string>
+
+QmitkMitkWorkbenchIntroPart::QmitkMitkWorkbenchIntroPart()
+  : m_Controls(NULL)
+{
+  berry::IPreferences::Pointer workbenchPrefs = QmitkExtApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
+  workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, true);
+  workbenchPrefs->Flush();
+}
+
+QmitkMitkWorkbenchIntroPart::~QmitkMitkWorkbenchIntroPart()
+{
+  // if the workbench is not closing (that means, welcome screen was closed explicitly), set "Show_intro" false
+  if (!this->GetIntroSite()->GetPage()->GetWorkbenchWindow()->GetWorkbench()->IsClosing())
+  {
+    berry::IPreferences::Pointer workbenchPrefs = QmitkExtApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
+    workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, false);
+    workbenchPrefs->Flush();
+  }
+  else
+  {
+    berry::IPreferences::Pointer workbenchPrefs = QmitkExtApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
+    workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, true);
+    workbenchPrefs->Flush();
+  }
+
+  // if workbench is not closing (Just welcome screen closing), open last used perspective
+  if (this->GetIntroSite()->GetPage()->GetPerspective()->GetId()
+    == "org.mitk.mitkworkbench.perspectives.editor" && !this->GetIntroSite()->GetPage()->GetWorkbenchWindow()->GetWorkbench()->IsClosing())
+    {
+    berry::IPerspectiveDescriptor::Pointer perspective = this->GetIntroSite()->GetWorkbenchWindow()->GetWorkbench()->GetPerspectiveRegistry()->FindPerspectiveWithId("org.mitk.mitkworkbench.perspectives.editor");
+    if (perspective)
+    {
+      this->GetIntroSite()->GetPage()->SetPerspective(perspective);
+    }
+  }
+
+}
+
+
+void QmitkMitkWorkbenchIntroPart::CreateQtPartControl(QWidget* parent)
+{
+  if (!m_Controls)
+  {
+    // create GUI widgets
+    m_Controls = new Ui::QmitkWelcomeScreenViewControls;
+    m_Controls->setupUi(parent);
+#ifdef QT_WEBKIT
+
+    // create a QWebView as well as a QWebPage and QWebFrame within the QWebview
+    m_view = new QWebView(parent);
+    m_view->page()->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
+
+    QUrl urlQtResource(QString("qrc:/org.mitk.gui.qt.welcomescreen/mitkworkbenchwelcomeview.html"),  QUrl::TolerantMode );
+    m_view->load( urlQtResource );
+
+    // adds the webview as a widget
+    parent->layout()->addWidget(m_view);
+    this->CreateConnections();
+#else
+    parent->layout()->addWidget(new QLabel("<h1><center>Please install Qt with the WebKit option to see cool pictures!</center></h1>"));
+#endif
+  }
+}
+
+#ifdef QT_WEBKIT
+void QmitkMitkWorkbenchIntroPart::CreateConnections()
+{
+  if ( m_Controls )
+  {
+    connect( (QObject*)(m_view->page()), SIGNAL(linkClicked(const QUrl& )), this, SLOT(DelegateMeTo(const QUrl& )) );
+  }
+}
+
+
+void QmitkMitkWorkbenchIntroPart::DelegateMeTo(const QUrl& showMeNext)
+{
+  QString scheme          = showMeNext.scheme();
+  QByteArray urlHostname  = showMeNext.encodedHost();
+  QByteArray urlPath      = showMeNext.encodedPath();
+  QByteArray dataset      = showMeNext.encodedQueryItemValue("dataset");
+  QByteArray clear        = showMeNext.encodedQueryItemValue("clear");
+
+  if (scheme.isEmpty()) MITK_INFO << " empty scheme of the to be delegated link" ;
+
+  // if the scheme is set to mitk, it is to be tested which action should be applied
+  if (scheme.contains(QString("mitk")) )
+  {
+    if(urlPath.isEmpty() ) MITK_INFO << " mitk path is empty " ;
+
+    // searching for the perspective keyword within the host name
+    if(urlHostname.contains(QByteArray("perspectives")) )
+    {
+      // the simplified method removes every whitespace
+      // ( whitespace means any character for which the standard C++ isspace() method returns true)
+      urlPath = urlPath.simplified();
+      QString tmpPerspectiveId(urlPath.data());
+      tmpPerspectiveId.replace(QString("/"), QString("") );
+      std::string perspectiveId  = tmpPerspectiveId.toStdString();
+
+      // is working fine as long as the perspective id is valid, if not the application crashes
+      GetIntroSite()->GetWorkbenchWindow()->GetWorkbench()->ShowPerspective(perspectiveId, GetIntroSite()->GetWorkbenchWindow() );
+
+      // search the Workbench for opened StdMultiWidgets to ensure the focus does not stay on the welcome screen and is switched to
+      // an StdMultiWidget if one available
+      mitk::IDataStorageService::Pointer service =
+          berry::Platform::GetServiceRegistry().GetServiceById<mitk::IDataStorageService>(mitk::IDataStorageService::ID);
+      berry::IEditorInput::Pointer editorInput;
+      editorInput = new mitk::DataStorageEditorInput( service->GetActiveDataStorage() );
+
+      // the solution is not clean, but the dependency to the StdMultiWidget was removed in order to fix a crash problem
+      // as described in Bug #11715
+      // This is the correct way : use the static string ID variable
+      // berry::IEditorPart::Pointer editor = GetIntroSite()->GetPage()->FindEditors( editorInput, QmitkStdMultiWidgetEditor::EDITOR_ID );
+      // QuickFix: we use the same string for an local variable
+      const std::string stdEditorID = "org.mitk.editors.stdmultiwidget";
+
+      // search for opened StdMultiWidgetEditors
+      std::vector<berry::IEditorReference::Pointer> editorList = GetIntroSite()->GetPage()->FindEditors( editorInput, stdEditorID, 1 );
+
+      // if an StdMultiWidgetEditor open was found, give focus to it
+      if(editorList.size())
+      {
+        GetIntroSite()->GetPage()->Activate( editorList[0]->GetPart(true) );
+      }
+
+    }
+  }
+  // if the scheme is set to http, by default no action is performed, if an external webpage needs to be
+  // shown it should be implemented below
+  else if (scheme.contains(QString("http")) )
+  {
+    QDesktopServices::openUrl(showMeNext);
+//    m_view->load( ) ;
+  }
+  else if(scheme.contains("qrc"))
+  {
+    m_view->load(showMeNext);
+  }
+
+}
+
+#endif
+
+void QmitkMitkWorkbenchIntroPart::StandbyStateChanged(bool standby)
+{
+
+}
+
+
+void QmitkMitkWorkbenchIntroPart::SetFocus()
+{
+
+}
diff --git a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkMitkWorkbenchIntroPart.h b/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkMitkWorkbenchIntroPart.h
new file mode 100644
index 0000000000..06db8a2e27
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkMitkWorkbenchIntroPart.h
@@ -0,0 +1,93 @@
+/*===================================================================
+
+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 QMITKWORKBENCHINTROPART_H_
+#define QMITKWORKBENCHINTROPART_H_
+
+#include <QtCore/qconfig.h>
+
+#include <berryQtIntroPart.h>
+#include <ui_QmitkWelcomeScreenViewControls.h>
+
+
+/**
+ * \ingroup org_mitk_gui_qt_welcomescreen_internal
+ * \brief QmitkMitkWorkbenchIntroPart
+ * The WelcomeView Module is an helpful feature to people new to MITK. The main idea is to provide first 
+ * information about the MITK Workbench. 
+ * The WelcomeView is realized by making use of the QTWebKit Module. The Qt WebKit module 
+ * provides an HTML browser engine that makes it easy to embed web content into native applications, and to enhance 
+ * web content with native controls.
+ * For the welcome view of the application the QWebView, QWebPage classes have been used. The shown WelcomeView
+ * html start page is styled by an external css stylesheet. The required resources as well as the html pages are integrated 
+ * into the QtResource system. The QT resource system allows the storage of files like html pages, css pages, jpgs etc. 
+ * as binaries within the executable. 
+ * This minimizes the risk of loosing resource files as well as the risk of getting files deleted. In order to use the Qt 
+ * resource system the resource files have to be added to the associated qrt resource file list. 
+ * 
+ * The foundation is set to design more complex html pages. The Q::WebPage gives options to set a 
+ * LinkDelegationPolicy. The used policy defines how links to external or internal resources are handled. To fit our needs 
+ * the delegate all links policy is used. This requires all external as well as internal links of the html pages to be handle 
+ * explicitly. In order to change mitk working modes (perspectives) a mitk url scheme has been designed. The url scheme 
+ * is set to mitk. The url host provides information about what's next to do. In our case, the case of switching to a 
+ * particular working mode the host is set to perspectives. The followed path provides information about the perspective id.
+ * (e.g. mitk//::mitk.perspectives/org.mitk.qt.defaultperspective) The the generic design of the mitk url scheme allows to  
+ * execute other task depending on the mitk url host.
+ * \sa QmitkWelcomePage Editor 
+ */
+
+class QWebView ; 
+
+class QmitkMitkWorkbenchIntroPart : public berry::QtIntroPart
+{
+
+// this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
+  Q_OBJECT
+
+public:
+
+  QmitkMitkWorkbenchIntroPart();
+  QmitkMitkWorkbenchIntroPart(const QmitkMitkWorkbenchIntroPart& other)
+  {
+    Q_UNUSED(other)
+    throw std::runtime_error("Copy constructor not implemented");
+  }
+ ~QmitkMitkWorkbenchIntroPart();
+
+
+  virtual void CreateQtPartControl(QWidget *parent);
+
+  void StandbyStateChanged(bool standby);
+
+  void SetFocus();
+#ifdef QT_WEBKIT
+
+  virtual void CreateConnections();
+
+
+protected slots:
+
+
+  void DelegateMeTo(const QUrl& ShowMeNext); 
+#endif
+protected:
+
+  Ui::QmitkWelcomeScreenViewControls* m_Controls;
+  QWebView* m_view;
+};
+
+#endif /* QMITKWORKBENCHINTROPART_H_ */
diff --git a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtDefaultPerspective.h b/Plugins/org.mitk.gui.qt.extapplication/src/internal/perspectives/QmitkEditorPerspective.cpp
old mode 100755
new mode 100644
similarity index 55%
copy from Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtDefaultPerspective.h
copy to Plugins/org.mitk.gui.qt.extapplication/src/internal/perspectives/QmitkEditorPerspective.cpp
index 48e98aae9f..6c787290a9
--- a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtDefaultPerspective.h
+++ b/Plugins/org.mitk.gui.qt.extapplication/src/internal/perspectives/QmitkEditorPerspective.cpp
@@ -1,36 +1,21 @@
 /*===================================================================
 
 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 "QmitkEditorPerspective.h"
 
-#ifndef QMITKEXTDEFAULTPERSPECTIVE_H_
-#define QMITKEXTDEFAULTPERSPECTIVE_H_
-
-#include <berryIPerspectiveFactory.h>
-
-class QmitkExtDefaultPerspective : public QObject, public berry::IPerspectiveFactory
+void QmitkEditorPerspective::CreateInitialLayout(berry::IPageLayout::Pointer /*layout*/)
 {
-  Q_OBJECT
-  Q_INTERFACES(berry::IPerspectiveFactory)
-  
-public:
-
-  QmitkExtDefaultPerspective();
-
-  void CreateInitialLayout(berry::IPageLayout::Pointer layout);
-
-};
-
-#endif /* QMITKEXTDEFAULTPERSPECTIVE_H_ */
+}
diff --git a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtDefaultPerspective.h b/Plugins/org.mitk.gui.qt.extapplication/src/internal/perspectives/QmitkEditorPerspective.h
old mode 100755
new mode 100644
similarity index 56%
copy from Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtDefaultPerspective.h
copy to Plugins/org.mitk.gui.qt.extapplication/src/internal/perspectives/QmitkEditorPerspective.h
index 48e98aae9f..83496d942f
--- a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtDefaultPerspective.h
+++ b/Plugins/org.mitk.gui.qt.extapplication/src/internal/perspectives/QmitkEditorPerspective.h
@@ -1,36 +1,41 @@
 /*===================================================================
 
 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 QMITKEXTDEFAULTPERSPECTIVE_H_
-#define QMITKEXTDEFAULTPERSPECTIVE_H_
+#ifndef QMITKEDITORPERSPECTIVE_H_
+#define QMITKEDITORPERSPECTIVE_H_
 
 #include <berryIPerspectiveFactory.h>
 
-class QmitkExtDefaultPerspective : public QObject, public berry::IPerspectiveFactory
+class QmitkEditorPerspective : public QObject, public berry::IPerspectiveFactory
 {
   Q_OBJECT
   Q_INTERFACES(berry::IPerspectiveFactory)
-  
-public:
 
-  QmitkExtDefaultPerspective();
+public:
 
-  void CreateInitialLayout(berry::IPageLayout::Pointer layout);
+  QmitkEditorPerspective() {}
+  QmitkEditorPerspective(const QmitkEditorPerspective& other)
+  {
+    Q_UNUSED(other)
+    throw std::runtime_error("Copy constructor not implemented");
+  }
+  ~QmitkEditorPerspective() {}
 
+  void CreateInitialLayout(berry::IPageLayout::Pointer /*layout*/);
 };
 
-#endif /* QMITKEXTDEFAULTPERSPECTIVE_H_ */
+#endif /* QMITKEDITORPERSPECTIVE_H_ */
diff --git a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtDefaultPerspective.cpp b/Plugins/org.mitk.gui.qt.extapplication/src/internal/perspectives/QmitkExtDefaultPerspective.cpp
old mode 100755
new mode 100644
similarity index 100%
rename from Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtDefaultPerspective.cpp
rename to Plugins/org.mitk.gui.qt.extapplication/src/internal/perspectives/QmitkExtDefaultPerspective.cpp
diff --git a/Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtDefaultPerspective.h b/Plugins/org.mitk.gui.qt.extapplication/src/internal/perspectives/QmitkExtDefaultPerspective.h
old mode 100755
new mode 100644
similarity index 100%
rename from Plugins/org.mitk.gui.qt.extapplication/src/internal/QmitkExtDefaultPerspective.h
rename to Plugins/org.mitk.gui.qt.extapplication/src/internal/perspectives/QmitkExtDefaultPerspective.h
diff --git a/Plugins/org.mitk.gui.qt.extapplication/src/internal/perspectives/QmitkWelcomeScreenViewControls.ui b/Plugins/org.mitk.gui.qt.extapplication/src/internal/perspectives/QmitkWelcomeScreenViewControls.ui
new file mode 100644
index 0000000000..4a7cda1314
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.extapplication/src/internal/perspectives/QmitkWelcomeScreenViewControls.ui
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>QmitkWelcomeScreenViewControls</class>
+ <widget class="QWidget" name="QmitkWelcomeScreenViewControls">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>458</width>
+    <height>398</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>0</width>
+    <height>0</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>QmitkTemplate</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <property name="margin">
+    <number>0</number>
+   </property>
+   <item row="0" column="0">
+    <layout class="QGridLayout" name="m_WebViewLayout"/>
+   </item>
+  </layout>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/Manual.dox
index 116b47b88d..d80a8bc5dc 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/Manual.dox
@@ -1,12 +1,12 @@
 /**
 \page org_mitk_gui_qt_igtexample IGT Examples
 
-This bundle includes views with examples and help applications for IGT. The different views are described on the pages below:
+This plugin includes views with examples and help applications for IGT. The different views are described on the pages below:
 
 <ul>
 <li> \subpage org_igttrackinglab
 <li> \subpage org_imageguidedtherapytutorial
 </ul>
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/Manual.dox
index 52f21a462b..08bbb387ff 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/Manual.dox
@@ -1,15 +1,15 @@
 /**
 \page org_mitk_gui_qt_igttracking IGT Tracking
 
-This bundle offers basic tracking functionalities. This includes connecting to a tracking system, logging and recording of tracking data, managing tracking tools and playing recorded tracking data.
+This plugin offers basic tracking functionalities. This includes connecting to a tracking system, logging and recording of tracking data, managing tracking tools and playing recorded tracking data.
 
-The bundle includes different views, which are described in different pages in detail:
+The plugin includes different views, which are described in different pages in detail:
 
 <ul>
-<li> \subpage org_igttrackingtoolbox : Allows for connecting to a tracking system and logging/recording of the tracked data.
-<li> \subpage org_igtnavigationtoolmanager : Navigation Tool Manager: This view offers functionality to manage tool storages. Each tool storage holds a preconfigured tool collection. Once saved you can load a tool storage in the Tracking Toolbox and don't need to add every tool seperately.
-<li> \subpage org_navigationdataplayer : Navigation Data Player: Plays navigation data which was recorded with the Tracking Toolbox for example.
+<li> \subpage org_mitk_views_igttrackingtoolbox : Allows for connecting to a tracking system and logging/recording of the tracked data.
+<li> \subpage org_mitk_views_igtnavigationtoolmanager : Navigation Tool Manager: This view offers functionality to manage tool storages. Each tool storage holds a preconfigured tool collection. Once saved you can load a tool storage in the Tracking Toolbox and don't need to add every tool seperately.
+<li> \subpage org_mitk_views_navigationdataplayer : Navigation Data Player: Plays navigation data which was recorded with the Tracking Toolbox for example.
 </ul>
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolManager.dox b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolManager.dox
index 1fee58aeee..0068963460 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolManager.dox
+++ b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolManager.dox
@@ -1,47 +1,47 @@
 /**
 
-\page org_igtnavigationtoolmanager The MITK-IGT Navigation Tool Manager
+\page org_mitk_views_igtnavigationtoolmanager The MITK-IGT Navigation Tool Manager
 
 \image html iconNavigationToolManager.png "Icon of the Module"
 
 \section QmitkMITKIGTNavigationToolManager Introduction
 
-This bundle allows for creating and editing NavigationToolStorages. These storages contains naviagtion tools of a tracking device, can be saved permanently and used later for any other IGT application.
+This view allows for creating and editing NavigationToolStorages. These storages contains naviagtion tools of a tracking device, can be saved permanently and used later for any other IGT application.
 
 Available sections:
   - \ref QmitkMITKIGTNavigationToolManager
   - \ref QmitkMITKIGTNavigationToolManagerToolOverview
   - \ref QmitkMITKIGTNavigationToolManagerManagingNavigationToolStorage
   - \ref QmitkMITKIGTNavigationToolManagerAddingEditingNavigationTools
 
 \section QmitkMITKIGTNavigationToolManagerToolOverview Navigation Tools Overview
 
 A navigation tool of MITK-IGT represents a tracking tool (e.g. an emt sensor or an optically tracked tool) and it's corresponding data, like it's name and it's surface. A navigation tool is a generalized container for any trackable object in combination with it's additional information. Every navigation tool has different properties which are:
 
 <ul>
 <li> Name
 <li> Unique identifier
 <li> Tool definition file
 <li> Serial number
 <li> Surface for visualization
 <li> Type of tracking device
 <li> Type of the tool
 </ul>
 
-Note that not all properties are needed for all types of tools. A tool definition file, for example, is only needed by optical tracking tools (e.g. a .rom file for Polaris or a toolfile for the MicronTracker). A tool associated with the aurora system is alwalys identified by it's serial number. You can also detect Aurora tools automatically with the TrackingToolbox bundle and edit the automatically detected tool storage later with this bundle. 
+Note that not all properties are needed for all types of tools. A tool definition file, for example, is only needed by optical tracking tools (e.g. a .rom file for Polaris or a toolfile for the MicronTracker). A tool associated with the aurora system is alwalys identified by it's serial number. You can also detect Aurora tools automatically with the TrackingToolbox view and edit the automatically detected tool storage later with this view. 
 
 \section QmitkMITKIGTNavigationToolManagerManagingNavigationToolStorage Managing Navigation Tool Storage
 
 In order to create a new storage container, or edit an existing one, you can use the buttons "add", "edit" and "delete" to manage the contained navigation tools. If you click "edit" or "delete" the operation is applied on the currently selected tool, as shown in the screenshot below. If you want to create a new storage container, just start adding tools when you start the program and save the storage container. To edit an existing tool storage container click "load" and add/edit/delete tools.
 
 \image html NavigationToolManagemantStartScreen.png "Screenshot of the main view of NavigationToolManagent"
 
 \section QmitkMITKIGTNavigationToolManagerAddingEditingNavigationTools Adding / Editing Navigation Tools
 
 If you add or edit a navigation tool, an input mask, as shown in the screenshot below, appears. The tool identifier is filled automatically, if you change it, remember that it is unique in the current storage. Also, choose a valid surface for every tool, this is nessesary for correct tool visualization. The other information depends on the tracking system type. So choose a tool file for the Polaris or the MicronTracker system and type in a serial number for the Aurora system. Two identical tools with the same serial number are also possible, they are assigned by the order in which they are attached to the device. As long as they also have the same surface, this should not be a problem.
 
 The tool type is additional information which is not needed by the tracking device but might be needed by further IGT applications.
 
 \image html NavigationToolManagementAddTool.png "Screenshot of add/edit navigation tool screen"
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTTrackingToolbox.dox b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTTrackingToolbox.dox
index 82a85e61fa..0d1c66231c 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTTrackingToolbox.dox
+++ b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTTrackingToolbox.dox
@@ -1,64 +1,64 @@
 /**
 
-\page org_igttrackingtoolbox The MITK-IGT Tracking Toolbox
+\page org_mitk_views_igttrackingtoolbox The MITK-IGT Tracking Toolbox
 
 \image html iconTrackingToolbox.png "Icon of the module"
 
 Available sections:
   - \ref QmitkMITKIGTTrackingToolboxIntroduction
   - \ref QmitkMITKIGTTrackingToolboxWorkflow
   - \ref QmitkMITKIGTTrackingToolboxConnecting
   - \ref QmitkMITKIGTTrackingToolboxLoadingTools
   - \ref QmitkMITKIGTTrackingToolboxAutoDetection
   - \ref QmitkMITKIGTTrackingToolboxStartTracking
   - \ref QmitkMITKIGTTrackingToolboxLogging
   - \ref QmitkMITKIGTTrackingOptions
 
 \section QmitkMITKIGTTrackingToolboxIntroduction Introduction
 
-The MITK-IGT Tracking Toolbox is a bundle which allows you to connect to a tracking device, track and visualize navigation tools and write the tracked data into a log file. Currently the devices Polaris, Aurora (both Northern Digital Inc. (NDI); Waterloo, Ontario, Canada) and MicronTracker (Claron Technology, Inc.; Toronto, Ontario, Canada) are supported. The MicroBird family (Ascension Technology Corporation, Inc.; Burlington, USA) will hopefully follow soon since it is already supported by the tracking layer of IGT. The logging feature of the Tracking Toolbox supports logging in XML or CSV format.
+The MITK-IGT Tracking Toolbox is a view which allows you to connect to a tracking device, track and visualize navigation tools and write the tracked data into a log file. Currently the devices Polaris, Aurora (both Northern Digital Inc. (NDI); Waterloo, Ontario, Canada) and MicronTracker (Claron Technology, Inc.; Toronto, Ontario, Canada) are supported. The MicroBird family (Ascension Technology Corporation, Inc.; Burlington, USA) will hopefully follow soon since it is already supported by the tracking layer of IGT. The logging feature of the Tracking Toolbox supports logging in XML or CSV format.
 
 \image html screenshot_mitk.png "MITK Screenshot with the TrackingToolbox activated"
 
 \section QmitkMITKIGTTrackingToolboxWorkflow General workflow Introduction
 
 A general Workflow with the Tracking Toolbox may be:
 
 <ul>
 <li> Configuration of a tracking device
 <li> Loading a toolfile which holds tool definitions
 <li> Start tracking
 <li> Logging tracked data
 </ul>
 
 \section QmitkMITKIGTTrackingToolboxConnecting Tracking Device Configuration
 
 The tracking device can be specified in the tracking device configuration section located in the upper area of the tracking tab. As shown in the screenshot below, you choose your tracking device in the drop down menu. If you use a tracking system connected to a serial port, like Aurora or Polaris, you then need to specifiy the serial port. In case of the MicronTracker you only need to ensure that all drivers are installed correctly and integrated into MITK. If you want to check the connection, press "test connection". The results are displayed in the small black box on the right.
 
 \image html configurationWidget.png "Tracking Device Configuration"
 
 \section QmitkMITKIGTTrackingToolboxLoadingTools Loading tools
 
-To load tools which can be tracked you need a predefined tracking tool storage. If you use the Aurora system you also have the possibility to automatically detect the connected tools. In this case a tracking tool storage is created by the software (see section below). Otherwise you can use the MITK bundle NavigationToolManager to define a navigation tool storage. There you can create navigation tools with the corresponding toolfiles, visualization surfaces and so on. Please see NavigationToolManager manual for more details.
+To load tools which can be tracked you need a predefined tracking tool storage. If you use the Aurora system you also have the possibility to automatically detect the connected tools. In this case a tracking tool storage is created by the software (see section below). Otherwise you can use the MITK view NavigationToolManager to define a navigation tool storage. There you can create navigation tools with the corresponding toolfiles, visualization surfaces and so on. Please see NavigationToolManager manual for more details.
 
 Navigation tool storages can be loaded by pressing the button "Load Tools". Please ensure that the tracking device type of the tools matches the chosen tracking device, otherwise you will get an error message if you try to start tracking. All loaded tools will then be displayed in grey as shown in the screenshot below. If you start tracking they will become green if the tools were found and red if they were not found inside the tracking volume.
 
 \image html trackingToolsWidget.png "Tracking Tools"
 
 \section QmitkMITKIGTTrackingToolboxAutoDetection Auto detection of tools (only Aurora)
 
 If the Aurora tracking system is used, a button "Auto Detection" appears. If you press this button the software connects to the system and automatically detects all connected tools. You will then be asked whether you want to save the detected tools as a tool storage to the hard drive. You might want to do this if you want to use or modify this tool storage later. In the automatically detected tool storage the tools are named AutoDetectedTools1, AutoDetectedTools2, and so on. Small spheres are used as tool surfaces. After autodetection the detected tools are loaded automatically even if you did not save them.
 
 \section QmitkMITKIGTTrackingToolboxStartTracking Start/stop tracking
 
 Tracking can simply be started by pressing "Start Tracking". Note that options may not be changed during tracking. Once tracking has started the tracking volume (only if the option is on) and the tools are visualized in the 3D view of MITK.
 
 \section QmitkMITKIGTTrackingToolboxLogging Logging features
 
 If your device is tracking, you are able to log the tracking data by using the logging tab. You first must define a file name. You can then choose whether you want comma seperated (csv) or xml format. Press "Start Logging" to start logging. You can also limit the number of logged frames, which will cause the logging to stop automatically after the given number.
 
 \section QmitkMITKIGTTrackingOptions Options
 
 In the options tab you can enable or disable the visualization of the tracking volume and of the tool quaternions. If enabled, the tool quaternions are shown in the tool information. You can also define the update rate of the tracking data. The update rate should not be set higher than the update rate of the tracking system.
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkNavigationDataPlayer.dox b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkNavigationDataPlayer.dox
index 667946ac47..c6dec7930e 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkNavigationDataPlayer.dox
+++ b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkNavigationDataPlayer.dox
@@ -1,18 +1,18 @@
 /**
-\page org_navigationdataplayer NavigationData Player
+\page org_mitk_views_navigationdataplayer NavigationData Player
 
 \image html iconNavigationDataPlayer.png "Icon of NavigationData Player"
 
 Available sections:
   - \ref NavigationDataPlayerOverview
 
 \section NavigationDataPlayerOverview
 The navigation data player plays recorded or artificial navigation data of one ore more tracking tools and visualizes their trajectory. For that purpose select an input file (*.xml only) and select which tracking tool's trajectory should be visualized. If you additionally activate the checkbox "Splines" the trajectory curve will be smoothed via spline interpolation.
 Press the button "start" for starting the player and the visualization. If "Sequential Mode" is checked, the navigation data are played sequentially without regarding the recorded time steps.
 
 You can use the resolution field to define which part of the samples you want to use. E.g. 1 = every sample; 2 = every second sample; 3 = every third sample, ...
 
 \image html screenshotNavigationDataPlayer.png "Screenshot of the NavigationData Player"
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/QmitkImageCropperUserManual.dox b/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/QmitkImageCropperUserManual.dox
index 0c7dbce73a..26abe156ce 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/QmitkImageCropperUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/QmitkImageCropperUserManual.dox
@@ -1,41 +1,41 @@
 /**
-\page org_imagecropper The Image Cropper Module
+\page org_mitk_views_imagecropper The Image Cropper Plugin
 
-\image html icon.png "Icon of the Module"
+\image html icon.png "Icon of the Plugin"
 
 Available sections:
   - \ref QmitkImageCropperUserManualOverview 
   - \ref QmitkImageCropperUserManualFeatures 
   - \ref QmitkImageCropperUserManualUsage 
   - \ref QmitkImageCropperUserManualTroubleshooting
 
 \section QmitkImageCropperUserManualOverview Overview
 
 ImageCropper is a functionality which allows the user to manually crop an image by means of a bounding box. The functionality does not create a new image, it only hides parts of the original image.
 
 \section QmitkImageCropperUserManualFeatures Features
 
 - Crop a selected image using a bounding box.
 - Set the border voxels to a specific user defined value after cropping.
 
 
 
 \section QmitkImageCropperUserManualUsage Usage
 First select from the drop down menu the image to crop. The three 2D widgets show yellow rectangles representing the bounding box in each plane (axial, sagital, coronal), the lower right 3D widget shows the entire volume of the bounding box.\n
 
 - To change the <b>size</b> of bounding box press <i> control + right click </i> and move the cursor up/down or left/right in one of the three 2D views.\n
 - To change the <b>orientation</b> of the bounding box press <i> control + middle click </i> and move the cursor up/down or left/right in one of the three 2D views.\n
 - To <b>move</b> the bounding box press <i> control + left click </i> and move the cursor to the wanted position in one of the three 2D views.\n
 
 
 To show the result press the [crop] button.\n
 To crop the image again press the [New bounding box!] button.\n\n
 
 All actions can be undone by using the global undo function (Ctrl+Z).\n
 
 To set the border voxels to a specific value after cropping the image, activate the corresponding checkbox and choose a gray value.
 
 \section QmitkImageCropperUserManualTroubleshooting Troubleshooting
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.imagenavigator/documentation/UserManual/QmtikImageNavigator.dox b/Plugins/org.mitk.gui.qt.imagenavigator/documentation/UserManual/QmtikImageNavigator.dox
index 721f5b8d33..86ed33d160 100644
--- a/Plugins/org.mitk.gui.qt.imagenavigator/documentation/UserManual/QmtikImageNavigator.dox
+++ b/Plugins/org.mitk.gui.qt.imagenavigator/documentation/UserManual/QmtikImageNavigator.dox
@@ -1,15 +1,15 @@
 /**
-\page org_imagenavigator The Image Navigator
+\page org_mitk_views_imagenavigator The Image Navigator
 
 \image html Slider.png "Icon of the Module"
 
 \image html ImageNavigator.png "Image Navigator"
 
 Fast movement through the available data can be achieved by using the Image Navigator. 
 By moving the sliders around you can scroll quickly through the slides and timesteps. 
 By entering numbers in the relevant fields you can jump directly to your point of interest.
 
 The "Show detail" checkbox enables you to see the world coordinates in millimetres
 and the index/voxel coordinates.  These may be edited to jump to a specific location.
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
index 4c8c73f202..fcfec0e161 100644
--- a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
+++ b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
@@ -1,398 +1,398 @@
 /*===================================================================
 
 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 "QmitkImageNavigatorView.h"
 
 #include <QmitkStepperAdapter.h>
 #include <QmitkRenderWindow.h>
 
 #include <berryConstants.h>
 
 
 const std::string QmitkImageNavigatorView::VIEW_ID = "org.mitk.views.imagenavigator";
 
 
 QmitkImageNavigatorView::QmitkImageNavigatorView()
   : m_AxialStepper(0)
   , m_SagittalStepper(0)
   , m_FrontalStepper(0)
   , m_TimeStepper(0)
   , m_Parent(0)
   , m_IRenderWindowPart(0)
 {
 }
 
 QmitkImageNavigatorView::~QmitkImageNavigatorView()
 {
 }
 
 void QmitkImageNavigatorView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets
   m_Parent = parent;
   m_Controls.setupUi(parent);
   m_Controls.m_SliceNavigatorAxial->SetInverseDirection(true);
 
   connect(m_Controls.m_XWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
   connect(m_Controls.m_YWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
   connect(m_Controls.m_ZWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
 
   m_Parent->setEnabled(false);
 
   mitk::IRenderWindowPart* renderPart = this->GetRenderWindowPart();
   this->RenderWindowPartActivated(renderPart);
 }
 
 void QmitkImageNavigatorView::SetFocus ()
 {
   m_Controls.m_XWorldCoordinateSpinBox->setFocus();
 }
 
 void QmitkImageNavigatorView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (this->m_IRenderWindowPart != renderWindowPart)
   {
     this->m_IRenderWindowPart = renderWindowPart;
     this->m_Parent->setEnabled(true);
 
     QmitkRenderWindow* renderWindow = renderWindowPart->GetRenderWindow("axial");
     if (renderWindow)
     {
       if (m_AxialStepper) m_AxialStepper->deleteLater();
       m_AxialStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorAxial,
                                                      renderWindow->GetSliceNavigationController()->GetSlice(),
                                                      "sliceNavigatorAxialFromSimpleExample");
       m_Controls.m_SliceNavigatorAxial->setEnabled(true);
       m_Controls.m_AxialLabel->setEnabled(true);
       m_Controls.m_ZWorldCoordinateSpinBox->setEnabled(true);
       connect(m_AxialStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
     }
     else
     {
       m_Controls.m_SliceNavigatorAxial->setEnabled(false);
       m_Controls.m_AxialLabel->setEnabled(false);
       m_Controls.m_ZWorldCoordinateSpinBox->setEnabled(false);
     }
 
     renderWindow = renderWindowPart->GetRenderWindow("sagittal");
     if (renderWindow)
     {
       if (m_SagittalStepper) m_SagittalStepper->deleteLater();
       m_SagittalStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorSagittal,
                                                   renderWindow->GetSliceNavigationController()->GetSlice(),
                                                   "sliceNavigatorSagittalFromSimpleExample");
       m_Controls.m_SliceNavigatorSagittal->setEnabled(true);
       m_Controls.m_SagittalLabel->setEnabled(true);
       m_Controls.m_YWorldCoordinateSpinBox->setEnabled(true);
       connect(m_SagittalStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
     }
     else
     {
       m_Controls.m_SliceNavigatorSagittal->setEnabled(false);
       m_Controls.m_SagittalLabel->setEnabled(false);
       m_Controls.m_YWorldCoordinateSpinBox->setEnabled(false);
     }
 
     renderWindow = renderWindowPart->GetRenderWindow("coronal");
     if (renderWindow)
     {
       if (m_FrontalStepper) m_FrontalStepper->deleteLater();
       m_FrontalStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorFrontal,
                                                  renderWindow->GetSliceNavigationController()->GetSlice(),
                                                  "sliceNavigatorFrontalFromSimpleExample");
       m_Controls.m_SliceNavigatorFrontal->setEnabled(true);
       m_Controls.m_CoronalLabel->setEnabled(true);
       m_Controls.m_XWorldCoordinateSpinBox->setEnabled(true);
       connect(m_FrontalStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
     }
     else
     {
       m_Controls.m_SliceNavigatorFrontal->setEnabled(false);
       m_Controls.m_CoronalLabel->setEnabled(false);
       m_Controls.m_XWorldCoordinateSpinBox->setEnabled(false);
     }
 
     mitk::SliceNavigationController* timeController = renderWindowPart->GetTimeNavigationController();
     if (timeController)
     {
       if (m_TimeStepper) m_TimeStepper->deleteLater();
       m_TimeStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorTime,
                                               timeController->GetTime(),
                                               "sliceNavigatorTimeFromSimpleExample");
       m_Controls.m_SliceNavigatorTime->setEnabled(true);
       m_Controls.m_TimeLabel->setEnabled(true);
     }
     else
     {
       m_Controls.m_SliceNavigatorTime->setEnabled(false);
       m_Controls.m_TimeLabel->setEnabled(false);
     }
   }
 }
 
 void QmitkImageNavigatorView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_IRenderWindowPart = 0;
   m_Parent->setEnabled(false);
 }
 
 int QmitkImageNavigatorView::GetSizeFlags(bool width)
 {
   if(!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkImageNavigatorView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
 {
   if(width==false)
   {
     return 200;
   }
   else
   {
     return preferredResult;
   }
 }
 
 int QmitkImageNavigatorView::GetClosestAxisIndex(mitk::Vector3D normal)
 {
   // cos(theta) = normal . axis
   // cos(theta) = (a, b, c) . (d, e, f)
   // cos(theta) = (a, b, c) . (1, 0, 0) = a
   // cos(theta) = (a, b, c) . (0, 1, 0) = b
   // cos(theta) = (a, b, c) . (0, 0, 1) = c
   double absCosThetaWithAxis[3];
 
   for (int i = 0; i < 3; i++)
   {
     absCosThetaWithAxis[i] = fabs(normal[i]);
   }
   int largestIndex = 0;
   double largestValue = absCosThetaWithAxis[0];
   for (int i = 1; i < 3; i++)
   {
     if (absCosThetaWithAxis[i] > largestValue)
     {
       largestValue = absCosThetaWithAxis[i];
       largestIndex = i;
     }
   }
   return largestIndex;
 }
 
 void QmitkImageNavigatorView::SetBorderColors()
 {
   if (m_IRenderWindowPart)
   {
     QmitkRenderWindow* renderWindow = m_IRenderWindowPart->GetRenderWindow("axial");
     if (renderWindow)
     {
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, QString("red"));
       }
     }
 
     renderWindow = m_IRenderWindowPart->GetRenderWindow("sagittal");
     if (renderWindow)
     {
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, QString("green"));
       }
     }
 
     renderWindow = m_IRenderWindowPart->GetRenderWindow("coronal");
     if (renderWindow)
     {
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, QString("blue"));
       }
     }
   }
 }
 
 void QmitkImageNavigatorView::SetBorderColor(int axis, QString colorAsStyleSheetString)
 {
   if (axis == 0)
   {
     this->SetBorderColor(m_Controls.m_XWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
   else if (axis == 1)
   {
     this->SetBorderColor(m_Controls.m_YWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
   else if (axis == 2)
   {
     this->SetBorderColor(m_Controls.m_ZWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
 }
 
 void QmitkImageNavigatorView::SetBorderColor(QDoubleSpinBox *spinBox, QString colorAsStyleSheetString)
 {
   assert(spinBox);
   spinBox->setStyleSheet(QString("border: 2px solid ") + colorAsStyleSheetString + ";");
 }
 
 void QmitkImageNavigatorView::SetStepSizes()
 {
   this->SetStepSize(0);
   this->SetStepSize(1);
   this->SetStepSize(2);
 }
 
 void QmitkImageNavigatorView::SetStepSize(int axis)
 {
   if (m_IRenderWindowPart)
   {
-    mitk::Geometry3D::ConstPointer geometry = m_IRenderWindowPart->GetActiveRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry();
+    mitk::Geometry3D::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry();
 
     if (geometry.IsNotNull())
     {
       mitk::Point3D crossPositionInIndexCoordinates;
       mitk::Point3D crossPositionInIndexCoordinatesPlus1;
       mitk::Point3D crossPositionInMillimetresPlus1;
       mitk::Vector3D transformedAxisDirection;
 
       mitk::Point3D crossPositionInMillimetres = m_IRenderWindowPart->GetSelectedPosition();
       geometry->WorldToIndex(crossPositionInMillimetres, crossPositionInIndexCoordinates);
 
       crossPositionInIndexCoordinatesPlus1 = crossPositionInIndexCoordinates;
       crossPositionInIndexCoordinatesPlus1[axis] += 1;
 
       geometry->IndexToWorld(crossPositionInIndexCoordinatesPlus1, crossPositionInMillimetresPlus1);
 
       transformedAxisDirection = crossPositionInMillimetresPlus1 - crossPositionInMillimetres;
 
       int closestAxisInMillimetreSpace = this->GetClosestAxisIndex(transformedAxisDirection);
       double stepSize = transformedAxisDirection.GetNorm();
       this->SetStepSize(closestAxisInMillimetreSpace, stepSize);
     }
   }
 }
 
 void QmitkImageNavigatorView::SetStepSize(int axis, double stepSize)
 {
   if (axis == 0)
   {
     m_Controls.m_XWorldCoordinateSpinBox->setSingleStep(stepSize);
   }
   else if (axis == 1)
   {
     m_Controls.m_YWorldCoordinateSpinBox->setSingleStep(stepSize);
   }
   else if (axis == 2)
   {
     m_Controls.m_ZWorldCoordinateSpinBox->setSingleStep(stepSize);
   }
 }
 
 void QmitkImageNavigatorView::OnMillimetreCoordinateValueChanged()
 {
   if (m_IRenderWindowPart)
   {
-    mitk::Geometry3D::ConstPointer geometry = m_IRenderWindowPart->GetActiveRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry();
+    mitk::Geometry3D::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry();
 
     if (geometry.IsNotNull())
     {
       mitk::Point3D positionInWorldCoordinates;
       positionInWorldCoordinates[0] = m_Controls.m_XWorldCoordinateSpinBox->value();
       positionInWorldCoordinates[1] = m_Controls.m_YWorldCoordinateSpinBox->value();
       positionInWorldCoordinates[2] = m_Controls.m_ZWorldCoordinateSpinBox->value();
 
       m_IRenderWindowPart->SetSelectedPosition(positionInWorldCoordinates);
     }
   }
 }
 
 void QmitkImageNavigatorView::OnRefetch()
 {
   if (m_IRenderWindowPart)
   {
-    mitk::Geometry3D::ConstPointer geometry = m_IRenderWindowPart->GetActiveRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry();
+    mitk::Geometry3D::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry();
 
     if (geometry.IsNotNull())
     {
       mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
 
       mitk::Point3D cornerPoint1InIndexCoordinates;
       cornerPoint1InIndexCoordinates[0] = bounds[0];
       cornerPoint1InIndexCoordinates[1] = bounds[2];
       cornerPoint1InIndexCoordinates[2] = bounds[4];
 
       mitk::Point3D cornerPoint2InIndexCoordinates;
       cornerPoint2InIndexCoordinates[0] = bounds[1];
       cornerPoint2InIndexCoordinates[1] = bounds[3];
       cornerPoint2InIndexCoordinates[2] = bounds[5];
 
       if (!geometry->GetImageGeometry())
       {
         cornerPoint1InIndexCoordinates[0] += 0.5;
         cornerPoint1InIndexCoordinates[1] += 0.5;
         cornerPoint1InIndexCoordinates[2] += 0.5;
         cornerPoint2InIndexCoordinates[0] -= 0.5;
         cornerPoint2InIndexCoordinates[1] -= 0.5;
         cornerPoint2InIndexCoordinates[2] -= 0.5;
       }
 
       mitk::Point3D crossPositionInWorldCoordinates = m_IRenderWindowPart->GetSelectedPosition();
 
       mitk::Point3D cornerPoint1InWorldCoordinates;
       mitk::Point3D cornerPoint2InWorldCoordinates;
 
       geometry->IndexToWorld(cornerPoint1InIndexCoordinates, cornerPoint1InWorldCoordinates);
       geometry->IndexToWorld(cornerPoint2InIndexCoordinates, cornerPoint2InWorldCoordinates);
 
       m_Controls.m_XWorldCoordinateSpinBox->blockSignals(true);
       m_Controls.m_YWorldCoordinateSpinBox->blockSignals(true);
       m_Controls.m_ZWorldCoordinateSpinBox->blockSignals(true);
 
       m_Controls.m_XWorldCoordinateSpinBox->setMinimum(std::min(cornerPoint1InWorldCoordinates[0], cornerPoint2InWorldCoordinates[0]));
       m_Controls.m_YWorldCoordinateSpinBox->setMinimum(std::min(cornerPoint1InWorldCoordinates[1], cornerPoint2InWorldCoordinates[1]));
       m_Controls.m_ZWorldCoordinateSpinBox->setMinimum(std::min(cornerPoint1InWorldCoordinates[2], cornerPoint2InWorldCoordinates[2]));
       m_Controls.m_XWorldCoordinateSpinBox->setMaximum(std::max(cornerPoint1InWorldCoordinates[0], cornerPoint2InWorldCoordinates[0]));
       m_Controls.m_YWorldCoordinateSpinBox->setMaximum(std::max(cornerPoint1InWorldCoordinates[1], cornerPoint2InWorldCoordinates[1]));
       m_Controls.m_ZWorldCoordinateSpinBox->setMaximum(std::max(cornerPoint1InWorldCoordinates[2], cornerPoint2InWorldCoordinates[2]));
 
       m_Controls.m_XWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[0]);
       m_Controls.m_YWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[1]);
       m_Controls.m_ZWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[2]);
 
       m_Controls.m_XWorldCoordinateSpinBox->blockSignals(false);
       m_Controls.m_YWorldCoordinateSpinBox->blockSignals(false);
       m_Controls.m_ZWorldCoordinateSpinBox->blockSignals(false);
     }
 
     this->SetBorderColors();
 
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkImageStatistics.dox b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkImageStatistics.dox
index d8b1a02745..f3a1131c37 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkImageStatistics.dox
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkImageStatistics.dox
@@ -1,44 +1,44 @@
 /**
-\page org_imagestatistics The Image Statistics Module
+\page org_mitk_views_imagestatistics The Image Statistics View
 
-\image html ImageStatistic_48.png "Icon of the Module"
+\image html ImageStatistic_48.png "Icon of the View"
 
 \section QmitkImageStatisticsUserManualSummary Summary
 
-This module provides an easy interface to quickly compute some features of a whole image or a region of interest.
+This view provides an easy interface to quickly compute some features of a whole image or a region of interest.
 
-This document will tell you how to use this module, but it is assumed that you already know how to use MITK in general.
+This document will tell you how to use this view, but it is assumed that you already know how to use MITK in general.
 
 Please see \ref QmitkImageStatisticsUserManualDetails for more detailed information on usage and supported filters.
-If you encounter problems using the module, please have a look at the \ref QmitkImageStatisticsUserManualTrouble page.
+If you encounter problems using the view, please have a look at the \ref QmitkImageStatisticsUserManualTrouble page.
 
 \section QmitkImageStatisticsUserManualDetails Details
 
 Manual sections:
 
 - \ref QmitkImageStatisticsUserManualOverview 
 - \ref QmitkImageStatisticsUserManualUsage
 - \ref QmitkImageStatisticsUserManualTrouble
 
 \section QmitkImageStatisticsUserManualOverview Overview
 
-This module provides an easy interface to quickly compute some features of a whole image or a region of interest.
+This view provides an easy interface to quickly compute some features of a whole image or a region of interest.
 
 \image html Screenshot1.png "The interface"
 
 \section QmitkImageStatisticsUserManualUsage Usage
 
-After selection of an image or a binary mask of an image in the datamanader, the Image Statistics module shows some statistical information. If a mask is selected, the name of the mask and the name of the image, to which the mask is applied, are shown at the top.
+After selection of an image or a binary mask of an image in the datamanader, the Image Statistics view shows some statistical information. If a mask is selected, the name of the mask and the name of the image, to which the mask is applied, are shown at the top.
 
 Below it is the statistics window which displays the calculated statistical features (such as mean, standard deviation...) and the histogram.
 
-At the bottom of the module are two buttons. They copy their respective data in csv format to the clipboard.
+At the bottom of the view are two buttons. They copy their respective data in csv format to the clipboard.
 
 \section QmitkImageStatisticsUserManualTrouble Troubleshooting
 
 No known problems.
 
 <B>All other problems.</B><BR>
 Please report to the MITK mailing list.
 See http://www.mitk.org/wiki/Mailinglist on how to do this.
 */
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
index c67288184b..c990dbef5a 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
@@ -1,134 +1,134 @@
 /**
-\page org_measurement The Measurement Module
+\page org_mitk_views_measurement The Measurement View
 
-\image html Measurement_48.png "Icon of the Module"
+\image html Measurement_48.png "Icon of the View"
 
 \section QmitkMeasurementUserManualOverview Overview
 
-The Measurement module enables the user to interact with 2D images or single slices of 3D image stacks and planar figure data types. It allows to measure distances, angels, pathes and several geometric figures on a dataset. 
+The Measurement view enables the user to interact with 2D images or single slices of 3D image stacks and planar figure data types. It allows to measure distances, angels, pathes and several geometric figures on a dataset. 
 
 Available Sections:
 - \ref QmitkMeasurementUserManualOverview
 - \ref QmitkMeasurementUserManualFeatures
   - \ref SubOne
   - \ref SubTwo
   - \ref SubThree
   - \ref SubFour
   - \ref SubFive
   - \ref SubSix
   - \ref SubSeven
 - \ref QmitkMeasurementUserManualUsage
   - \ref One
   - \ref Two
   - \ref Three
   - \ref Four
 
-The workflow to use this module is:
+The workflow to use this view is:
 
 \image html Workflow.png
 
-The workflow is repeatedly useable with the same or different measurement figures, which are correlated to the choosen image and can be saved together with it for future use. On pressing the Measurement icon (see picture below the page title) in the view button line the basic appearance of the bundle is as follws.
+The workflow is repeatedly useable with the same or different measurement figures, which are correlated to the choosen image and can be saved together with it for future use. On pressing the Measurement icon (see picture below the page title) in the view button line the basic appearance of the view is as follws.
 
 \image html Basic_Screen_edited.JPG
 
-The standard working plane is "Axial" but the other standard viewplanes ("Saggital" and "Coronal") are also valid for measurements. To swap between the view planes refer to 3M Application Bundle User Manual.
+The standard working plane is "Axial" but the other standard viewplanes ("Saggital" and "Coronal") are also valid for measurements. To swap between the view planes refer to the application user manual.
 
 \section QmitkMeasurementUserManualFeatures Features
 
-The bundle as it is depicted below offers the following features in the order of apperance on the image from top to bottom: 
+The view as it is depicted below offers the following features in the order of apperance on the image from top to bottom: 
 \image html Measurement_View.JPG
 The first information is the selected image's name (here: DICOM-MRI-Image) followed by the measurement figures button line with the seven measurement figures. From left to right the buttons are connected with the following functions:
 
 \subsection SubOne Draw Line
 Draws a line between two set points and returns the distance between these points.
 
 \subsection SubTwo Draw Path
 Draws a path between several set points (two and more) and calculates the circumference, that is all line's length summed up. Add the final point by double left click.
 
 \subsection SubThree Draw Angle
 Draws two lines from three set points connected in the second set point and returns the inner angle at the second point. 
 
 \subsection SubFour Draw Four Point Angle
 Draws two lines that may but must not intersect from four set points. The returned angle is the one depicted in the icon.
 
 \subsection SubFive Draw Circle
 Draws a circle by setting two points, whereas the first set point is the center and the second the radius of the circle. The measured values are the radius and the included area.
 
 \subsection SubSix Draw Rectangle
 Draws a rectangle by setting two points at the opposing edges of the rectangle starting with the upper left edge. The measured values are the circumference and the included area. 
 
 \subsection SubSeven Draw Polygon
 Draws a polygon by setting three or more points. The measured values are the circumference and the included area. Add the final point by double left click.
 
 Below the buttonline the statistics window is situated, it displays the results of the actual measurements from the selected measurement figures. The content of the statistics window can be copied to the clipboard with the correspondig button for further use in a table calculation programm (e.g. Open Office Calc etc.). 
 
 \image html  Image_processed.JPG
 
-The last row contains again a button line to swap from the measurement bundle (activated in the image) to other supported MITK 3M3 bundles.
+The last row contains again a button line to swap from the measurement perspective (activated in the image) to other supported MITK perspectives.
   
 \section QmitkMeasurementUserManualUsage Usage
 
 This Section is subdivided into four subsections:
 <ol>
     <li><b>Add an image</b>
     <li><b>Work with measurement figures</b>
     <li><b>Save the image with measurement information</b>
   <li><b>Remove measurement figures or image</b>
 </ol>
 
 Let's start with subsection 1
 \subsection One   Add an image
 
 There are two possible ways to add an image to the programm. One is to grap the image with left mouse click from your prefered file browser and simply drag&drop it to the View Plane field. The other way is to use the 
 \image html OpenButton.png
 button in the upper left corner of the application. A dialog window appears showing the file tree of the computer. Navigate to the wanted file and select it with the left mouse click. Afterwards just use the dialog's open button.  
 
 The wanted image appears in the View Plane and in the Data Manager the images name appears as a new tree node. Now the image is loaded it can be adjusted in the usual way ( zoom in/out: right mouse button + moving the mouse up and down, moving the image: press mouse wheel and move the mouse to the wished direction, scroll through the slices( only on 3D images): scroll mouse wheel up and down).
 
 \image html Image_Loaded_Screen.JPG
 
 After the image is loaded the image's name appears in the Data Manager. By left-clicking on the image name the buttonline becomes activated. 
 
 \subsection Two Work with measurement figures
-The measurement module comes with seven measurement figures(see picture below), that can be applied to the images. 
+The measurement view comes with seven measurement figures(see picture below), that can be applied to the images. 
 \image html MeasurementFigureButtonline.jpg
 The results of the measurement with each of these figures is shown in the statistics window and in the lower right corner of the view plane. 
 \image html Image_processed_Screen.JPG
 When applying more then one measurement figure to the image the actual measurement figure is depicted in red and the displayed values belong to this measurement figure. All measurement figures become part of the Data Manager as a node of the image tree.
 
 \subsection Three Save the image with measurement information
 After applying the wanted measurement figures the entire scene consisting of the image and the measurement figures can be saved for future use. Therefore just click the right mouse button when over the image item in the Data Manager and choose the item "Save" in the opening item list. Following to that a save dialog appears where the path to the save folder can be set. Afterwards just accept your choice with the save button.
 
 \subsection Four Remove measurement figures or image
 If the single measurement figures or the image is not needed any longer, it can be removed solely or as an entire group. The image can't be removed without simultaneously removing all the dependent measurement figures that belong to the image tree in the Data Manager. To remove just select the wanted items in the data manager list by left-click on it or if several items wanted to be removed left click on all wanted by simultaneously holding the ctrl-button pressed.
 
 For more detailed usage of the save/remove functionality refer to the Data Manager User Manual.
 
 <!-- <ul>
   <li> The Measurement Module is able to measure:
   <ul>
     <li> Distances between two points
     <li> Angles between two lines (defined by three points) 
     <li> Distances along a path 
     </ul>
 </ul>
     
 \section QmitkMeasurementUserManualUsage Usage
 To use the Measurement Module, at first a data set must be loaded. That can be done by drag & drop.
 Choose the measurement method you need by pressing the according button. 
 <ul>
   <li>Points can be set by "shift-clicking" on the place in the data set. 
   <li>Remove points by pressing the del-button on your keyboard. 
   <li>You can mark a point by clickon it with the cursor and move it while the mouse button is still pressed. 
 </ul>
 What the different modes mean and how to use them:
 <ul>
   <li> a) Distances: To measure the distance between two points, you have to set two points. The distance will be displayed on the line between the points.
   <li> b) Angles: Angles can be measured between two lines. For that you have to set three points. The angle will be displayed between the two lines. 
   <li> c) Path: Distances and angles along a path can be measured by setting at least two (for distance) or three (for angles) or more (for longer pathes) points. The distance and the angles for each part will be displayed next to the path.
 </ul>
 
 \image html MeasurementGUI.png Graphical User Interface of Measurement -->
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox.dox b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox.dox
index d42431ff8e..e1fb8f97b2 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox.dox
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox.dox
@@ -1,12 +1,12 @@
 /**
-\page org_measurementtoolbox The Measurement Toolbox Bundle
+\page org_mitk_gui_qt_measurementtoolbox The Measurement Toolbox Plugin
 
 \section QmitkmeasurementToolbox Manual 
 
-This bundle contains all views that provide measurement and statistics functionality.
+This plugin contains all views that provide measurement and statistics functionality.
 
 <ul>
-  <li> \subpage org_measurement
-  <li> \subpage org_imagestatistics
+  <li> \subpage org_mitk_views_measurement
+  <li> \subpage org_mitk_views_imagestatistics
 </ul>
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
index b74e5e01e0..b00f0c516a 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
@@ -1,718 +1,718 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #define MEASUREMENT_DEBUG MITK_DEBUG("QmitkMeasurementView") << __LINE__ << ": "
 
 #include "QmitkMeasurementView.h"
 
 #include <QtGui>
 
 #include <mitkVtkLayerController.h>
 #include <mitkWeakPointer.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarAngle.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarLine.h>
 #include <mitkPlanarCross.h>
 #include <mitkPlanarFourPointAngle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkILinkedRenderWindowPart.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <QmitkRenderWindow.h>
 
 struct QmitkPlanarFigureData
 {
   QmitkPlanarFigureData()
     : m_Figure(0), m_EndPlacementObserverTag(0), m_SelectObserverTag(0), m_StartInteractionObserverTag(0), m_EndInteractionObserverTag(0)
   {
   }
 
   mitk::PlanarFigure* m_Figure;
   unsigned int m_EndPlacementObserverTag;
   unsigned int m_SelectObserverTag;
   unsigned int m_StartInteractionObserverTag;
   unsigned int m_EndInteractionObserverTag;
 };
 
 struct QmitkMeasurementViewData
 {
   QmitkMeasurementViewData()
     : m_LineCounter(0), m_PathCounter(0), m_AngleCounter(0),
       m_FourPointAngleCounter(0), m_EllipseCounter(0),
       m_RectangleCounter(0), m_PolygonCounter(0), m_UnintializedPlanarFigure(false)
   {
   }
 
   // internal vars
   unsigned int m_LineCounter;
   unsigned int m_PathCounter;
   unsigned int m_AngleCounter;
   unsigned int m_FourPointAngleCounter;
   unsigned int m_EllipseCounter;
   unsigned int m_RectangleCounter;
   unsigned int m_PolygonCounter;
   QList<mitk::DataNode::Pointer> m_CurrentSelection;
   std::map<mitk::DataNode*, QmitkPlanarFigureData> m_DataNodeToPlanarFigureData;
   mitk::WeakPointer<mitk::DataNode> m_SelectedImageNode;
   bool m_UnintializedPlanarFigure;
 
   // WIDGETS
   QWidget* m_Parent;
   QLabel* m_SelectedImageLabel;
   QAction* m_DrawLine;
   QAction* m_DrawPath;
   QAction* m_DrawAngle;
   QAction* m_DrawFourPointAngle;
   QAction* m_DrawEllipse;
   QAction* m_DrawRectangle;
   QAction* m_DrawPolygon;
   QToolBar* m_DrawActionsToolBar;
   QActionGroup* m_DrawActionsGroup;
   QTextBrowser* m_SelectedPlanarFiguresText;
   QPushButton* m_CopyToClipboard;
   QGridLayout* m_Layout;
 };
 
 const std::string QmitkMeasurementView::VIEW_ID = "org.mitk.views.measurement";
 
 QmitkMeasurementView::QmitkMeasurementView()
 : d( new QmitkMeasurementViewData )
 {
 }
 QmitkMeasurementView::~QmitkMeasurementView()
 {
   this->RemoveAllInteractors();
   delete d;
 }
 void QmitkMeasurementView::CreateQtPartControl(QWidget* parent)
 {
   d->m_Parent = parent;
 
   // image label
   QLabel* selectedImageLabel = new QLabel("Reference Image: ");
   d->m_SelectedImageLabel = new QLabel;
   d->m_SelectedImageLabel->setStyleSheet("font-weight: bold;");
 
   d->m_DrawActionsToolBar = new QToolBar;
   d->m_DrawActionsGroup = new QActionGroup(this);
   d->m_DrawActionsGroup->setExclusive(true);
 
   //# add actions
   MEASUREMENT_DEBUG << "Draw Line";
   QAction* currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/line.png"), "Draw Line");
   currentAction->setCheckable(true);
   d->m_DrawLine = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Path";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/path.png"), "Draw Path");
   currentAction->setCheckable(true);
   d->m_DrawPath = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Angle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/angle.png"), "Draw Angle");
   currentAction->setCheckable(true);
   d->m_DrawAngle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Four Point Angle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/four-point-angle.png"), "Draw Four Point Angle");
   currentAction->setCheckable(true);
   d->m_DrawFourPointAngle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Circle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/circle.png"), "Draw Circle");
   currentAction->setCheckable(true);
   d->m_DrawEllipse = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Rectangle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/rectangle.png"), "Draw Rectangle");
   currentAction->setCheckable(true);
   d->m_DrawRectangle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Polygon";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/polygon.png"), "Draw Polygon");
   currentAction->setCheckable(true);
   d->m_DrawPolygon = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   // planar figure details text
   d->m_SelectedPlanarFiguresText = new QTextBrowser;
 
   // copy to clipboard button
   d->m_CopyToClipboard = new QPushButton("Copy to Clipboard");
 
   d->m_Layout = new QGridLayout;
   d->m_Layout->addWidget(selectedImageLabel, 0, 0, 1, 1);
   d->m_Layout->addWidget(d->m_SelectedImageLabel, 0, 1, 1, 1);
   d->m_Layout->addWidget(d->m_DrawActionsToolBar, 1, 0, 1, 2);
   d->m_Layout->addWidget(d->m_SelectedPlanarFiguresText, 2, 0, 1, 2);
   d->m_Layout->addWidget(d->m_CopyToClipboard, 3, 0, 1, 2);
 
   d->m_Parent->setLayout(d->m_Layout);
 
   // create connections
   this->CreateConnections();
 
   // readd interactors and observers
   this->AddAllInteractors();
 }
 void QmitkMeasurementView::CreateConnections()
 {
   QObject::connect( d->m_DrawLine, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawLineTriggered(bool) ) );
   QObject::connect( d->m_DrawPath, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawPathTriggered(bool) ) );
   QObject::connect( d->m_DrawAngle, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawAngleTriggered(bool) ) );
   QObject::connect( d->m_DrawFourPointAngle, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawFourPointAngleTriggered(bool) ) );
   QObject::connect( d->m_DrawEllipse, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawEllipseTriggered(bool) ) );
   QObject::connect( d->m_DrawRectangle, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawRectangleTriggered(bool) ) );
   QObject::connect( d->m_DrawPolygon, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawPolygonTriggered(bool) ) );
   QObject::connect( d->m_CopyToClipboard, SIGNAL( clicked(bool) )
     , this, SLOT( CopyToClipboard(bool) ) );
 }
 
 void QmitkMeasurementView::NodeAdded( const mitk::DataNode* node )
 {
   // add observer for selection in renderwindow
   mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
   bool isPositionMarker (false);
   node->GetBoolProperty("isContourMarker", isPositionMarker);
   if( figure && !isPositionMarker )
   {
     MEASUREMENT_DEBUG << "figure added. will add interactor if needed.";
     mitk::PlanarFigureInteractor::Pointer figureInteractor
         = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
 
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", nonConstNode);
     }
     else
     {
       // just to be sure that the interactor is not added twice
       mitk::GlobalInteraction::GetInstance()->RemoveInteractor(figureInteractor);
     }
 
     MEASUREMENT_DEBUG << "adding interactor to globalinteraction";
     mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
 
     MEASUREMENT_DEBUG << "will now add observers for planarfigure";
     QmitkPlanarFigureData data;
     data.m_Figure = figure;
 
     // add observer for event when figure has been placed
     typedef itk::SimpleMemberCommand< QmitkMeasurementView > SimpleCommandType;
     SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
     initializationCommand->SetCallbackFunction( this, &QmitkMeasurementView::PlanarFigureInitialized );
     data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
     // add observer for event when figure is picked (selected)
     typedef itk::MemberCommand< QmitkMeasurementView > MemberCommandType;
     MemberCommandType::Pointer selectCommand = MemberCommandType::New();
     selectCommand->SetCallbackFunction( this, &QmitkMeasurementView::PlanarFigureSelected );
     data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
 
     // add observer for event when interaction with figure starts
     SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
     startInteractionCommand->SetCallbackFunction( this, &QmitkMeasurementView::DisableCrosshairNavigation);
     data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
 
     // add observer for event when interaction with figure starts
     SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
     endInteractionCommand->SetCallbackFunction( this, &QmitkMeasurementView::EnableCrosshairNavigation);
     data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
 
     // adding to the map of tracked planarfigures
     d->m_DataNodeToPlanarFigureData[nonConstNode] = data;
   }
   this->CheckForTopMostVisibleImage();
 }
 
 void QmitkMeasurementView::NodeChanged(const mitk::DataNode* node)
 {
   // DETERMINE IF WE HAVE TO RENEW OUR DETAILS TEXT (ANY NODE CHANGED IN OUR SELECTION?)
   bool renewText = false;
   for( int i=0; i < d->m_CurrentSelection.size(); ++i )
   {
     if( node == d->m_CurrentSelection.at(i) )
     {
       renewText = true;
       break;
     }
   }
 
   if(renewText)
   {
     MEASUREMENT_DEBUG << "Selected nodes changed. Refreshing text.";
     this->UpdateMeasurementText();
   }
 
   this->CheckForTopMostVisibleImage();
 }
 
 void QmitkMeasurementView::CheckForTopMostVisibleImage(mitk::DataNode* _NodeToNeglect)
 {
   d->m_SelectedImageNode = this->DetectTopMostVisibleImage().GetPointer();
   if( d->m_SelectedImageNode.GetPointer() == _NodeToNeglect )
     d->m_SelectedImageNode = 0;
 
   if( d->m_SelectedImageNode.IsNotNull() && d->m_UnintializedPlanarFigure == false )
   {
     MEASUREMENT_DEBUG << "Reference image found";
     d->m_SelectedImageLabel->setText( QString::fromStdString( d->m_SelectedImageNode->GetName() ) );
     d->m_DrawActionsToolBar->setEnabled(true);
     MEASUREMENT_DEBUG << "Updating Measurement text";
   }
   else
   {
     MEASUREMENT_DEBUG << "No reference image available. Will disable actions for creating new planarfigures";
     if( d->m_UnintializedPlanarFigure == false )
       d->m_SelectedImageLabel->setText( "No visible image available." );
 
     d->m_DrawActionsToolBar->setEnabled(false);
   }
 }
 
 void QmitkMeasurementView::NodeRemoved(const mitk::DataNode* node)
 {
   MEASUREMENT_DEBUG << "node removed from data storage";
 
   mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
   std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it =
       d->m_DataNodeToPlanarFigureData.find(nonConstNode);
 
   if( it != d->m_DataNodeToPlanarFigureData.end() )
   {
     QmitkPlanarFigureData& data = it->second;
 
     MEASUREMENT_DEBUG << "removing figure interactor to globalinteraction";
     mitk::Interactor::Pointer oldInteractor = node->GetInteractor();
 //    if(oldInteractor.IsNotNull())
 //      mitk::GlobalInteraction::GetInstance()->RemoveInteractor(oldInteractor);
 
     // remove observers
     data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
     data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
     data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
     data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
 
     MEASUREMENT_DEBUG << "removing from the list of tracked planar figures";
     d->m_DataNodeToPlanarFigureData.erase( it );
   }
 
   this->CheckForTopMostVisibleImage(nonConstNode);
 }
 
 
 void QmitkMeasurementView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
 {
   MEASUREMENT_DEBUG << "planar figure " << object << " selected";
   std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it =
       d->m_DataNodeToPlanarFigureData.begin();
 
   d->m_CurrentSelection.clear();
   while( it != d->m_DataNodeToPlanarFigureData.end())
   {
     mitk::DataNode* node = it->first;
     QmitkPlanarFigureData& data = it->second;
 
     if( data.m_Figure == object )
     {
       MITK_DEBUG << "selected node found. enabling selection";
       node->SetSelected(true);
       d->m_CurrentSelection.push_back( node );
     }
     else
     {
       node->SetSelected(false);
     }
 
     ++it;
   }
   this->UpdateMeasurementText();
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkMeasurementView::PlanarFigureInitialized()
 {
   MEASUREMENT_DEBUG << "planar figure initialized";
   d->m_UnintializedPlanarFigure = false;
   d->m_DrawActionsToolBar->setEnabled(true);
 
   d->m_DrawLine->setChecked(false);
   d->m_DrawPath->setChecked(false);
   d->m_DrawAngle->setChecked(false);
   d->m_DrawFourPointAngle->setChecked(false);
   d->m_DrawEllipse->setChecked(false);
   d->m_DrawRectangle->setChecked(false);
   d->m_DrawPolygon->setChecked(false);
 }
 
 void QmitkMeasurementView::SetFocus()
 {
   d->m_SelectedImageLabel->setFocus();
 }
 
 void QmitkMeasurementView::OnSelectionChanged(berry::IWorkbenchPart::Pointer part,
                                               const QList<mitk::DataNode::Pointer> &nodes)
 {
   MEASUREMENT_DEBUG << "Determine the top most visible image";
   MEASUREMENT_DEBUG << "The PlanarFigure interactor will take the currently visible PlaneGeometry from the slice navigation controller";
 
   this->CheckForTopMostVisibleImage();
 
   MEASUREMENT_DEBUG << "refreshing selection and detailed text";
   d->m_CurrentSelection = nodes;
   this->UpdateMeasurementText();   
 
   for( int i=d->m_CurrentSelection.size()-1; i>= 0; --i)
   {
     mitk::DataNode* node = d->m_CurrentSelection.at(i);
 
     mitk::PlanarFigure* _PlanarFigure =
         _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     // the last selected planar figure
     if( _PlanarFigure )
     {
       mitk::ILinkedRenderWindowPart* linkedRenderWindow =
           dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
       if( linkedRenderWindow )
       {
         mitk::Point3D centerP = _PlanarFigure->GetGeometry()->GetOrigin();
-        linkedRenderWindow->GetRenderWindow("axial")->GetSliceNavigationController()->SelectSliceByPoint(centerP);
+        linkedRenderWindow->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SelectSliceByPoint(centerP);
       }
       break;
     }
   }
 
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkMeasurementView::ActionDrawLineTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarLine::Pointer figure = mitk::PlanarLine::New();
   QString qString = QString("Line%1").arg(++d->m_LineCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarLine initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawPathTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
   figure->ClosedOff();
   QString qString = QString("Path%1").arg(++d->m_PathCounter);
   mitk::DataNode::Pointer node = this->AddFigureToDataStorage(figure, qString);
   mitk::BoolProperty::Pointer closedProperty = mitk::BoolProperty::New( false );
   node->SetProperty("ClosedPlanarPolygon", closedProperty);
 
   MEASUREMENT_DEBUG << "PlanarPath initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawAngleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarAngle::Pointer figure = mitk::PlanarAngle::New();
   QString qString = QString("Angle%1").arg(++d->m_AngleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarAngle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawFourPointAngleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarFourPointAngle::Pointer figure =
     mitk::PlanarFourPointAngle::New();
   QString qString = QString("Four Point Angle%1").arg(++d->m_FourPointAngleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarFourPointAngle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawEllipseTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
   QString qString = QString("Circle%1").arg(++d->m_EllipseCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarCircle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawRectangleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarRectangle::Pointer figure = mitk::PlanarRectangle::New();
   QString qString = QString("Rectangle%1").arg(++d->m_RectangleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarRectangle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawPolygonTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
   figure->ClosedOn();
   QString qString = QString("Polygon%1").arg(++d->m_PolygonCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarPolygon initialized...";
 }
 
 void QmitkMeasurementView::CopyToClipboard( bool checked )
 {
   Q_UNUSED(checked)
 
   MEASUREMENT_DEBUG << "Copying current Text to clipboard...";
   QString clipboardText = d->m_SelectedPlanarFiguresText->toPlainText();
   QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 }
 
 mitk::DataNode::Pointer QmitkMeasurementView::AddFigureToDataStorage(
   mitk::PlanarFigure* figure, const QString& name)
 {
   // add as
   MEASUREMENT_DEBUG << "Adding new figure to datastorage...";
   if( d->m_SelectedImageNode.IsNull() )
   {
     MITK_ERROR << "No reference image available";
     return 0;
   }
 
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetName(name.toStdString());
   newNode->SetData(figure);
   // set as selected
   newNode->SetSelected( true );
   this->GetDataStorage()->Add(newNode, d->m_SelectedImageNode);
 
   // set all others in selection as deselected
   for( size_t i=0; i<d->m_CurrentSelection.size(); ++i)
     d->m_CurrentSelection.at(i)->SetSelected(false);
   d->m_CurrentSelection.clear();
   d->m_CurrentSelection.push_back( newNode );
   this->UpdateMeasurementText();
   this->DisableCrosshairNavigation();
   d->m_DrawActionsToolBar->setEnabled(false);
   d->m_UnintializedPlanarFigure = true;
   return newNode;
 }
 
 void QmitkMeasurementView::UpdateMeasurementText()
 {
   d->m_SelectedPlanarFiguresText->clear();
 
   QString infoText;
   QString plainInfoText;
   unsigned int j = 1;
   mitk::PlanarFigure* _PlanarFigure = 0;
   mitk::PlanarAngle* planarAngle = 0;
   mitk::PlanarFourPointAngle* planarFourPointAngle = 0;
   mitk::DataNode::Pointer node = 0;
 
   for (unsigned int i=0; i<d->m_CurrentSelection.size(); ++i, ++j)
   {
     plainInfoText.clear();
     node = d->m_CurrentSelection.at(i);
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     if( !_PlanarFigure )
       continue;
 
     if(j>1)
       infoText.append("<br />");
 
     infoText.append(QString("<b>%1</b><hr />").arg(QString::fromStdString(
       node->GetName())));
     plainInfoText.append(QString("%1").arg(QString::fromStdString(
       node->GetName())));
 
     planarAngle = dynamic_cast<mitk::PlanarAngle*> (_PlanarFigure);
     if(!planarAngle)
     {
       planarFourPointAngle = dynamic_cast<mitk::PlanarFourPointAngle*> (_PlanarFigure);
     }
 
     double featureQuantity = 0.0;
     for (unsigned int k = 0; k < _PlanarFigure->GetNumberOfFeatures(); ++k)
     {
       if ( !_PlanarFigure->IsFeatureActive( k ) ) continue;
 
       featureQuantity = _PlanarFigure->GetQuantity(k);
       if ((planarAngle && k == planarAngle->FEATURE_ID_ANGLE)
         || (planarFourPointAngle && k == planarFourPointAngle->FEATURE_ID_ANGLE))
         featureQuantity = featureQuantity * 180 / vnl_math::pi;
 
       infoText.append(
         QString("<i>%1</i>: %2 %3") .arg(QString(
         _PlanarFigure->GetFeatureName(k))) .arg(featureQuantity, 0, 'f',
         2) .arg(QString(_PlanarFigure->GetFeatureUnit(k))));
 
       plainInfoText.append(
         QString("\n%1: %2 %3") .arg(QString(_PlanarFigure->GetFeatureName(k))) .arg(
         featureQuantity, 0, 'f', 2) .arg(QString(
         _PlanarFigure->GetFeatureUnit(k))));
 
       if(k+1 != _PlanarFigure->GetNumberOfFeatures())
         infoText.append("<br />");
     }
 
     if (j != d->m_CurrentSelection.size())
       infoText.append("<br />");    
   }
 
   d->m_SelectedPlanarFiguresText->setHtml(infoText);
 }
 
 void QmitkMeasurementView::AddAllInteractors()
 {
   MEASUREMENT_DEBUG << "Adding interactors to all planar figures";
 
   mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
   const mitk::DataNode* node = 0;
 
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
     ; it++)
   {
     node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
     this->NodeAdded( node );
   }
 }
 
 void QmitkMeasurementView::RemoveAllInteractors()
 {
   MEASUREMENT_DEBUG << "Removing interactors and observers from all planar figures";
 
   mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
   const mitk::DataNode* node = 0;
 
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
     ; it++)
   {
     node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
     this->NodeRemoved( node );
   }
 }
 
 mitk::DataNode::Pointer QmitkMeasurementView::DetectTopMostVisibleImage()
 {
   // get all images from the data storage which are not a segmentation
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateNot::Pointer isNotBinary = mitk::NodePredicateNot::New( isBinary );
   mitk::NodePredicateAnd::Pointer isNormalImage = mitk::NodePredicateAnd::New( isImage, isNotBinary );
 
   mitk::DataStorage::SetOfObjects::ConstPointer Images
       = this->GetDataStorage()->GetSubset( isNormalImage );
 
 
   mitk::DataNode::Pointer currentNode;
   int maxLayer = itk::NumericTraits<int>::min();
 
   // iterate over selection
   for (mitk::DataStorage::SetOfObjects::ConstIterator sofIt = Images->Begin(); sofIt != Images->End(); ++sofIt)
   {
     mitk::DataNode::Pointer node = sofIt->Value();
     if ( node.IsNull() )
       continue;
     if (node->IsVisible(NULL) == false)
       continue;
     int layer = 0;
     node->GetIntProperty("layer", layer);
     if ( layer < maxLayer )
     {
       continue;
     }
     else
     {
       maxLayer = layer;
       currentNode = node;
     }
   }
 
   return currentNode;
 }
 
 void QmitkMeasurementView::EnableCrosshairNavigation()
 {
   MEASUREMENT_DEBUG << "EnableCrosshairNavigation";
 
   // enable the crosshair navigation
   if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
       dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
   {
     MEASUREMENT_DEBUG << "enabling linked navigation";
     //linkedRenderWindow->EnableLinkedNavigation(true);
     linkedRenderWindow->EnableSlicingPlanes(true);
   }
 }
 
 void QmitkMeasurementView::DisableCrosshairNavigation()
 {
   MEASUREMENT_DEBUG << "DisableCrosshairNavigation";
 
   // disable the crosshair navigation during the drawing
   if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
       dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
   {
     MEASUREMENT_DEBUG << "disabling linked navigation";
     //linkedRenderWindow->EnableLinkedNavigation(false);
     linkedRenderWindow->EnableSlicingPlanes(false);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.meshdecimation/documentation/Manual/meshdecimation-manual.dox b/Plugins/org.mitk.gui.qt.meshdecimation/documentation/Manual/meshdecimation-manual.dox
index 2403ecd237..5cdc4fafa6 100644
--- a/Plugins/org.mitk.gui.qt.meshdecimation/documentation/Manual/meshdecimation-manual.dox
+++ b/Plugins/org.mitk.gui.qt.meshdecimation/documentation/Manual/meshdecimation-manual.dox
@@ -1,33 +1,33 @@
 /**
 
-\page org_meshdecimation The Mesh Decimation Module
+\page org_mitk_views_meshdecimation The Mesh Decimation Plugin
 
-\image html meshdecimation.png "Icon of the Module"
+\image html meshdecimation.png "Icon of the Plugin"
 
 Available sections:
   - \ref meshdecimationOverview 
   - \ref meshdecimationFeatures 
   - \ref meshdecimationUsage 
 
 \section meshdecimationOverview Overview
 
 MeshDecimation is a user friendly tool to decimate a MITK surface.
 
 \section meshdecimationFeatures Features
 
-The module offers two basic procedures to decimate surfaces: One that reduces a surface with a possible loss of topology (quality), but with a garuanteed reduction rate that is expressed in terms of percent of the original mesh. The other variant preserves the topology and stops decimating when it detects heavy topological changes.   
+The view offers two basic procedures to decimate surfaces: One that reduces a surface with a possible loss of topology (quality), but with a garuanteed reduction rate that is expressed in terms of percent of the original mesh. The other variant preserves the topology and stops decimating when it detects heavy topological changes.   
  
 \section meshdecimationUsage Usage
 
-\image html meshdecimation-ui.png "The user interface of the Mesh Decimation Module"
+\image html meshdecimation-ui.png "The user interface of the Mesh Decimation View"
 
-The usage of the module should be straightforward, as shown in the screenshot. To decimate a MITK surface do the following:
+The usage of the view should be straightforward, as shown in the screenshot. To decimate a MITK surface do the following:
 - Select a surface in the datamanager
 - Enter a target reduction rate
 - Select a decimation method (\ref meshdecimationFeatures)
 - Press the "Decimate" button
 - Repeat the process until you are satisfied with the decimation
 - Save the surface to disk
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkMovieMakerUserManual.dox b/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkMovieMakerUserManual.dox
index 9117d97603..602f4243c5 100644
--- a/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkMovieMakerUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkMovieMakerUserManual.dox
@@ -1,45 +1,45 @@
 /**
 
-\page org_moviemaker The Movie Maker Module
+\page org_mitk_views_moviemaker The Movie Maker View
 
-\image html icon.png "Icon of the Module"
+\image html icon.png "Icon of the View"
 
 Available sections:
   - \ref QmitkMovieMakerUserManualOverview 
   - \ref QmitkMovieMakerUserManualFeatures 
   - \ref QmitkMovieMakerUserManualUsage 
 
 \section QmitkMovieMakerUserManualOverview Overview
 
 MovieMaker is a functionality for easily creating fancy movies from scenes displayed in MITK widgets.
 It is also possible to slide through your data, automatically rotate 3D scenes and take screenshots of widgets.
 
 \section QmitkMovieMakerUserManualFeatures Features
 
  The Movie Maker allows you to create movies and screenshots from within MITK. It can automatically scroll thorugh timesteps and slices while recording a movie. This way, you can record visualizations like a beating heart or a rotating skull.
  
 \section QmitkMovieMakerUserManualUsage Usage
 
 \image html QmitkMovieMakerControlArea.png "A view of the command area of QmitkMovieMaker"
 
 \subsection QmitkMovieMakerUserManualWindowSelection Window selection
 With the first two drop down boxes, you can choose which window you want to step through and which window you want to record in. Left clicking inside a window will set both drop down boxes to that window, but you can choose different windows for stepping and recording.
 
 The first drop down box defines the window along which slices will be stepped through if stepping is set to spatial (see below). The second denotes the window from which the content will be recorded.
 
 \subsection QmitkMovieMakerUserManualRecordingOptions Recording Options
 
 The slider can be used to step through the slices manually while not recording. Start and stop control a preview of what a video would look like.
 
 The buttons in the bottom part of this section can be used to create movies (windows only) or screenshots. Clicking opens a file %dialog where a name can be selected. After confirmation, a screenshot or movie is created according to the playing options.
 
 \subsection QmitkMovieMakerUserManualPlayingOptions Playing Options
 
 The first section controls whether the movie steps through slices (if a 2D view is selected), rotate the shown scene (if a 3D view is selected), or step through time steps (if set to temporal and a time resolved dataset is selected). If set to combined, a combination of both above options is used, with their speed relation set via the S/T Relation Spinbox.
 
 In the second section the direction of stepping can be set. Options are: Forward, backward and Ping-Pong, which is back-and-forth.The stepping speed can be set via the spinbox(total time in seconds).
 
 Although stepping speed is a total time in sec., this can not always be achieved. As a minimal frame rate of 25 fps is assumed to provide smooth movies, a dataset with only 25 slices will always be stepped through in 1 sec or faster.
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkScreenshotMakerManual.dox b/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkScreenshotMakerManual.dox
similarity index 86%
rename from Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkScreenshotMakerManual.dox
rename to Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkScreenshotMakerManual.dox
index 9f2e96a063..688b614a55 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkScreenshotMakerManual.dox
+++ b/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkScreenshotMakerManual.dox
@@ -1,19 +1,19 @@
 /**
-\page screenshot_maker The Screenshot Maker
+\page org_mitk_views_screenshotmaker The Screenshot Maker
 
-This module provides the functionality to create and save screenshots of the data.
+This view provides the functionality to create and save screenshots of the data.
 
 Available sections:
   - \ref QmitkScreenshotMakerUserManualUse
 
 \image html screenshot_maker_interface.png The Screenshot Maker User Interface
 
 \section QmitkScreenshotMakerUserManualUse Usage
 
 The first section offers the option of creating a screenshot of the last activated render window (thus the one, which was last clicked into). Upon clicking the button, the Screenshot Maker asks for a filename in which the screenshot is to be stored. The multiplanar Screenshot button asks for a folder, where screenshots of the three 2D views will be stored with default names.
 
 The high resolution screenshot section works the same as the simple screenshot section, aside from the fact, that the user can choose a magnification factor.
 
 In the option section one can rotate the camera in the 3D view by using the buttons. Furthermore one can choose the background colour for the screenshots, default is black.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteractionUserManual.dox b/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteractionUserManual.dox
index adbf30cb2d..5151fea9ac 100644
--- a/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteractionUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteractionUserManual.dox
@@ -1,38 +1,38 @@
 /**
-\page org_pointsetinteraction The Point Set Interaction Module
+\page org_mitk_views_pointsetinteraction The Point Set Interaction View
 
-\image html pointset_interaction.png "Icon of the Module"
+\image html pointset_interaction.png "Icon of the View"
 
 Available sections:
   - \ref QmitkPointSetInteractionUserManualOverview 
   - \ref QmitkPointSetInteractionUserManualDetails 
 
 \section QmitkPointSetInteractionUserManualOverview Overview
 
 This functionality allows you to define multiple sets of points, to fill them with points and to save them in so called PointSets.
 
 \image html QmitkPointSetInteraction.png "MITK with the QmitkPointSetInteraction functionality"
 
 This document will tell you how to use this functionality, but it is assumed that you already know how to navigate through the slices of an image using the
 four window view. Please read the application manual for more information.
 
 \section QmitkPointSetInteractionUserManualDetails Details
 
 First of all you have to select a PointSet to use this functionality. Therefore, you have to select the point set in the data manager. If there are currently no point sets in the data tree, you have to first add a new point set to the data tree. This is done by clicking the "Add pointset..." 
 button.
 
 \image html AddPointSet.png "The Add pointset... dialog"
 
 In the pop-up dialog, you have to specify a name for the new point set. This is also the node for the new data tree item.
 
 \image html CurrentPointSetArea.png "The Current pointset area"
 
 The "Current pointset" area contains a list of points. Within this area, all points for the current point set node are listed. To set points you have to toggle the "Set Points"  button, the leftmost of the four buttons on the bottom of the view. Points can be defined by performing a left mouse button click while holding the "Shift"-key pressed in the four window view. 
 
 To erase all points from the list press the next button. The user is prompted to confirm the decision. If you want to delete only a single point, left click on it in the list and then press delete on your keyboard. 
 
 With the third button, a previously saved point set can be loaded and all of its points are shown in the list and the four window view. The user is prompted to select the file to be loaded. The file extension is ".mps". On the right of this button is the save button. With this function the entire point set can be saved to the harddrive. The user is prompted to select a filename. Pointsets are saved in XML fileformat but have to have a ".mps" file extension. 
 
 You can select points in the render window, if the "Set Points" button is toggled, with a left mouse button click on them. If you keep the mouse button pressed, you can move the points by moving the mouse and then releasing the mouse button. With the delete key you can remove the selected points. 
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkDeformableRegistrationUserManual.dox b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkDeformableRegistrationUserManual.dox
index 10a3d0cdb5..fd11c761dc 100644
--- a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkDeformableRegistrationUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkDeformableRegistrationUserManual.dox
@@ -1,52 +1,52 @@
 /**
-\page org_deform_registration The Deformable Image Registration Module
+\page org_mitk_views_deformableregistration The Deformable Image Registration View
 
 Available sections:
   - \ref DeformableRegistrationUserManualOverview
   - \ref DeformableRegistrationUserManualDetails
 
 \section DeformableRegistrationUserManualOverview Overview
 
-This module allows you to register 2D as well as 3D images in a deformable manner. Register means to align two images, so that they become as similar as
+This view allows you to register 2D as well as 3D images in a deformable manner. Register means to align two images, so that they become as similar as
 possible. Registration results will directly be applied to the Moving Image.
 
-\image html QmitkDeformableRegistration_small.png "MITK with the DeformableRegistration module"
+\image html QmitkDeformableRegistration_small.png "MITK with the DeformableRegistration view"
 
-This document will tell you how to use this module, but it is assumed that you already know how to navigate through the slices of an image using the
+This document will tell you how to use this view, but it is assumed that you already know how to navigate through the slices of an image using the
 multi-widget.
 
 \section DeformableRegistrationUserManualDetails Details
 
 First of all you have to open the data sets which you want to register and select them in the Data Manager. You have to select exactly 2 images for registration. The image which was selected 
 first will become the fixed image, the other one the moving image. The two selected images will remain for registration until exactly two images were selected in the Data Manager again. While 
-there aren't two images for registration a message is viewed on top of the module saying that registration needs two images. If two images are selected the message disappears and the interaction 
+there aren't two images for registration a message is viewed on top of the view saying that registration needs two images. If two images are selected the message disappears and the interaction 
 areas for the fixed and moving data appears. On default only the fixed and moving image are shown in the render windows. If you want to have other images visible you have to set the visibility 
 via the Data Manager. Also if you want to perform a reinit on a specific node or a global reinit for all nodes you have to use the Data Manager.
 
 \image html ImageSelectionDeformable.png "The Image area"
 
 The upper area is the "Image" area, where the selected images are shown. It is used for changing the colour of the images between grey values and red/green as well as for changing the opacity of the moving image.
 To do so, just use the "Moving Image Opacity:" slider. In the "Show Images Red/Green" you can switch the color from both datasets. If you check the box, the fixed dataset will be displayed in redvalues and the
 moving dataset in greenvalues to improve visibility of differences in the datasets. If you uncheck the "Show Images Red/Green" checkbox, 
 both datasets will be displayed in greyvalues.
 
 \image html RegistrationDeformable.png "The Registration area for Demons based registration"
 
 In the "Registration" area you have the choice between different Demonsbased deformable registration algorithms. There are available:
 
 \li <b>Demons Registration</b>
 
 \li <b>Symmetric Forces Demons Registration</b>
 
 For both methods you have to define the same set of parameters. First you have to decide whether you want to perform a histogram matching. This can be done by selecting "Use Histogram Matching". 
 When it is selected the corresponding parameters are enabled and have to be set. These are the "Number of Histogram Levels", "Number of Match Points" and whether to use a "Threshold at Mean 
 Intensity".
 
 For the registration method itself you have to specify the "Number of Iterations" and the "Standard Deviation" within the "Demons Registration" area.
 
 If all this is done, you can perform the registration by clicking the "Calculate Transformation" button. Finally, you will be asked where you want the result image and the resulting deformation field 
 to be saved. Therefore you have to select the folder and enter a filename.
 
 The results will be added in the DataStorage and can be saved in the Data Manager.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkPointBasedRegistrationUserManual.dox b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkPointBasedRegistrationUserManual.dox
index c10a09068a..cfc7e3be68 100644
--- a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkPointBasedRegistrationUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkPointBasedRegistrationUserManual.dox
@@ -1,106 +1,106 @@
 /**
-\page org_pointbased_reg  The Point Based Registration Module
+\page org_mitk_views_pointbasedregistration  The Point Based Registration View
 
-\image html pointBasedIcon.png "Icon of the Module"
+\image html pointBasedIcon.png "Icon of the View"
 
 Available sections:
   - \ref PointBasedRegistrationUserManualOverview 
   - \ref PointBasedRegistrationUserManualDetails 
 
 \section PointBasedRegistrationUserManualOverview Overview
 
-This module allows you to register two datasets in a rigid and deformable manner via corresponding 
+This view allows you to register two datasets in a rigid and deformable manner via corresponding 
 PointSets. Register means to align two datasets, so that they become as similar as possible. 
 Therefore you have to set corresponding points in both datasets, which will be matched. The movement, which has to be 
 performed on the points to align them, will be performed on the moving data as well. The result is shown in the multi-widget. 
 
-\image html PointBasedRegistration_small.png "MITK with the PointBasedRegistration module"
+\image html PointBasedRegistration_small.png "MITK with the PointBasedRegistration view"
 
-This document will tell you how to use this module, but it is assumed that you already know how to navigate through 
+This document will tell you how to use this view, but it is assumed that you already know how to navigate through 
 the slices of a dataset using the multi-widget.
 
 \section PointBasedRegistrationUserManualDetails Details
 
 First of all you have to open the data sets which you want to register and select them in the Data Manager. You have to select exactly 2 images for registration. The image which was selected 
 first will become the fixed image, the other one the moving image. The two selected images will remain for registration until exactly two images were selected in the Data Manager again. While 
-there aren't two images for registration a message is viewed on top of the module saying that registration needs two images. If two images are selected the message disappears and the interaction 
+there aren't two images for registration a message is viewed on top of the view saying that registration needs two images. If two images are selected the message disappears and the interaction 
 areas for the fixed and moving data appears. The upper area is for interaction with the fixed data. Beneath this area is the interaction area for the moving data. On default only the fixed and 
 moving image with their corresponding pointsets are shown in the render windows. If you want to have other images visible you have to set the visibility via the Data Manager. Also if you want to 
 perform a reinit on a specific node or a global reinit for all nodes you have to use the Data Manager.
 
 \image html FixedDataPointBased.png "The Fixed Data area"
 
 The "Fixed Data" area contains a QmitkPointListWidget. Within this widget, all points for the fixed data are listed. The label above this list shows the number of points that are already set. 
 To set points you have to toggle the "Set Points"  button, the leftmost under the QmitkPointListWidget. The views in the QmitkStdMultiWidget were reinitialized to the fixed data. Points can 
 be defined by performing a left click while holding the "Shift"-key pressed in the QmitkStdMultiWidget. You can remove the interactor which listens for left clicks while 
 holding the "Shift"-key pressed by detoggle the "Set Points" button. The next button, "Clear Point Set", is for deleting all specified points from this dataset. The user is prompted to confirm 
 the decision. With the most right button, a previously saved point set can be loaded and all of its points are shown in the QmitkPointListWidget and in the QmitkStdMultiWidget. The user is prompted 
 to select the file to be loaded. The file extension is ".mps". On the left of this button is the save button. With this function all points specified for this dataset and shown in the 
 QmitkPointListWidget are saved to harddisk. The user is prompted to select a filename. Pointsets were saved in XML fileformat but have to have a ".mps" file extension. You can select landmarks 
 in the render window with a left mouse button click on them. If you keep the mouse button pressed you can move the landmark to an other position by moving the mouse and then release the mouse 
 button. With the delete key you can remove the selected landmarks. You can also select landmarks by a double click on a landmark within the QmitkPointListWidget. Using the "Up-Arrow"-button or
 the "F2" key you can easily move a landmark upwards and bring it further downwards by pressing "F3" or using the "Down-Arrow"-button. Thus the landmark number can be changed. 
 The QmitkStdMultiWidget changes its view to show the position of the landmark.
 
 \image html MovingDataPointBased.png "The Moving Data area"
 
 The "Moving Data" area contains a QmitkPointListWidget. Within this widget, all points for the moving data are listed. The label above this list shows the number of points that are already set. 
 To set points you have to toggle the "Set Points"  button, the leftmost under the QmitkPointListWidget. The views in the QmitkStdMultiWidget were reinitialized to the moving data. With the 
 "Opacity:" slider you can change the opacity of the moving dataset. If the slider is leftmost the moving dataset is totally transparent, whereas if it is rightmost the moving dataset is totally 
 opaque. Points can be defined by performing a left click while holding the "Shift"-key pressed in the QmitkStdMultiWidget. You can remove the interactor which listens for left 
 mousebutton click while holding the "Shift"-key pressed by detoggle the "Set Points" button. The next button, "Clear Point Set", is for deleting all specified points from this dataset. The user 
 is prompted to confirm the decision. With the button on your right hand side, a previously saved point set can be loaded and all of its points are shown in the QmitkPointListWidget and in the QmitkStdMultiWidget. 
 The user is prompted to select the file to be loaded. The file extension is ".mps". On the left of this button is the save button. With this function all points specified for this dataset and 
 shown in the QmitkPointListWidget are saved to harddisk. The user is prompted to select a filename. Pointsets were saved in XML fileformat but have to have a ".mps" file extension. You can 
 select landmarks in the render window with a left click on them. If you keep the mouse button pressed you can move the landmark to an other position by moving the mouse and then 
 release the mouse button. With the delete key you can remove the selected landmarks. You can also select landmarks by a double click on a landmark within the QmitkPointListWidget. Using the "Up-Arrow"-button or
 the "F2" key you can easily move a landmark upwards and bring it further downwards by pressing "F3" or using the "Down-Arrow"-button. Thus the landmark number can be changed.The QmitkStdMultiWidget changes its view to show the position of the 
 landmark.
 
 \image html DisplayOptionsPointBased.png "The Display Options area"
 
 In this area you can find the "Show Images Red/Green" checkbox. Here you can switch the color from both datasets. If you check the box, the fixed dataset will be 
 displayed in redvalues and the moving dataset in greenvalues to improve visibility of differences in the datasets. If you uncheck the "Show Images Red/Green" checkbox, both datasets will be 
 displayed in greyvalues.
 
 Before you perform your transformation it is useful to see both images again. Therefore detoggle the "Set Points" button for the fixed data as well as for the moving data.
 
 \image html RegistrationPointBased.png "The Registration area"
 
 The functions concerning the registration are displayed in the "Registration" area. It not only contains the registration method selection and the registration itself but also offers the possibility
 to save, undo or redo the results. Furthermore a display is implemented, which shows you how good the landmarks correspond.
 Those features will be explained in following paragraphs.
 
 Using the "Method"-selector, you can pick one of those transformations: <b>Rigid</b>, <b>Similarity</b>, <b>Affine</b> and <b>LandmarkWarping</b>.
 Depending on which one you chose, an additional specifier, "Use ICP" can be set, which leads to the following possibilities for registration: 
 
 \li <b>Rigid with ICP</b> means only translation and rotation. The order of your landmarks will not be taken into account. E. g. landmark one in the fixed data can be mapped on landmark three in the moving data. You 
 have to set at least one landmark in each dataset to enable the Register button which performs the transformation.
 
 \li <b>Similarity with ICP</b> means only translation, scaling and rotation. The order of your landmarks will not be taken into account. E. g. landmark one in the fixed data can be mapped on landmark three in the 
 moving data. You have to set at least one landmark in each dataset to enable the Register button which performs the transformation.
 
 \li <b>Affine with ICP</b> means only translation, scaling, rotation and shearing. The order of your landmarks will not be taken into account. E. g. landmark one in the fixed data can be mapped on landmark three in 
 the moving data. You have to set at least one landmark in each dataset to enable the Register button which performs the transformation.
 
 \li <b>Rigid</b> means only translation and rotation. The order of your landmarks will be taken into account. E. g. landmark one in the fixed data will be mapped on landmark one in the moving data. You have to set 
 at least one landmark and the same number of landmarks in each dataset to enable the Register button which performs the transformation.
 
 \li <b>Similarity</b> means only translation, scaling and rotation. The order of your landmarks will be taken into account. E. g. landmark one in the fixed data will be mapped on landmark one in the moving data. 
 You have to set at least one landmark and the same number of landmarks in each dataset to enable the Register button which performs the transformation.
 
 \li <b>Affine</b> means only translation, scaling, rotation and shearing. The order of your landmarks will be taken into account. E. g. landmark one in the fixed data will be mapped on landmark one in the moving 
 data. You have to set at least one landmark and the same number of landmarks in each dataset to enable the Register button which performs the transformation.
 
 \li <b>LandmarkWarping</b> means a freeform deformation of the moving image, so that afterwards the landmarks are exactly aligned. The order of your landmarks will be taken into account. 
 E. g. landmark one in the fixed data will be mapped on landmark one in the moving data. You have to set at least one landmark and the same number of landmarks in each dataset to enable the 
 Register button which performs the transformation.
 
 The root mean squares difference between the landmarks will be displayed as number, so that you can check how good the landmarks correspond.
 
 The "Undo Transformation" button becomes enabled after performing a transformation and allows you to undo it. After doing this, the "Redo Transformation" button
 is enabled and lets you redo, the just undone transformation(no calculation  needed)
 
 Saving of the transformed image can be done via the Data Manager.
  
 */
diff --git a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkRigidRegistrationUserManual.dox b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkRigidRegistrationUserManual.dox
index 77afc8ed3e..3d0c69fe8a 100644
--- a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkRigidRegistrationUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkRigidRegistrationUserManual.dox
@@ -1,214 +1,214 @@
 /**
-\page org_rigid_regis The Rigid Registration Module
+\page org_mitk_views_rigidregistration The Rigid Registration View
 
-\image html rigidRegistrationIcon.png "Icon of the Module"
+\image html rigidRegistrationIcon.png "Icon of the View"
 
 Available sections:
   - \ref QmitkRigidRegistrationUserManualOverview 
   - \ref QmitkRigidRegistrationUserManualIssues 
   - \ref QmitkRigidRegistrationUserManualDetails
   - \ref QmitkRigidRegistrationUserManualReferences 
 
 \section QmitkRigidRegistrationUserManualOverview Overview
 
-This module allows you to register 2D as well as 3D images in a rigid manner. If the Moving Image is an image with multiple timesteps you can select one timestep for registration. 
+This view allows you to register 2D as well as 3D images in a rigid manner. If the Moving Image is an image with multiple timesteps you can select one timestep for registration. 
 Register means to align two images, so that they become as similar as possible. Therefore you can select from different transforms, metrics and optimizers. Registration results will 
 directly be applied to the Moving Image. Also binary images as image masks can be used to restrict the metric evaluation only to the masked area.
 
-\image html RigidRegistration_small.png "MITK with the QmitkRigidRegistration module"
+\image html RigidRegistration_small.png "MITK with the QmitkRigidRegistration view"
 
-This document will tell you how to use this module, but it is assumed that you already know how to navigate through the slices of an image using the
+This document will tell you how to use this view, but it is assumed that you already know how to navigate through the slices of an image using the
 multi-widget.
 
 \section QmitkRigidRegistrationUserManualIssues Known Issues
 
 Depending on your system the registration can fail to allocate memory for calculating the gradient image for registration. In this case you can try to select another optimizer which is not based 
 on a gradient image and uncheck the checkbox for "Compute Gradient".
 
 \section QmitkRigidRegistrationUserManualDetails Details
 
 First of all you have to open the data sets which you want to register and select them in the Data Manager. You have to select exactly 2 images for registration. The image which was selected 
 first will become the fixed image, the other one the moving image. The two selected images will remain for registration until exactly two images were selected in the Data Manager again. 
 
 \image html ImageArea.png "The Image area"
 
-While there aren't two images for registration a message is viewed on top of the module saying that registration needs two images. If two images are selected the message disappears and the 
+While there aren't two images for registration a message is viewed on top of the view saying that registration needs two images. If two images are selected the message disappears and the 
 interaction areas for the fixed and moving data appears. If both selected images have a binary image as childnode a selection box appears which allows, when checked, to use the binary images as 
 image mask to restrict the registration on this certain area. If an image has more than one binary image as child, the upper one from the DataManager list is used. If the Moving Image is a 
 dynamic images with several timesteps a slider appears to select a specific timestep for registration. 
 
 On default only the fixed and moving image are shown in the render windows. If you want to have other images visible you have to set the visibility 
 via the Data Manager. Also if you want to perform a reinit on a specific node or a global reinit for all nodes you have to use the Data Manager.
 
 The colour of the images can be changed between grey values and red/green and the opacity of the moving image can be changed.
 With the "Moving Image Opacity:" slider you can change the opacity of the moving dataset. In the "Show Images Red/Green" you can switch the color from both datasets. If you check the box, 
 the fixed dataset will be displayed in red-values and the moving dataset in green-values to improve visibility of differences in the datasets. If you uncheck the "Show Images Red/Green" checkbox, 
 both datasets will be displayed in grey-values.
 
 \image html RegistrationArea.png "The Registration area"
 
 In the "Register" area you can start the registration by clicking the "Calculate Transform" button. The optimizer value for every iteration step is diplayed as LCD number next to the 
 "Optimizer Value:" label. Many of the registration methods can be canceled during their iteration steps by clicking the "Stop Optimization" button. During the calculation, a progress bar 
 indicates the progress of the registration process. The render widgets are updated for every single iteration step, so that the user has the chance to supervise how good the registration 
 process works with the selected methods and parameters. If the registration process does not lead to a sufficient result, it is possible to undo the transformation and restart the registration 
 process with some changes in parameters. The differences in transformation due to the changed parameters can be seen in every iteration step and help the user understand the parameters.
 Also the optimizer value is updated for every single iteration step and shown in the GUI. The optimizer value is an indicator for the misalignment between the two images. The real time 
 visualization of the registration as well as the optimizer value provides the user with information to trace the improvement through the optimization process.
 The "Undo Transformation" button becomes enabled when you have performed an transformation and you can undo the performed transformations. The "Redo Transformation" button becomes enabled when 
 you have performed an undo to redo the transformation without to recalculate it.
 
 \image html ManualRegistrationArea.png "The Manual Registration area"
 
 In the "Manual Registration" area, shown by checking the checkbox Manual Registration, you can manually allign the images by moving sliders for translation and scaling in x-, y- and z-axis as 
 well as for rotation around the x-, y- and z-Axis. Additionally you can automatically allign the image centers with the button "Automatic Allign Image Centers".
 
 \image html Tab2.png "The Advanced Mode tab"
 
 In the "Advanced Mode" tab you can choose a transform, a metric, an optimizer and an interpolator and you have to set the corresponding parameters to specify the registration 
 method you want to perform. With the topmost button you can also load testpresets. These presets contain all parametersets which were saved using the "Save as Testpreset" button. The "Save as 
 Preset" button makes the preset available from the "Automatic Registration" tab. This button should be used when a preset is not intended for finding good parameters anymore but can be used as 
 standard preset.
 
 To show the current transform and its parameters for the registration process, the Transform checkbox has to be checked. Currently, the following transforms are implemented 
 (for detailed information see [1] and [2]):
 
 \li <b>Translation:</b> Transformation by a simple translation for every dimension.
 
 \li <b>Scale:</b> Transformation by a certain scale factor for each dimension.
 
 \li <b>ScaleLogarithmic:</b> Transformation by a certain scale factor for each dimension. The parameter factors are passed as logarithms.
 
 \li <b>Affine:</b> Represents an affine transform composed of rotation, scaling, shearing and translation.
 
 \li <b>FixedCenterOfRotationAffine:</b> Represents an affine transform composed of rotation around a user provided center, scaling, shearing and translation.
 
 \li <b>Rigid3D:</b> Represents a 3D rotation followed by a 3D translation.
 
 \li <b>Euler3D:</b> Represents a rigid rotation in 3D space. That is, a rotation followed by a 3D translation.
 
 \li <b>CenteredEuler3D:</b> Represents a rigid rotation in 3D space around a user provided center. That is, a rotation followed by a 3D translation.
 
 \li <b>QuaternionRigid:</b> Represents a 3D rotation and a 3D translation. The rotation is specified as a quaternion.
 
 \li <b>Versor:</b> Represents a 3D rotation. The rotation is specified by a versor or unit quaternion.
 
 \li <b>VersorRigid3D:</b> Represents a 3D rotation and a 3D translation. The rotation is specified by a versor or unit quaternion.
 
 \li <b>ScaleSkewVersor3D:</b> Represents a 3D translation, scaling, shearing and rotation. The rotation is specified by a versor or unit quaternion.
 
 \li <b>Similarity3D:</b> Represents a 3D rotation, a 3D translation and homogeneous scaling.
 
 \li <b>Rigid2D:</b> Represents a 2D rotation followed by a 2D translation.
 
 \li <b>CenteredRigid2D:</b> Represents a 2D rotation around a user provided center followed by a 2D translation.
 
 \li <b>Euler2D:</b> Represents a 2D rotation and a 2D translation.
 
 \li <b>Similarity2D:</b> Represents a 2D rotation, homogeneous scaling and a 2D translation.
 
 \li <b>CenteredSimilarity2D:</b> Represents a 2D rotation around a user provided center, homogeneous scaling and a 2D translation.
 
 The desired transform can be chosen from a combo box. All parameters defining the selected transform have to be specified within the line edits and checkboxes underneath the transform combo box.
 To show the current metric and its parameters for the registration process, the Metric checkbox has to be checked. Currently, the following metrics are implemented 
 (for detailed information see [1] and [2]):
 
 \li <b>MeanSquares:</b> Computes the mean squared pixel-wise difference in intensity between image A and B.
 
 \li <b>NormalizedCorrelation:</b> Computes pixel-wise cross correlation and normalizes it by the square root of the autocorrelation of the images.
 
 \li <b>GradientDifference:</b> Evaluates the difference in the derivatives of the moving and fixed images.
 
 \li <b>KullbackLeiblerCompareHistogram</b>[3]<b>:</b> Measures the relative entropy between two discrete probability distributions.
 
 \li <b>CorrelationCoefficientHistogram:</b> Computes the cross correlation coefficient between the intensities.
 
 \li <b>MeanSquaresHistogram:</b> The joint histogram of the fixed and the mapped moving image is built first. Then the mean squared pixel-wise difference in intensity between image A and B is 
 calculated.
 
 \li <b>MutualInformationHistogram:</b> Computes the mutual information between image A and image B.
 
 \li <b>NormalizedMutualInformationHistogram:</b> Computes the mutual information between image A and image B.
 
 \li <b>MattesMutualInformation</b>[4, 5]<b>:</b> The method of Mattes et al. is used to compute the mutual information between two images to be registered.
 
 \li <b>MeanReciprocalSquareDifference:</b> Computes pixel-wise differences and adds them after passing them through a bell-shaped function 1 / (1+x^2).
 
 \li <b>MutualInformation</b>[6]<b>:</b> Computes the mutual information between image A and image B.
 
 \li <b>MatchCardinality:</b> Computes cardinality of the set of pixels that match exactly between the moving and fixed images.
 
 \li <b>KappaStatistic</b>[7]<b>:</b> Computes spatial intersection of two binary images.
 
 The desired metric can be chosen from a combo box. All parameters defining the selected metric have to be specified within the line edits and checkboxes underneath the metric combo box.
 To show the current optimizer and its parameters for the registration process, the Optimizer checkbox has to be checked. Currently, the following optimizers are implemented 
 (for detailed information see [1] and [2]):
 
 \li <b>Exhaustive:</b> Fully samples a grid on the parametric space.
 
 \li <b>GradientDescent:</b> A simple gradient descent optimizer.
 
 \li <b>QuaternionRigidTransformGradientDescent:</b> Variant of a gradient descent optimizer.
 
 \li <b>LBFGSB</b>[8, 9]<b>:</b> Limited memory Broyden Fletcher Goldfarb Shannon minimization with simple bounds.
 
 \li <b>OnePlusOneEvolutionary</b>[10]<b>:</b> 1+1 evolutionary strategy.
 
 \li <b>Powell:</b> Implements Powell optimization using Brent line search.
 
 \li <b>FRPR:</b> Fletch-Reeves & Polak-Ribiere optimization using dBrent line search.
 
 \li <b>RegularStepGradientDescent:</b> Variant of a gradient descent optimizer.
 
 \li <b>VersorTransform:</b> Variant of a gradient descent optimizer.
 
 \li <b>Amoeba:</b> Implementation of the Nelder-Meade downhill simplex algorithm.
 
 \li <b>ConjugateGradient:</b> Used to solve unconstrained optimization problems.
 
 \li <b>LBFGS:</b> Limited memory Broyden Fletcher Goldfarb Shannon minimization.
 
 \li <b>SPSA</b>[11]<b>:</b> Based on simultaneous perturbation.
 
 \li <b>VersorRigid3DTransform:</b> Variant of a gradient descent optimizer for the VersorRigid3DTransform parameter space.
 
 The desired optimizer can be chosen from a combo box. All parameters defining the selected optimizer have to be specified within the line edits and checkboxes underneath the optimizer combo box.
 To show the current interpolator for the registration process, just check the Interpolator checkbox. Currently, the following interpolators are implemented 
 (for detailed information see [1] and [2]):
 
 \li <b>Linear:</b> Intensity varies linearly between grid positions.
 
 \li <b>NearestNeighbor:</b> Uses the intensity of the nearest grid position.
 
 You can show and hide the parameters for the selection by checking or unchecking the corresponding area. You can save the current sets of parameters with the "Save as Testpreset" or "Save as 
 Preset" buttons.
 
 \section QmitkRigidRegistrationUserManualReferences References:
 
 1. L. Ibanez, W. Schroeder and K. Ng, The ITK Software Guide, Kitware Inc, New York, 2005.
 
 2. http://www.itk.org/Doxygen/
 
 3. Albert C.S. Chung, William M. Wells III, Alexander Norbash, and W. Eric L. Grimson, Multi-modal Image Registration by Minimising Kullback-Leibler Distance, In Medical Image Computing and 
 Computer-Assisted Intervention - MICCAI 2002, LNCS 2489, pp. 525 - 532.
 
 4. D. Mattes, D. R. Haynor, H. Vesselle, T. Lewellen and W. Eubank, "Nonrigid multimodality image registration", Medical Imaging 2001: Image Processing, 2001, pp. 1609-1620.
 
 5. D. Mattes, D. R. Haynor, H. Vesselle, T. Lewellen and W. Eubank, "PET-CT Image Registration in the Chest Using Free-form Deformations", IEEE Transactions in Medical Imaging. 
 Vol.22, No.1, January 2003, pp.120-128.
 
 6. Viola, P. and Wells III, W. (1997). "Alignment by Maximization of Mutual Information" International Journal of Computer Vision, 24(2):137-154.
 
 7. AP Zijdenbos, BM Dawant, RA Margolin , AC Palmer, Morphometric analysis of white matter lesions in MR images: Method and validation, IEEE Transactions on Medical Imaging, 
 13(4):716-724, Dec. 1994.
 
 8. R. H. Byrd, P. Lu and J. Nocedal. A Limited Memory Algorithm for Bound Constrained Optimization, (1995), SIAM Journal on Scientific and Statistical Computing , 16, 5, pp. 1190-1208.
 
 9. C. Zhu, R. H. Byrd and J. Nocedal. L-BFGS-B: Algorithm 778: L-BFGS-B, FORTRAN routines for large scale bound constrained optimization (1997), ACM Transactions on Mathematical Software, 
 Vol 23, Num. 4, pp. 550 - 560. 
 
 10. Martin Styner, G. Gerig, Christian Brechbuehler, Gabor Szekely, "Parametric estimate of intensity inhomogeneities applied to MRI", IEEE TRANSACTIONS ON MEDICAL IMAGING; 19(3), pp. 153-165,
  2000.
 
 11. Spall, J.C. (1998), "An Overview of the Simultaneous Perturbation Method for Efficient Optimization," Johns Hopkins APL Technical Digest, vol. 19, pp. 482-492.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/RegistrationModuleOverview.dox b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/RegistrationModuleOverview.dox
index fdea9e2a31..64aa225fa7 100644
--- a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/RegistrationModuleOverview.dox
+++ b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/RegistrationModuleOverview.dox
@@ -1,14 +1,14 @@
 /**
-\page RegistrationModuleOverviewPage The Registration Modules
+\page org_mitk_gui_qt_registration The Registration Plugin
 
 \section RegistrationModuleOverviewPageOverview Overview
 
-MITK provides several modules for the registration of images.
+MITK provides several views for the registration of images.
 
-\section RegistrationModuleOverviewPageList List of Modules
+\section RegistrationModuleOverviewPageList List of Views
 
-  \li \subpage org_deform_registration
-  \li \subpage org_pointbased_reg
-  \li \subpage org_rigid_regis
+  \li \subpage org_mitk_views_deformableregistration
+  \li \subpage org_mitk_views_pointbasedregistration
+  \li \subpage org_mitk_views_rigidregistration
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/ToolExtensionsGeneralOverview.dox b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/ToolExtensionsGeneralOverview.dox
index a30a965483..910d24fc46 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/ToolExtensionsGeneralOverview.dox
+++ b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/ToolExtensionsGeneralOverview.dox
@@ -1,181 +1,181 @@
 /**
 
-\page toolextensions How to extend the Segmentation bundle with external tools
+\page toolextensions How to extend the Segmentation view with external tools
 
 <ul>
 <li> \ref ToolExtensionsGeneralOverview2 </li>
 <li> \ref ToolExtensionsGeneralOverview3 </li>
   <ul>
   <li> \ref ToolExtensionsGeneralOverview31 </li>
   <li> \ref ToolExtensionsGeneralOverview32 </li>
   <li> \ref ToolExtensionsGeneralOverview33 </li>
   </ul>
 <li> \ref ToolExtensionsGeneralOverview4 </li>
 <li> \ref ToolExtensionsGeneralOverview5 </li>
 <li> \ref ToolExtensionsGeneralOverview6 </li>
 </ul>
 
 \section ToolExtensionsGeneralOverview2 Introduction
 
-The application for manual segmentation in MITK (Segmentation bundle) comes
+The application for manual segmentation in MITK (Segmentation view) comes
 with a tool class framework that is extensible with new tools (description at
 \ref QmitkSegmentationTechnicalPage). The usual way
 to create new tools (since it is mostly used inside DKFZ) is to just add new
 files to the MITK source code tree. However, this requires to be familiar with
 the MITK build system and turnaround time during development might be long 
 (recompiling parts of MITK again and again).
 
 For external users who just want to use
 MITK as a library and application, there is a way to create new segmentation 
 tools in an MITK external project, which will compile the new tools into a 
 shared object (DLL). Such shared objects can be loaded via the ITK object factory
 and its autoload feature on application startup. This document describes
 how to build such external extensions.
 
 <b>Example files can be found</b> in the MITK source code in the directory
 <tt>${MITK_SOURCE_DIR}/QApplications/ToolExtensionsExample/</tt>.
 
 \section ToolExtensionsGeneralOverview3 What might be part of an extension
 
 The extension concept assumes that you want to create one or several new
 interactive segmentation tools for Segmentation or another MITK
 functionality that uses the tools infrastructure. In the result you
 will create a shared object (DLL), which contains several tools and their GUI
 counterparts, plus optional code that your extension requires. The following
 sections shortly describe each of these parts.
 
 \subsection ToolExtensionsGeneralOverview31 Tool classes
 
 A tool is basically any subclass of mitk::Tool. Tools are created at runtime
 through the ITK object factory (so they inherit from itk::Object). Tools
 should handle the interaction part of a segmentation method, i.e. create
 seed points, draw contours, etc., in order to parameterize segmentation algorithms.
 Simple algorithms can even be part of a tool. A tools is identified by icon (XPM format),
 name (short string) and optionally a group name (e.g. the group name for Segmentation
 is "default").
 
 <b>There is a naming convention</b>: you should put a tool called \c mitk::ExternalTool into
 files called \c mitkExternalTool.h and \c mitkExternalTool.cpp. This is \e required if
 you use the convenience macros described below, because there need to be ITK factories,
 which names are directly derived from the file names of the tools. For the example of mitk::ExternalTool
 there would be a factory called \c mitk::ExternalToolFactory in a file named \c mitkExternalToolFactory.cpp.
 
 \subsection ToolExtensionsGeneralOverview32 GUI classes for tools
 
 Tools are non-graphical classes that only implement interactions in renderwindows. However,
 some tools will need a means to allow the user to set some parameters -- a graphical user interface, GUI.
 In the Qt3 case, tool GUIs inherit from QmitkToolGUI, which is a mixture of QWidget and itk::Object.
 Tool GUIs are also created through the ITK object factory.
 
 Tools inform their GUIs about state changes by messages. Tool GUIs communicate with their associated tools
 via direct method calls (they know their tools). See mitk::BinaryThresholdTool for examples.
 
 <b>Again a naming convention</b>: if the convenience macros for tool extension shared objects are used,
 you have to put a tool GUI called \c QmitkExternalToolGUI into a files named \c QmitkExternalToolGUI.cpp
 and \c QmitkExternalToolGUI.h. The convenience macro will create a factory called \c QmitkExternalToolGUIFactory
 into a file named \c QmitkExternalToolGUIFactory.cpp.
 
 \subsection ToolExtensionsGeneralOverview33 Additional files
 
 If you are writing tools MITK externally, these tools might depend on additional files, e.g.
 segmentation algorithms. These can also be compiled into a tool extension shared object.
 
 \section ToolExtensionsGeneralOverview4 Writing a CMake file for a tool extension
 
 Summing up the last section, an example tool extension could comprise the following files:
 \verbatim
 mitkExternalTool.h      \
 mitkExternalTool.xpm     >--- implementing mitk::ExternalTool (header, icon, implementation)
 mitkExternalTool.cpp    /
 
 QmitkExternalToolGUI.h    ,-- implementing a GUI for mitk::ExternalTool
 QmitkExternalToolGUI.cpp /
 
 externalalgorithm.h         \
 externalalgorithm.cpp        \
 externalalgorithmsolver.h     >-- a couple of files (not related to MITK tools)
 externalalgorithmsolver.cpp  /
 \endverbatim
 
 This should all be compiled into one shared object. Just like ITK, VTK and MITK we
 will use CMake for this purpose (I assume you either know or are willing to learn about
 <a href="htpp://www.cmake.org">www.cmake.org</a>)
 A CMake file for the above example would look like this:
 
 \code
 project( ExternalTool )
 
 find_package(ITK)
 find_package(MITK)
 find_package(Qt3)
 
 add_definitions(${QT_DEFINITIONS})
 
 set( TOOL_QT3GUI_FILES
      QmitkExternalToolGUI.cpp
    )
 
 set( TOOL_FILES
      mitkExternalTool.cpp
    )
 
 set( TOOL_ADDITIONAL_CPPS
      externalalgorithm.cpp
      externalalgorithmsolver.cpp
    )
 
 set( TOOL_ADDITIONAL_MOC_H
 )
 
 MITK_GENERATE_TOOLS_LIBRARY(mitkExternalTools)
 \endcode
 
 Basically, you only have to change the definitions of \c TOOL_FILES and, optionally, 
 \c TOOL_QT3GUI_FILES, \c TOOL_ADDITIONAL_CPPS and \c TOOL_ADDITIONAL_MOC_H. 
 For all .cpp files in \c TOOL_FILES and \c TOOL_QT3GUI_FILES there will be factories
 created assuming the naming conventions described in the sections above.
 Files listed in \c TOOL_ADDITIONAL_CPPS will just be compiled. Files listed in
 \c TOOL_ADDITIONAL_MOC_H will be run through Qts meta object compiler \c moc -- 
 this is neccessary for all objects that have the Q_OBJECT macro in their declaration.
 \c moc will create new files that will also be compiled into the library.
 
 \section ToolExtensionsGeneralOverview5 Compiling the extension
 
 For compiling a tool extension, you will need a compiled version of MITK. We will
 assume MITK was compiled into /home/user/mitk/debug. You need to build MITK with
 <b>BUILD_SHARED_CORE</b> turned on!
 
 You build the tool extension just like any other CMake based project:
 \li know where your source code is (e.g. /home/user/mitk/tool-extension-src)
 \li change into the directory, where you want to compile the shared object (e.g. /home/user/mitk/tool-extension-debug)
 \li invoke cmake: <tt>ccmake /home/user/mitk/tool-extension-src</tt>
 \li configure (press c or the "configure" button)
 \li set the ITK_DIR variable to the directory, where you compiled ITK
 \li set the MITK_DIR variable to the directory, where you compiled MITK: <tt>/home/user/mitk/debug</tt>
 \li configure (press "c" or the "configure" button)
 \li generate (press "g" or the "generate" button)
 
 This should do it and leave you with a or project file or Makefile that you can compile (using make or VisualStudio).
 
 \section ToolExtensionsGeneralOverview6 Configuring ITK autoload
 
 If the compile succeeds, you will get a library mitkExternalTools.dll or libmitkExternalTools.so.
 This library exports a symbol \c itkLoad which is expected by the ITK object factory.
 
 On application startup the ITK object factory will search a list of directories from 
 the environment variable \c ITK_AUTOLOAD_PATH. Set this environment variable to your binary directory (<tt>/home/user/mitk/tool-extension-debug</tt>).
 
 The ITK object factory will load all shared objects that it finds in the specified directories
 and will test if they contain a symbol (function pointer) \c itkLoad, which is expected
 to return a pointer to a itk::ObjectFactoryBase instance. If such a symbol is found, the
 returned factory will be registered with the ITK object factory.
 
 If you successfully followed all the steps above, MITK will find your mitk::ExternalTool on
 application startup, when the ITK object factory is asked to create all known instances of
 mitk::Tool. Furthermore, if your mitk::ExternalTool claims to be part of the "default" group,
 there will be a new icon in Segmentation, which activates your tool.
 
 <b>Have fun!</b> (And Windows users: welcome to the world of DLLs)
 
 **/
 
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentation.dox b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentation.dox
index e5cbf68936..1947a0c348 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentation.dox
+++ b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentation.dox
@@ -1,292 +1,292 @@
 /**
-\page org_segment The Segmentation Module
+\page org_mitk_views_segmentation The Segmentation Plugin
 
-\image html segmentation.png "Icon of the Module"
+\image html segmentation.png "Icon of the Plugin"
 
 <i>Some of the features described below  are not available in the open-source part of the MITK-3M3-Application.</i>
 
 Available sections:
 
  - \ref org_mitk_gui_qt_segmentationUserManualOverview
  - \ref org_mitk_gui_qt_segmentationUserManualTechnical
  - \ref org_mitk_gui_qt_segmentationUserManualImageSelection
  - \ref org_mitk_gui_qt_segmentationUserManualManualKringeling
    - \ref org_mitk_gui_qt_segmentationUserManualManualKringeling1
    - \ref org_mitk_gui_qt_segmentationUserManualManualKringeling2
    - \ref org_mitk_gui_qt_segmentationUserManualManualKringeling3
    - \ref org_mitk_gui_qt_segmentationUserManualManualKringeling4
  - \ref org_mitk_gui_qt_segmentationUserManualManualKringeling5
  - \ref org_mitk_gui_qt_segmentationUserManualOrganSegmentation
    - \ref org_mitk_gui_qt_segmentationUserManualOrganSegmentation1
    - \ref org_mitk_gui_qt_segmentationUserManualOrganSegmentation2
    - \ref org_mitk_gui_qt_segmentationUserManualOrganSegmentation99
  - \ref org_mitk_gui_qt_segmentationUserManualLesionSegmentation
  - \ref org_mitk_gui_qt_segmentationUserManualPostprocessing
  - \ref org_mitk_gui_qt_segmentationUserManualSurfaceMasking
  - \ref org_mitk_gui_qt_segmentationUserManualTechnicalDetail
 
 \section org_mitk_gui_qt_segmentationUserManualOverview Overview
 
 The <b>Segmentation perspective</b> allows you to create segmentations of anatomical and pathological structures in medical images of the human body.
 The perspective groups a number of tools which can be used for:
 <ul>
   <li> (semi-)automatic segmentation of organs on CT or MR image volumes
   <li> semi-automatic segmentation of lesions such as enlarged lymph nodes or tumors
   <li> manual segmentation of any structures you might want to delineate
 </ul>
 
 \image html org_mitk_gui_qt_segmentationIMGapplication.png Segmentation perspective consisting of the Data Manager view and the Segmentation view
 
 If you wonder what segmentations are good for, we shortly revisit the concept of a segmentation here.
 A CT or MR image is made up of volume of physical measurements (volume elements are called voxels).
 In CT images, for example, the gray value of each voxel corresponds to the mass absorbtion coefficient for X-rays in this voxel, which is similar in many %parts of the human body.
 The gray value does not contain any further information, so the computer does not know whether a given voxel is part of the body or the background, nor can it tell a brain from a liver.
 However, the distinction between a foreground and a background structure is required when:
 <ul>
 <li>you want to know the volume of a given organ (the computer needs to know which %parts of the image belong to this organ)
 <li>you want to create 3D polygon visualizations (the computer needs to know the surfaces of structures that should be drawn)
 <li>as a necessary pre-processing step for therapy planning, therapy support, and therapy monitoring
 </ul>
 Creating this distinction between foreground and background is called <i>segmentation</i>.
-The Segmentation perspective of the MITK ExtApp uses a voxel based approach to segmentation, i.e. each voxel of an image must be completely assigned to either foreground or background.
+The Segmentation perspective of the MITK Workbench uses a voxel based approach to segmentation, i.e. each voxel of an image must be completely assigned to either foreground or background.
 This is in contrast to some other applications which might use an approach based on contours, where the border of a structure might cut a voxel into two %parts.
 
 The remainder of this document will summarize the features of the Segmentation perspective and how they are used.
 
 \section org_mitk_gui_qt_segmentationUserManualTechnical Technical Issues
 
-The Segmentation perspective makes a number of assumptions. To know what this module can be used for, it will help you to know that:
+The Segmentation perspective makes a number of assumptions. To know what this view can be used for, it will help you to know that:
 <ul>
   <li> Images must be 2D, 3D, or 3D+t
   <li> Images must be single-values, i.e. CT, MRI or "normal" ultrasound. Images from color doppler or photographic (RGB) images are not supported
   <li> Segmentations are handled as binary images of the same extent as the original image
 </ul>
 
 \section org_mitk_gui_qt_segmentationUserManualImageSelection Image Selection
 
 The Segmentation perspective makes use of the Data Manager view to give you an overview of all images and segmentations. 
 
 \image html org_mitk_gui_qt_segmentationIMGselection.png Data Manager is used for selecting the current segmentation. The reference image is selected in the drop down box of the control area.
 
 To select the reference image (e.g. the original CT/MR image) use the drop down box in the control area of the Segmentation view. The segmentation image selected in the Data Manager is displayed below the drop down box. If no segmentation image exists or none is selected create a new segmentation image by using the "New segmentation" button.
 Some items of the graphical user interface might be disabled when no image is selected.
 In any case, the application will give you hints if a selection is needed.
 
 \section org_mitk_gui_qt_segmentationUserManualManualKringeling Manual Contouring
 
 With manual contouring you define which voxels are part of the segmentation and which are not.
 This allows you to create segmentations of any structeres that you may find in an image, even if they are not part of the human body.
 You might also use manual contouring to correct segmentations that result from sub-optimal automatic methods.
 The drawback of manual contouring is that you might need to define contours on many 2D slices.
 However, this is moderated by the interpolation feature, which will make suggestions for a segmentation.
 
 \subsection org_mitk_gui_qt_segmentationUserManualManualKringeling1 Creating New Segmentations
 
 Unless you want to edit existing segmentations, you have to create a new, empty segmentation before you can edit it.
 To do so, click the "New manual segmentation" button.
 Input fields will appear where you can choose a name for the new segmentation and a color for its display.
 Click the checkmark button to confirm or the X button to cancel the new segmentation.
 Notice that the input field suggests names once you %start typing and that it also suggests colors for known organ names.
 If you use names that are not yet known to the application, it will automatically remember these names and consider them the next time you create a new segmentation.
 
 Once you created a new segmentation, you can notice a new item with the "binary mask" icon in the Data Manager tree view.
 This item is automatically selected for you, allowing you to %start editing the new segmentation right away.
 
 \subsection org_mitk_gui_qt_segmentationUserManualManualKringeling2 Selecting Segmentations for Editing
 
 As you might want to have segmentations of multiple structures in a single patient image, the application needs to know which of them to use for editing.
 You select a segmenation by clicking it in the tree view of Data Manager. Note that segmentations are usually displayed as sub-items of "their" patient image.
 In the rare case, where you need to edit a segmentation that is not displayed as a a sub-item, you can click both the original image AND the segmentation while holding down CTRL or for Mac OS X the CMD on the keyboard.
 
 When a selection is made, the Segmentation View will hide all but the selected segmentation and the corresponding original image.
 When there are multiple segmentations, the unselected ones will remain in the Data Manager, you can make them visible at any time by selecting them.
 
 \subsection org_mitk_gui_qt_segmentationUserManualManualKringeling3 Selecting Editing Tools
 
-If you are familiar with the MITK ExtApp, you know that clicking and moving the mouse in any of the 2D render windows will move around the crosshair that defines what part of the image is displayed.
+If you are familiar with the MITK Workbench, you know that clicking and moving the mouse in any of the 2D render windows will move around the crosshair that defines what part of the image is displayed.
 This behavior is disabled while any of the manual segmentation tools are active -- otherwise you might have a hard time concentrating on the contour you are drawing.
 
 To %start using one of the editing tools, click its button the the displayed toolbox.
 The selected editing tool will be active and its corresponding button will stay pressed until you click the button again.
 Selecting a different tool also deactivates the previous one.
 
 If you have to delineate a lot of images, you should try using shortcuts to switch tools. Just hit the first letter of each tool to activate it (A for Add, S for Subtract, etc.).
 
 \subsection org_mitk_gui_qt_segmentationUserManualManualKringeling4 Using Editing Tools
 
 All of the editing tools work by the same principle: you use the mouse (left button) to click anywhere in a 2D window (any of the orientations axial, sagittal, or frontal), move the mouse while holding the mouse button and release to finish the editing action.
 
 Multi-step undo and redo is fully supported by all editing tools. Use the application-wide undo button in the toolbar to revert erroneous %actions.
 
 \image html org_mitk_gui_qt_segmentationIMGiconAddSubtract.png Add and Subtract Tools
 
 Use the left mouse button to draw a closed contour. When releasing the mouse button, the contour will be added (Add tool) to or removed from (Subtract tool) the current segmentation.
 Hold down the CTRL / CMD key to invert the operation (this will switch tools temporarily to allow for quick corrections).
 
 \image html org_mitk_gui_qt_segmentationIMGiconPaintWipe.png Paint and Wipe Tools
 
 Use the slider below the toolbox to change the radius of these round paintbrush tools. Move the mouse in any 2D window and press the left button to draw or erase pixels.
 As the Add/Subtract tools, holding CTRL / CMD while drawing will invert the current tool's behavior.
 
 \image html org_mitk_gui_qt_segmentationIMGiconRegionGrowing.png Region Growing Tool
 
 Click at one point in a 2D slice widget to add an image region to the segmentation with the region growing tool. Moving up the cursor while holding the left mouse button widens the range for the included grey values; moving it down narrows it.
 When working on an image with a high range of grey values, the selection range can be influenced more strongly by moving the cursor at higher velocity.
 
 Region Growing selects all pixels around the mouse cursor that have a similar gray value as the pixel below the mouse cursor.
 This enables you to quickly create segmentations of structures that have a good contrast to surrounding tissue, e.g. the lungs.
 The tool will select more or less pixels (corresponding to a changing gray value interval width) when you move the mouse up or down while holding down the left mouse button.
 
 A common issue with region growing is the so called "leakage" which happens when the structure of interest is connected to other pixels, of similar gray values, through a narrow "bridge" at the border of the structure.
 The Region Growing tool comes with a "leakage detection/removal" feature. If leakage happens, you can left-click into the leakage region and the tool will try to automatically remove this region (see illustration below).
 
 \image html org_mitk_gui_qt_segmentationIMGleakage.png Leakage correction feature of the Region Growing tool
 <br>
 \image html org_mitk_gui_qt_segmentationIMGiconCorrection.png Correction Tool
 
 You do not have to draw a closed contour to use the Correction tool and do not need to switch between the Add and Substract tool to perform
 small corrective changes. The following figure shows the usage of this tool:
 <ul>
 <li> if the user draws a line which %starts and ends outside the segmenation AND it intersects no other segmentation the endpoints of the line are connected and the resulting contour is filled
 <li> if the user draws a line which %starts and ends outside the segmenation a part of it is cut off (left image)
 <li> if the line is drawn fully inside the segmentation the marked region is added to the segmentation (right image)
 </ul>
 
 \image html org_mitk_gui_qt_segmentationIMGcorrectionActions.png %Actions of the Correction tool illustrated.
 <br>
 \image html org_mitk_gui_qt_segmentationIMGiconFill.png Fill Tool
 
 Left-click inside a segmentation with holes to completely fill all holes.
 
 \image html org_mitk_gui_qt_segmentationIMGiconErase.png Erase Tool
 
 This tool removes a connected part of pixels that form a segmentation. You may use it to remove so called islands (see picture) or to clear a whole slice at once (hold CTRL while clicking).
 
 \subsection org_mitk_gui_qt_segmentationUserManualManualKringeling5 Interpolation
 
 Creating segmentations for modern CT volumes is very time-consuming, because structures of interest can easily cover a range of 50 or more slices.
 The Manual Segmentation View offers two helpful features for these cases: 
 
 <ul>
 <li> <b>3D Interpolation</b>
 <li> <b>2D Interpolation</b>
 </ul>
 <br>
 <b>The 3D interpolation</b> is activated by default when using the manual segmentation tools. That means if you start contouring, from the second contour onwards, the surface of the segmented area will be interpolated based on the given contour information. 
 The interpolation works with all available manual tools. Please note that this is currently a pure mathematical interpolation, i.e. image intensity information is not taken into account. With each further contour the interpolation result will be improved, 
 but the more contours you provide the longer the recalculation will take. To achieve an optimal interpolation result and in this way a most accurate segmentation you should try to describe the surface with sparse contours by segmenting in arbitrary 
 oriented planes. The 3D interpolation is not meant to be used for parallel slice-wise segmentation. 
 
 \image html org_mitk_gui_qt_segmentation3DInterpolationWrongRight.png 3D Interpolation HowTo
 
 You can accept the interpolation result by clicking the "Accept" - button below the tool buttons. 
 In this case the 3D interpolation will be deactivated automatically so that the result can be postprocessed without any interpolation running in background. During recalculation the interpolated surface is blinking yellow/white. When the interpolation 
 has finished the surface is shown yellow with a small opacity. Additional to the surface, black contours are shown in the 3D render window. They mark the positions of all the drawn contours which were used for the interpolation. 
 You can navigate between the drawn contours by clicking on the „Position“ - Nodes in the datamanager which are located below the selected segmentation. If you don't want to see these nodes just unckeck the „Show Position Nodes“ Checkbox and these nodes will be hidden.
 If you want to delete a drawn contour we recommend to use the Erase-Tool since Redo/Undo is not yet working for 3D interpolation.
 
 <br>
 <b>The 2D Interpolation</b> creates suggestions for a segmentation whenever you have a slice that
 <ul>
 <li> has got neighboring slices with segmentations (these do not need to be direct neighbors but could also be a couple of slices away) AND
 <li> is completely clear of a manual segmentation -- i.e. there will be no suggestion if there is even only a single pixel of segmentation in the current slice.
 </ul>
 
 Interpolated suggestions are displayed in a different way than manual segmentations are, until you "accept" them as part of the segmentation.
 To accept single slices, click the "Accept" button below the toolbox.
 If you have segmented a whole organ in every-x-slice, you may also review the interpolations and then accept all of them at once by clicking "... all slices".
 
 \section org_mitk_gui_qt_segmentationUserManualOrganSegmentation Organ Segmentation
 
 \note This feature is only available in our 3M3 Demo Application (http://www.mint-medical.de/productssolutions/mitk3m3/mitk3m3/#downloads) but not in the open source part of MITK
 
 The manual contouring described above is a fallback option that will work for any kind of images and structures of interest.
 However, manual contouring is very time-consuming and tedious.
 This is why a major part of image analysis research is working towards automatic segmentation methods.
 The Segmentation View comprises a number of easy-to-use tools for segmentation of CT images (Liver) and MR image (left ventricle and wall, left and right lung).
 
 \subsection org_mitk_gui_qt_segmentationUserManualOrganSegmentation1 Liver on CT Images
 
 On CT image volumes, preferrably with a contrast agent in the portal venous phase, the Liver tool will fully automatically analyze and segment the image.
 All you have to do is to load and select the image, then click the "Liver" button.
 During the process, which takes a minute or two, you will get visual progress feedback by means of a contour that moves closer and closer to the real liver boundaries.
 
 \subsection org_mitk_gui_qt_segmentationUserManualOrganSegmentation2 Heart, Lung, and Hippocampus on MRI
 
 While liver segmentation is performed fully automatic, the following tools for segmentation of the heart, the lungs, and the hippocampus need a minimum amount of guidance.
 Click one of the buttons on the "Organ segmentation" page to add an average %model of the respective organ to the image.
 This %model can be dragged to the right position by using the left mouse button while holding down the CTRL key.
 You can also use CTRL + middle mouse button to rotate or CTRL + right mouse button to scale the %model.
 
 Before starting the automatic segmentation process by clicking the "Start segmentation" button, try placing the %model closely to the organ in the MR image
 (in most cases, you do not need to rotate or scale the %model).
 During the segmentation process, a green contour that moves closer and closer to the real liver boundaries will provide you with visual feedback of the segmentation progress.
 
 The algorithms used for segmentation of the heart and lung are method which need training by a number of example images.
 They will not work well with other kind of images, so here is a list of the image types that were used for training:
 <ul>
 <li> Hippocampus segmentation: T1-weighted MR images, 1.5 Tesla scanner (Magnetom Vision, Siemens Medical Solutions), 1.0 mm isotropic resolution
 <li> Heart: Left ventricle inner segmentation (LV Model): MRI; velocity encoded cine (VEC-cine) MRI sequence; trained on systole and diastole
 <li> Heart: Left ventricular wall segmentation (LV Inner Wall, LV Outer Wall): 4D MRI; short axis 12 slice spin lock sequence(SA_12_sl); trained on whole heart cycle
 <li> Lung segmentation: 3D and 4D MRI; works best on FLASH3D and TWIST4D sequences
 </ul>
 
 \subsection org_mitk_gui_qt_segmentationUserManualOrganSegmentation99 Other Organs
 
 As mentioned in the Heart/Lung section, most of the underlying methods are based on "training".
 The basic algorithm is versatile and can be applied on all kinds of segmentation problems where the structure of interest is topologically like a sphere (and not like a torus etc.).
 If you are interested in other organs than those offered by the current version of the Segmentation view,
 please contact our research team.
 
 \section org_mitk_gui_qt_segmentationUserManualLesionSegmentation Lesion Segmentation
 
 \note This feature is only available in our 3M3 Demo Application (http://www.mint-medical.de/productssolutions/mitk3m3/mitk3m3/#downloads) but not in the open source part of MITK
 
 Lesion segmentation is a little different from organ segmentation. Since lesions are not part of the healthy body, they sometimes have a diffused border,
 and are often found in varying places all over the body.
 The tools in this section offer efficient ways to create 3D segmentations of such lesions.
 
 The Segmentation View currently offers supoprt for enlarged lymph nodes.
 
 To segment an enlarged lymph node, find a more or less central slice of it, activate the "Lymph Node" tool and draw a rough contour on the inside of the lymph node.
 When releaseing the mouse button, a segmentation algorithm is started in a background task. The result will become visible after a couple of seconds, but you do not have to wait for it.
 If you need to segment several lymph nodes, you can continue to inspect the image right after closing the drawn contour.
 
 If the lymph node segmentation is not to your content, you can select the "Lymph Node Correction" tool and drag %parts of the lymph node surface towards the right position (works in 3D, not slice-by-slice).
 This kind of correction helps in many cases.
 If nothing else helps, you can still use the pure manual tools as a fallback.
 
 \section org_mitk_gui_qt_segmentationUserManualPostprocessing Things you can do with segmentations
 
 As mentioned in the introduction, segmentations are never an end in themselves.
 Consequently, the Segmentation view adds a couple of "post-processing" %actions to the Data Manager.
 These %actions are accessible through the context-menu of segmentations in Data Manager's list view
 
 \image html org_mitk_gui_qt_segmentationIMGDataManagerContextMenu.png Context menu items for segmentations.
 
 <ul>
 <li> <b>Create polygon %model</b> applies the marching cubes algorithms to the segmentation. This polygon %model can be used for visualization in 3D or other things such as stereolithography (3D printing).
 <li> <b>Create smoothed polygon %model</b> uses smoothing in addition to the marching cubes algorithms, which creates models that do not follow the exact outlines of the segmentation, but look smoother.
 <li> <b>Statistics</b> goes through all the voxels in the patient image that are part of the segmentation and calculates some statistical measures (minumum, maximum, median, histogram, etc.). Note that the statistics are ALWAYS calculated for the parent element of the segmentation as shown in Data Manager.
 <li> <b>Autocrop</b> can save memory. Manual segmentations have the same extent as the patient image, even if the segmentation comprises only a small sub-volume. This invisible and meaningless margin is removed by autocropping.
 </ul>
 
 \section org_mitk_gui_qt_segmentationUserManualSurfaceMasking Surface Masking
 
 You can use the surface masking tool to create binary images from a surface which
 is used used as a mask on an image. This task is demonstrated below:
 
 \image html segmentationFromSurfaceBefore.png Load an image and a surface. 
 
 Select the image and the surface in the corresponding drop-down boxes (both are selected automatically if there is just one image and one surface)
 
 \image html segmentationFromSurfaceAfter.png Create segmentation from surface
 
 After clicking "Create segmentation from surface" the newly created binary image is inserted in the DataManager and can be used for further processing
 
 \section org_mitk_gui_qt_segmentationUserManualTechnicalDetail Technical Information for Developers
 
 For technical specifications see \subpage QmitkSegmentationTechnicalPage and for information on the extensions of the tools system \subpage toolextensions .
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkOtsuAction.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkOtsuAction.cpp
index 56ab14917a..066c4b84a6 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkOtsuAction.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkOtsuAction.cpp
@@ -1,209 +1,213 @@
 /*===================================================================
 
 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 "QmitkOtsuAction.h"
 
 // MITK
 #include <itkOtsuMultipleThresholdsImageFilter.h>
 #include <mitkRenderingManager.h>
 #include <mitkImage.h>
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkLevelWindowProperty.h>
 
 // ITK
 #include <itkMultiplyImageFilter.h>
 
 // Qt
 #include <QDialog>
 #include <QVBoxLayout>
 #include <QApplication>
 #include <QList>
 #include <QLabel>
 #include <QMessageBox>
 
 using namespace berry;
 using namespace mitk;
 using namespace std;
 
 QmitkOtsuAction::QmitkOtsuAction()
 : m_OtsuSegmentationDialog(NULL)
 { 
 }
 
 QmitkOtsuAction::~QmitkOtsuAction()
 {
 }
 
 void QmitkOtsuAction::Run(const QList<DataNode::Pointer> &selectedNodes)
 {
   this->m_DataNode = selectedNodes[0];
   //this->m_selectedNodes = selectedNodes;
 
-  m_OtsuSegmentationDialog = new QDialog(QApplication::activeWindow());
+  m_OtsuSegmentationDialog = new QDialog(QApplication::activeWindow(),Qt::WindowTitleHint | Qt::WindowSystemMenuHint);
   
 
   QVBoxLayout *layout = new QVBoxLayout;
   layout->setContentsMargins(0, 0, 0, 0);
   QHBoxLayout* spinBoxLayout = new QHBoxLayout;
   QHBoxLayout* buttonLayout = new QHBoxLayout;
 
   m_OtsuSpinBox = new QSpinBox;
   m_OtsuSpinBox->setRange(2, 32);
   m_OtsuSpinBox->setValue(2);
 
   m_OtsuPushButton = new QPushButton("OK");
   QPushButton* CancelButton = new QPushButton("Cancel");
 
   connect(m_OtsuPushButton, SIGNAL(clicked()), this, SLOT(OtsuSegmentationDone()));
   connect(CancelButton, SIGNAL(clicked()), m_OtsuSegmentationDialog, SLOT(reject()));
 
   QLabel* numberOfThresholdsLabel = new QLabel("Select number of Regions of Interest:");
   numberOfThresholdsLabel->setAlignment(Qt::AlignVCenter | Qt::AlignHCenter);
   layout->addWidget(numberOfThresholdsLabel);
   layout->addLayout(spinBoxLayout);
   spinBoxLayout->addSpacing(50);
   spinBoxLayout->addWidget(m_OtsuSpinBox);
   spinBoxLayout->addSpacing(50);
   layout->addLayout(buttonLayout);
   buttonLayout->addWidget(m_OtsuPushButton);
   buttonLayout->addWidget(CancelButton);
 
   m_OtsuSegmentationDialog->setLayout(layout);
   m_OtsuSegmentationDialog->setFixedSize(300, 80);
 
   m_OtsuSegmentationDialog->open();
 }
 
 void QmitkOtsuAction::OtsuSegmentationDone()
 {
 
   /*
   if (result == QDialog::Rejected)
   m_ThresholdingToolManager->ActivateTool(-1);*/
 
   this->PerformOtsuSegmentation();
 
   m_OtsuSegmentationDialog->deleteLater();
   m_OtsuSegmentationDialog = NULL;
 
   //m_ThresholdingToolManager->SetReferenceData(NULL);
   //m_ThresholdingToolManager->SetWorkingData(NULL);
 
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkOtsuAction::SetDataStorage(DataStorage *dataStorage)
 {
   m_DataStorage = dataStorage;
 }
 
 void QmitkOtsuAction::SetFunctionality(QtViewPart* /*functionality*/)
 {
 }
 
 void QmitkOtsuAction::PerformOtsuSegmentation()
 {
+  this->m_OtsuSegmentationDialog->setCursor(Qt::WaitCursor);
+
   int numberOfThresholds = this->m_OtsuSpinBox->value() - 1;
   int proceed;
   
   QMessageBox* messageBox = new QMessageBox(QMessageBox::Question, NULL, "The otsu segmentation computation may take several minutes depending on the number of Regions you selected. Proceed anyway?", QMessageBox::Ok | QMessageBox::Cancel);
   if (numberOfThresholds >= 5) 
   {
     proceed = messageBox->exec();
     if (proceed != QMessageBox::Ok) return;
   }
 
   mitk::Image::Pointer mitkImage = 0;
   
   mitkImage = dynamic_cast<mitk::Image*>( this->m_DataNode->GetData() );
 
   try
   {
     // get selected mitk image
     const unsigned short dim = 3;
     typedef short InputPixelType;
     typedef unsigned char OutputPixelType;
 
     typedef itk::Image< InputPixelType, dim > InputImageType;
     typedef itk::Image< OutputPixelType, dim > OutputImageType;
 
     //typedef itk::OtsuThresholdImageFilter< InputImageType, OutputImageType > FilterType;
     typedef itk::OtsuMultipleThresholdsImageFilter< InputImageType, OutputImageType > FilterType;
     //typedef itk::MultiplyImageFilter< OutputImageType, OutputImageType, OutputImageType> MultiplyFilterType;
     //typedef itk::RandomImageSource< OutputImageType> RandomImageSourceType;
     //typedef itk::ImageRegionIterator< OutputImageType > ImageIteratorType;
 
 
     FilterType::Pointer filter = FilterType::New();
     //MultiplyFilterType::Pointer multiplyImageFilter = MultiplyFilterType::New();
     //RandomImageSourceType::Pointer randomImageSource = RandomImageSourceType::New();
 
     filter->SetNumberOfThresholds(numberOfThresholds);
     //filter->SetLabelOffset(0);
     /*
     filter->SetOutsideValue( 1 );
     filter->SetInsideValue( 0 );*/
 
     InputImageType::Pointer itkImage;
     mitk::CastToItkImage(mitkImage, itkImage);
 
     filter->SetInput( itkImage );
 //    filter->UpdateOutputInformation();
 
     //multiplyImageFilter->SetInput1(filter->GetOutput());
     //OutputImageType::Pointer constantImage = OutputImageType::New();
     //constantImage->SetLargestPossibleRegion(filter->GetOutput()->GetLargestPossibleRegion());
     //constantImage->SetBufferedRegion(filter->GetOutput()->GetLargestPossibleRegion());
     //constantImage->Allocate();
     //ImageIteratorType it(constantImage, constantImage->GetLargestPossibleRegion());
     //while (!it.IsAtEnd())
     //{
     //  it.Set(1);
     //  ++it;
     //}
 
     ////randomImageSource->SetSize(filter->GetOutput()->GetLargestPossibleRegion().GetSize());
     ////multiplyImageFilter->SetInput2(randomImageSource->GetOutput());
     //multiplyImageFilter->SetInput2(constantImage);
 
     filter->Update();
     //multiplyImageFilter->Update();
 
     mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
     std::string nameOfResultImage = this->m_DataNode->GetName();
     nameOfResultImage.append("Otsu");
     resultNode->SetProperty("name", mitk::StringProperty::New(nameOfResultImage) );
     resultNode->SetProperty("binary", mitk::BoolProperty::New(false) );
     resultNode->SetProperty("use color", mitk::BoolProperty::New(false) );
 
     mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
     mitk::LevelWindow levelwindow;
     levelwindow.SetRangeMinMax(0, numberOfThresholds);
     levWinProp->SetLevelWindow( levelwindow );
     resultNode->SetProperty( "levelwindow", levWinProp );
 
     //resultNode->SetData( mitk::ImportItkImage ( filter->GetOutput() ) );
     resultNode->SetData( mitk::ImportItkImage ( filter->GetOutput() ) );
 
 
     this->m_DataStorage->Add(resultNode, this->m_DataNode);
 
+    this->m_OtsuSegmentationDialog->setCursor(Qt::ArrowCursor);
+
   }
   catch( std::exception& err )
   {
     MITK_ERROR(this->GetClassName()) << err.what();
   }
   }
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
index ab2ecebbff..a6b552aa70 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,1228 +1,1225 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
-Copyright (c) German Cancer Research Center, 
+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 
+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 "mitkDataNodeObject.h"
 #include "mitkProperties.h"
 #include "mitkSegTool2D.h"
 #include "mitkGlobalInteraction.h"
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkNewSegmentationDialog.h"
 
 #include <QMessageBox>
 
 #include <berryIWorkbenchPage.h>
 
 #include "QmitkSegmentationView.h"
 #include "QmitkSegmentationPostProcessing.h"
 #include "QmitkSegmentationOrganNamesHandling.cpp"
 
 #include <mitkSurfaceToImageFilter.h>
 #include <vtkPolyData.h>
 
 //For Segmentation in rotated slices
 //TODO clean up includes
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkPlanarCircle.h"
 
 #include "mitkGetModuleContext.h"
 #include "mitkModule.h"
 #include "mitkModuleRegistry.h"
 
 #include "mitkSegmentationObjectFactory.h"
 
 const std::string QmitkSegmentationView::VIEW_ID =
 "org.mitk.views.segmentation";
 
 // public methods
 
 QmitkSegmentationView::QmitkSegmentationView()
 :m_Parent(NULL)
 ,m_Controls(NULL)
 ,m_MultiWidget(NULL)
 ,m_RenderingManagerObserverTag(0)
+,m_DataSelectionChanged(false)
 {
   RegisterSegmentationObjectFactory();
 }
 
 QmitkSegmentationView::~QmitkSegmentationView()
 {
   // delete m_PostProcessing;
   delete m_Controls;
 }
 
 void QmitkSegmentationView::NewNodesGenerated()
 {
 //  ForceDisplayPreferencesUponAllImages();
 }
 
 void QmitkSegmentationView::NewNodeObjectsGenerated(mitk::ToolManager::DataVectorType* nodes)
 {
   if (!nodes) return;
 
   mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
   if (!toolManager) return;
   for (mitk::ToolManager::DataVectorType::iterator iter = nodes->begin(); iter != nodes->end(); ++iter)
   {
     this->FireNodeSelected( *iter );
     // only last iteration meaningful, multiple generated objects are not taken into account here
   }
 }
 
+void QmitkSegmentationView::Visible()
+{
+  if (m_DataSelectionChanged)
+  {
+    this->OnSelectionChanged(this->GetDataManagerSelection());
+  }
+}
+
 void QmitkSegmentationView::Activated()
 {
   // should be moved to ::BecomesVisible() or similar
   if( m_Controls )
   {
     m_Controls->m_ManualToolSelectionBox->setEnabled( true );
     m_Controls->m_OrganToolSelectionBox->setEnabled( true );
     m_Controls->m_LesionToolSelectionBox->setEnabled( true );
 
     m_Controls->m_SlicesInterpolator->Enable3DInterpolation( m_Controls->widgetStack->currentWidget() == m_Controls->pageManual );
 
     //TODO Remove Observer
     itk::ReceptorMemberCommand<QmitkSegmentationView>::Pointer command1 = itk::ReceptorMemberCommand<QmitkSegmentationView>::New();
     command1->SetCallbackFunction( this, &QmitkSegmentationView::RenderingManagerReinitialized );
     m_RenderingManagerObserverTag = mitk::RenderingManager::GetInstance()->AddObserver( mitk::RenderingManagerViewsInitializedEvent(), command1 );
 
     //Adding observers for node visibility to existing segmentations
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
     mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
     mitk::NodePredicateAnd::Pointer isSegmentation = mitk::NodePredicateAnd::New( isImage, isBinary );
 
     mitk::DataStorage::SetOfObjects::ConstPointer segmentations = this->GetDefaultDataStorage()->GetSubset( isSegmentation );
 
     for ( mitk::DataStorage::SetOfObjects::const_iterator iter = segmentations->begin();
       iter != segmentations->end();
       ++iter)
     {
         mitk::DataNode* node = *iter;
         itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
         command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
         m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( node, node->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
     }
 
     if(segmentations->Size() > 0)
     {
       FireNodeSelected(segmentations->ElementAt(0));
       segmentations->ElementAt(0)->GetProperty("visible")->Modified();
     }
   }
 }
 
 void QmitkSegmentationView::Deactivated()
 {
   if( m_Controls )
   {
     mitk::RenderingManager::GetInstance()->RemoveObserver( m_RenderingManagerObserverTag );
     m_Controls->m_ManualToolSelectionBox->setEnabled( false );
     //deactivate all tools
     m_Controls->m_ManualToolSelectionBox->GetToolManager()->ActivateTool(-1);
     m_Controls->m_OrganToolSelectionBox->setEnabled( false );
     m_Controls->m_LesionToolSelectionBox->setEnabled( false );
     m_Controls->m_SlicesInterpolator->EnableInterpolation( false );
 
     //Removing all observers
     for ( NodeTagMapType::iterator dataIter = m_WorkingDataObserverTags.begin(); dataIter != m_WorkingDataObserverTags.end(); ++dataIter )
     {
       (*dataIter).first->GetProperty("visible")->RemoveObserver( (*dataIter).second );
     }
     m_WorkingDataObserverTags.clear();
 
     if (m_MultiWidget)
     {
       mitk::SlicesCoordinator *coordinator = m_MultiWidget->GetSlicesRotator();
-      
+
       if (coordinator)
         coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
 
       coordinator = m_MultiWidget->GetSlicesSwiveller();
-      
+
       if (coordinator)
         coordinator->RemoveObserver(m_SlicesRotationObserverTag2);
 
     }
 
     // gets the context of the "Mitk" (Core) module (always has id 1)
     // TODO Workaround until CTL plugincontext is available
     mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
     // Workaround end
     mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
     //mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
     service->RemoveAllPlanePositions();
   }
 }
 
 void QmitkSegmentationView::StdMultiWidgetAvailable( QmitkStdMultiWidget& stdMultiWidget )
 {
   SetMultiWidget(&stdMultiWidget);
 }
 
 void QmitkSegmentationView::StdMultiWidgetNotAvailable()
 {
   SetMultiWidget(NULL);
 }
 
 void QmitkSegmentationView::StdMultiWidgetClosed( QmitkStdMultiWidget& /*stdMultiWidget*/ )
 {
   SetMultiWidget(NULL);
 }
 
 void QmitkSegmentationView::SetMultiWidget(QmitkStdMultiWidget* multiWidget)
 {
   if (m_MultiWidget)
   {
     mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
     if (coordinator)
     {
       coordinator->RemoveObserver( m_SlicesRotationObserverTag1 );
     }
     coordinator = m_MultiWidget->GetSlicesSwiveller();
     if (coordinator)
     {
       coordinator->RemoveObserver( m_SlicesRotationObserverTag2 );
     }
   }
 
   // save the current multiwidget as the working widget
   m_MultiWidget = multiWidget;
 
   //TODO Remove Observers
   if (m_MultiWidget)
   {
     mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
     if (coordinator)
     {
       itk::ReceptorMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkSegmentationView>::New();
       command2->SetCallbackFunction( this, &QmitkSegmentationView::SliceRotation );
       m_SlicesRotationObserverTag1 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
     }
 
     coordinator = m_MultiWidget->GetSlicesSwiveller();
     if (coordinator)
     {
       itk::ReceptorMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkSegmentationView>::New();
       command2->SetCallbackFunction( this, &QmitkSegmentationView::SliceRotation );
       m_SlicesRotationObserverTag2 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
     }
   }
   //TODO End Remove Observers
 
   if (m_Parent)
   {
     m_Parent->setEnabled(m_MultiWidget);
   }
 
   // tell the interpolation about toolmanager and multiwidget (and data storage)
   if (m_Controls && m_MultiWidget)
   {
     mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
     m_Controls->m_SlicesInterpolator->SetDataStorage( *(this->GetDefaultDataStorage()));
     m_Controls->m_SlicesInterpolator->Initialize( toolManager, m_MultiWidget );
   }
 }
 
 void QmitkSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences*)
 {
   ForceDisplayPreferencesUponAllImages();
 }
 
 //TODO remove function
 void QmitkSegmentationView::RenderingManagerReinitialized(const itk::EventObject&)
 {
   CheckImageAlignment();
 }
 
 //TODO remove function
 void QmitkSegmentationView::SliceRotation(const itk::EventObject&)
 {
   CheckImageAlignment();
 }
 
 
 // protected slots
 
 void QmitkSegmentationView::CreateNewSegmentation()
 {
   mitk::DataNode::Pointer node = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
   if (node.IsNotNull())
   {
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
     if (image.IsNotNull())
     {
       if (image->GetDimension()>1)
       {
         // ask about the name and organ type of the new segmentation
         QmitkNewSegmentationDialog* dialog = new QmitkNewSegmentationDialog( m_Parent ); // needs a QWidget as parent, "this" is not QWidget
 
         QString storedList = QString::fromStdString( this->GetPreferences()->GetByteArray("Organ-Color-List","") );
         QStringList organColors;
         if (storedList.isEmpty())
         {
           organColors = GetDefaultOrganColorString();
         }
         else
         {
           /*
           a couple of examples of how organ names are stored:
 
           a simple item is built up like 'name#AABBCC' where #AABBCC is the hexadecimal notation of a color as known from HTML
 
           items are stored separated by ';'
           this makes it necessary to escape occurrences of ';' in name.
           otherwise the string "hugo;ypsilon#AABBCC;eugen#AABBCC" could not be parsed as two organs
           but we would get "hugo" and "ypsilon#AABBCC" and "eugen#AABBCC"
 
           so the organ name "hugo;ypsilon" is stored as "hugo\;ypsilon"
           and must be unescaped after loading
 
           the following lines could be one split with Perl's negative lookbehind
           */
 
           // recover string list from BlueBerry view's preferences
           QString storedString = QString::fromStdString( this->GetPreferences()->GetByteArray("Organ-Color-List","") );
           MITK_DEBUG << "storedString: " << storedString.toStdString();
           // match a string consisting of any number of repetitions of either "anything but ;" or "\;". This matches everything until the next unescaped ';'
           QRegExp onePart("(?:[^;]|\\\\;)*");
           MITK_DEBUG << "matching " << onePart.pattern().toStdString();
           int count = 0;
           int pos = 0;
           while( (pos = onePart.indexIn( storedString, pos )) != -1 )
           {
             ++count;
             int length = onePart.matchedLength();
             if (length == 0) break;
             QString matchedString = storedString.mid(pos, length);
             MITK_DEBUG << "   Captured length " << length << ": " << matchedString.toStdString();
             pos += length + 1; // skip separating ';'
 
             // unescape possible occurrences of '\;' in the string
             matchedString.replace("\\;", ";");
 
             // add matched string part to output list
             organColors << matchedString;
           }
           MITK_DEBUG << "Captured " << count << " organ name/colors";
         }
 
         dialog->SetSuggestionList( organColors );
 
         int dialogReturnValue = dialog->exec();
 
         if ( dialogReturnValue == QDialog::Rejected ) return; // user clicked cancel or pressed Esc or something similar
 
         // ask the user about an organ type and name, add this information to the image's (!) propertylist
         // create a new image of the same dimensions and smallest possible pixel type
         mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
         mitk::Tool* firstTool = toolManager->GetToolById(0);
         if (firstTool)
         {
           try
           {
             mitk::DataNode::Pointer emptySegmentation =
               firstTool->CreateEmptySegmentationNode( image, dialog->GetSegmentationName().toStdString(), dialog->GetColor() );
 
             //Here we change the reslice interpolation mode for a segmentation, so that contours in rotated slice can be shown correctly
             emptySegmentation->SetProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_NEAREST) );
             // initialize showVolume to false to prevent recalculating the volume while working on the segmentation
             emptySegmentation->SetProperty( "showVolume", mitk::BoolProperty::New( false ) );
 
             if (!emptySegmentation) return; // could be aborted by user
 
             UpdateOrganList( organColors, dialog->GetSegmentationName(), dialog->GetColor() );
 
             /*
             escape ';' here (replace by '\;'), see longer comment above
             */
             std::string stringForStorage = organColors.replaceInStrings(";","\\;").join(";").toStdString();
             MITK_DEBUG << "Will store: " << stringForStorage;
             this->GetPreferences()->PutByteArray("Organ-Color-List", stringForStorage );
             this->GetPreferences()->Flush();
 
             if(m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0))
             {
               m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0)->SetSelected(false);
             }
             emptySegmentation->SetSelected(true);
             this->GetDefaultDataStorage()->Add( emptySegmentation, node ); // add as a child, because the segmentation "derives" from the original
 
             this->FireNodeSelected( emptySegmentation );
             this->OnSelectionChanged( emptySegmentation );
             this->SetToolManagerSelection(node, emptySegmentation);
           }
           catch (std::bad_alloc)
           {
             QMessageBox::warning(NULL,"Create new segmentation","Could not allocate memory for new segmentation");
           }
         }
       }
       else
       {
         QMessageBox::information(NULL,"Segmentation","Segmentation is currently not supported for 2D images");
       }
     }
   }
   else
   {
     MITK_ERROR << "'Create new segmentation' button should never be clickable unless a patient image is selected...";
   }
 }
 
 void QmitkSegmentationView::OnWorkingNodeVisibilityChanged(/*const itk::Object* caller, const itk::EventObject& e*/)
 {
   if (!m_Parent || !m_Parent->isVisible()) return;
 
   // The new selection behaviour is:
-  // 
+  //
   // When clicking on the checkbox of a segmentation the node will e selected and its reference node either
   // The previous selected segmentation (if there is one) will be deselected. Additionally a reinit on the
   // selected segmenation will be performed.
   // If more than one segmentation is selected the tools will be disabled.
 
   if (!m_Controls) return; // might happen on initialization (preferences loaded)
   mitk::DataNode::Pointer referenceDataNew = mitk::DataNode::New();
   mitk::DataNode::Pointer workingData;
 
   bool workingNodeIsVisible (true);
 
   unsigned int numberOfSelectedSegmentations (0);
 
   // iterate all images
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
 
   mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDefaultDataStorage()->GetSubset( isImage );
   for ( mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin();
     iter != allImages->end();
     ++iter)
   {
     mitk::DataNode* node = *iter;
     // apply display preferences
     ApplyDisplayOptions(node);
 
     bool isSegmentation(false);
     node->GetBoolProperty("binary", isSegmentation);
     if (node->IsSelected() && isSegmentation)
     {
       workingNodeIsVisible =  node->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
       if (!workingNodeIsVisible)
         return;
       numberOfSelectedSegmentations++;
 
       workingData = node;
 
       if (this->GetDefaultDataStorage()->GetSources(node)->Size() != 0)
       {
           referenceDataNew = this->GetDefaultDataStorage()->GetSources(node)->ElementAt(0);
       }
 
       bool isBinary(false);
 
       //Find topmost source or first source which is no binary image
       while (referenceDataNew && this->GetDefaultDataStorage()->GetSources(referenceDataNew)->Size() != 0)
       {
         referenceDataNew = this->GetDefaultDataStorage()->GetSources(referenceDataNew)->ElementAt(0);
 
         referenceDataNew->GetBoolProperty("binary",isBinary);
         if (!isBinary)
             break;
       }
 
       if (workingNodeIsVisible && referenceDataNew)
       {
           //Since the binary property of a segmentation can be set to false and afterwards you can create a new segmentation out of it
           //->could lead to a deadloop
           NodeTagMapType::iterator searchIter = m_WorkingDataObserverTags.find( referenceDataNew );
           if ( searchIter != m_WorkingDataObserverTags.end())
           {
               referenceDataNew->GetProperty("visible")->RemoveObserver( (*searchIter).second );
           }
           referenceDataNew->SetVisibility(true);
       }
 
       //set comboBox to reference image
       disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
         this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
       m_Controls->refImageSelector->setCurrentIndex( m_Controls->refImageSelector->Find(referenceDataNew) );
 
       connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
         this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
       continue;
     }
     if (workingData.IsNull() || (workingNodeIsVisible && node != referenceDataNew))
     {
       node->SetVisibility((false));
     }
   }
   if(numberOfSelectedSegmentations == 1)
     SetToolManagerSelection(referenceDataNew, workingData);
 
   mitk::DataStorage::SetOfObjects::Pointer temp = mitk::DataStorage::SetOfObjects::New();
   temp->InsertElement(0,workingData);
   mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(temp);
 
   // initialize the views to the bounding geometry
   /*mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();*/
 }
 
 void QmitkSegmentationView::NodeRemoved(const mitk::DataNode* node)
 {
   bool isSeg(false);
   bool isHelperObject(false);
   node->GetBoolProperty("helper object", isHelperObject);
   node->GetBoolProperty("binary", isSeg);
   if(isSeg && !isHelperObject)
   {
     mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = this->GetDataStorage()->GetDerivations(node, mitk::NodePredicateProperty::New("isContourMarker"
       , mitk::BoolProperty::New(true)));
 
     // gets the context of the "Mitk" (Core) module (always has id 1)
     // TODO Workaround until CTL plugincontext is available
     mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
     // Workaround end
     mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
     //mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
 
     mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
 
     for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
     {
       std::string nodeName = node->GetName();
       unsigned int t = nodeName.find_last_of(" ");
       unsigned int id = atof(nodeName.substr(t+1).c_str())-1;
 
       service->RemovePlanePosition(id);
 
       this->GetDataStorage()->Remove(it->Value());
     }
     mitk::DataNode* tempNode = const_cast<mitk::DataNode*>(node);
     node->GetProperty("visible")->RemoveObserver( m_WorkingDataObserverTags[tempNode] );
     m_WorkingDataObserverTags.erase(tempNode);
   }
 
   if((m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0) == node)||
     (m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0) == node))
   {
   //as we don't know which node was actually remove e.g. our reference node, disable 'New Segmentation' button.
   //consider the case that there is no more image in the datastorage
     this->SetToolManagerSelection(NULL, NULL);
   }
 }
 
 void QmitkSegmentationView::CreateSegmentationFromSurface()
-{ 
+{
   mitk::DataNode::Pointer surfaceNode =
     m_Controls->MaskSurfaces->GetSelectedNode();
   mitk::Surface::Pointer surface(0);
   if(surfaceNode.IsNotNull())
     surface = dynamic_cast<mitk::Surface*> ( surfaceNode->GetData() );
   if(surface.IsNull())
   {
     this->HandleException( "No surface selected.", m_Parent, true);
     return;
   }
 
   mitk::DataNode::Pointer imageNode
     = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
   mitk::Image::Pointer image(0);
   if (imageNode.IsNotNull())
     image = dynamic_cast<mitk::Image*>( imageNode->GetData() );
   if(image.IsNull())
   {
     this->HandleException( "No image selected.", m_Parent, true);
     return;
   }
 
   mitk::SurfaceToImageFilter::Pointer s2iFilter
     = mitk::SurfaceToImageFilter::New();
 
   s2iFilter->MakeOutputBinaryOn();
   s2iFilter->SetInput(surface);
   s2iFilter->SetImage(image);
   s2iFilter->Update();
 
   mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
   std::string nameOfResultImage = imageNode->GetName();
   nameOfResultImage.append(surfaceNode->GetName());
   resultNode->SetProperty("name", mitk::StringProperty::New(nameOfResultImage) );
   resultNode->SetProperty("binary", mitk::BoolProperty::New(true) );
   resultNode->SetData( s2iFilter->GetOutput() );
 
   this->GetDataStorage()->Add(resultNode, imageNode);
 
 }
 
-void QmitkSegmentationView::ManualToolSelected(int id)
-{
-  // disable crosshair movement when a manual drawing tool is active (otherwise too much visual noise)
-  if (m_MultiWidget)
-  {
-    if (id >= 0)
-    {
-      m_MultiWidget->DisableNavigationControllerEventListening();
-    }
-    else
-    {
-      m_MultiWidget->EnableNavigationControllerEventListening();
-    }
-  }
-}
-
 void QmitkSegmentationView::ToolboxStackPageChanged(int id)
 {
   // interpolation only with manual tools visible
   m_Controls->m_SlicesInterpolator->EnableInterpolation( id == 0 );
 
   if( id == 0 )
   {
     mitk::DataNode::Pointer workingData =   m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0);
     if( workingData.IsNotNull() )
     {
       m_Controls->lblSegmentation->setText( workingData->GetName().c_str() );
       m_Controls->lblSegImage->show();
       m_Controls->lblSegmentation->show();
     }
   }
   else
   {
     m_Controls->lblSegImage->hide();
     m_Controls->lblSegmentation->hide();
   }
 
   // this is just a workaround, should be removed when all tools support 3D+t
   if (id==2) // lesions
   {
     mitk::DataNode::Pointer node = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
     if (node.IsNotNull())
     {
       mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
       if (image.IsNotNull())
       {
         if (image->GetDimension()>3)
         {
           m_Controls->widgetStack->setCurrentIndex(0);
           QMessageBox::information(NULL,"Segmentation","Lesion segmentation is currently not supported for 4D images");
         }
       }
     }
   }
 }
 
 // protected
 
 void QmitkSegmentationView::OnComboBoxSelectionChanged( const mitk::DataNode* node )
 {
   mitk::DataNode* selectedNode = const_cast<mitk::DataNode*>(node);
   if( selectedNode != NULL )
   {
     m_Controls->refImageSelector->show();
     m_Controls->lblReferenceImageSelectionWarning->hide();
 
     bool isBinary(false);
     selectedNode->GetBoolProperty("binary", isBinary);
     if ( isBinary )
     {
       FireNodeSelected(selectedNode);
       selectedNode->SetVisibility(true);
     }
     else if (node != m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0))
     {
       if (m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0))
         m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0)->SetVisibility(false);
       if (m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0))
       {
         m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0)->SetVisibility(false);
       }
       FireNodeSelected(selectedNode);
       selectedNode->SetVisibility(true);
       SetToolManagerSelection(selectedNode, NULL);
     }
   }
   else
   {
     m_Controls->refImageSelector->hide();
     m_Controls->lblReferenceImageSelectionWarning->show();
   }
 }
 
 
 void QmitkSegmentationView::OnShowMarkerNodes (bool state)
 {
   mitk::SegTool2D::Pointer manualSegmentationTool;
 
   unsigned int numberOfExistingTools = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetTools().size();
 
   for(unsigned int i = 0; i < numberOfExistingTools; i++)
   {
     manualSegmentationTool = dynamic_cast<mitk::SegTool2D*>(m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetToolById(i));
 
     if (manualSegmentationTool)
     {
       if(state == true)
       {
         manualSegmentationTool->SetShowMarkerNodes( true );
       }
       else
       {
         manualSegmentationTool->SetShowMarkerNodes( false );
       }
     }
   }
 }
 
 void QmitkSegmentationView::OnSelectionChanged(mitk::DataNode* node)
 {
   std::vector<mitk::DataNode*> nodes;
   nodes.push_back( node );
   this->OnSelectionChanged( nodes );
 }
 
 void QmitkSegmentationView::OnSurfaceSelectionChanged()
-{   
+{
   // if Image and Surface are selected, enable button
   if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
     (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()))
     m_Controls->CreateSegmentationFromSurface->setEnabled(false);
   else
     m_Controls->CreateSegmentationFromSurface->setEnabled(true);
 }
 
 void QmitkSegmentationView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
 {
   // if the selected node is a contourmarker
   if ( !nodes.empty() )
   {
     std::string markerName = "Position";
     unsigned int numberOfNodes = nodes.size();
     std::string nodeName = nodes.at( 0 )->GetName();
     if ( ( numberOfNodes == 1 ) && ( nodeName.find( markerName ) == 0) )
     {
       this->OnContourMarkerSelected( nodes.at( 0 ) );
     }
   }
 
   // if Image and Surface are selected, enable button
   if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
     (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()))
     m_Controls->CreateSegmentationFromSurface->setEnabled(false);
   else
     m_Controls->CreateSegmentationFromSurface->setEnabled(true);
 
-  if (!m_Parent || !m_Parent->isVisible()) return;
+  m_DataSelectionChanged = false;
+  if (!m_Parent || !m_Parent->isVisible())
+  {
+    m_DataSelectionChanged = true;
+    return;
+  }
 
   // reaction to BlueBerry selection events
   //   this method will try to figure out if a relevant segmentation and its corresponding original image were selected
   //   a warning is issued if the selection is invalid
   //   appropriate reactions are triggered otherwise
 
   mitk::DataNode::Pointer referenceData = FindFirstRegularImage( nodes ); //m_Controls->refImageSelector->GetSelectedNode(); //FindFirstRegularImage( nodes );
   mitk::DataNode::Pointer workingData =   FindFirstSegmentation( nodes );
 
   if(referenceData.IsNull() && workingData.IsNull())
     return;
 
   bool invalidSelection( !nodes.empty() &&
     (
     nodes.size() > 2 ||    // maximum 2 selected nodes
     (nodes.size() == 2 && (workingData.IsNull() || referenceData.IsNull()) ) || // with two nodes, one must be the original image, one the segmentation
     ( workingData.GetPointer() == referenceData.GetPointer() ) //one node is selected as reference and working image
     // one item is always ok (might be working or reference or nothing
     )
     );
 
   if (invalidSelection)
   {
     // TODO visible warning when two images are selected
     MITK_ERROR << "WARNING: No image, too many (>2) or two equal images were selected.";
     workingData = NULL;
 
     if( m_Controls->refImageSelector->GetSelectedNode().IsNull() )
       referenceData = NULL;
   }
 
   if ( workingData.IsNotNull() && referenceData.IsNull() )
   {
     // find the DataStorage parent of workingData
     // try to find a "normal image" parent, select this as reference image
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
     mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
     mitk::NodePredicateNot::Pointer isNotBinary = mitk::NodePredicateNot::New( isBinary );
     mitk::NodePredicateAnd::Pointer isNormalImage = mitk::NodePredicateAnd::New( isImage, isNotBinary );
 
     mitk::DataStorage::SetOfObjects::ConstPointer possibleParents = this->GetDefaultDataStorage()->GetSources( workingData, isNormalImage );
 
     if (possibleParents->size() > 0)
     {
       if (possibleParents->size() > 1)
       {
         // TODO visible warning for this rare case
         MITK_ERROR << "Selected binary image has multiple parents. Using arbitrary first one for segmentation.";
       }
 
       referenceData = (*possibleParents)[0];
     }
 
     NodeTagMapType::iterator searchIter = m_WorkingDataObserverTags.find( workingData );
     if ( searchIter == m_WorkingDataObserverTags.end() )
     {
       //MITK_INFO<<"Creating new observer";
       itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
       command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
       m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( workingData, workingData->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
       workingData->GetProperty("visible")->Modified();
 
       return;
     }
 
     if(workingData->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1"))))
     {
         //set comboBox to reference image
         disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
           this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
         m_Controls->refImageSelector->setCurrentIndex( m_Controls->refImageSelector->Find(workingData) );
 
         connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
           this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
 
         // if Image and Surface are selected, enable button
         if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
           (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()) ||
           (!referenceData))
           m_Controls->CreateSegmentationFromSurface->setEnabled(false);
         else
           m_Controls->CreateSegmentationFromSurface->setEnabled(true);
 
         SetToolManagerSelection(referenceData, workingData);
         FireNodeSelected(workingData);
     }
     else
     {
         SetToolManagerSelection(NULL, NULL);
         FireNodeSelected(workingData);
     }
 
   }
-  else 
+  else
   {
     //set comboBox to reference image
-    disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ), 
+    disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
       this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
     m_Controls->refImageSelector->setCurrentIndex( m_Controls->refImageSelector->Find(referenceData) );
 
-    connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ), 
+    connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
       this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
     // if Image and Surface are selected, enable button
     if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
       (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()) ||
       (!referenceData))
       m_Controls->CreateSegmentationFromSurface->setEnabled(false);
     else
       m_Controls->CreateSegmentationFromSurface->setEnabled(true);
 
     SetToolManagerSelection(referenceData, workingData);
 
     FireNodeSelected(referenceData);
   }
 }
 
 void QmitkSegmentationView::OnContourMarkerSelected(const mitk::DataNode *node)
 {
   //TODO renderWindow anders bestimmen, siehe CheckAlignment
   QmitkRenderWindow* selectedRenderWindow = 0;
   QmitkRenderWindow* RenderWindow1 =
     this->GetActiveStdMultiWidget()->GetRenderWindow1();
   QmitkRenderWindow* RenderWindow2 =
     this->GetActiveStdMultiWidget()->GetRenderWindow2();
   QmitkRenderWindow* RenderWindow3 =
     this->GetActiveStdMultiWidget()->GetRenderWindow3();
   QmitkRenderWindow* RenderWindow4 =
     this->GetActiveStdMultiWidget()->GetRenderWindow4();
   bool PlanarFigureInitializedWindow = false;
 
   // find initialized renderwindow
   if (node->GetBoolProperty("PlanarFigureInitializedWindow",
     PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
   {
     selectedRenderWindow = RenderWindow1;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     RenderWindow2->GetRenderer()))
   {
     selectedRenderWindow = RenderWindow2;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     RenderWindow3->GetRenderer()))
   {
     selectedRenderWindow = RenderWindow3;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     RenderWindow4->GetRenderer()))
   {
     selectedRenderWindow = RenderWindow4;
   }
 
   // make node visible
   if (selectedRenderWindow)
   {
     std::string nodeName = node->GetName();
     unsigned int t = nodeName.find_last_of(" ");
     unsigned int id = atof(nodeName.substr(t+1).c_str())-1;
 
     // gets the context of the "Mitk" (Core) module (always has id 1)
     // TODO Workaround until CTL plugincontext is available
     mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
     // Workaround end
     mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
     //mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
 
     mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
     selectedRenderWindow->GetSliceNavigationController()->ExecuteOperation(service->GetPlanePosition(id));
     selectedRenderWindow->GetRenderer()->GetDisplayGeometry()->Fit();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 mitk::DataNode::Pointer QmitkSegmentationView::FindFirstRegularImage( std::vector<mitk::DataNode*> nodes )
 {
   if (nodes.empty()) return NULL;
 
   for(unsigned int i = 0; i < nodes.size(); ++i)
   {
     //mitk::DataNode::Pointer node = i.value()
     bool isImage(false);
     if (nodes.at(i)->GetData())
     {
       isImage = dynamic_cast<mitk::Image*>(nodes.at(i)->GetData()) != NULL;
     }
 
     // make sure this is not a binary image
     bool isSegmentation(false);
     nodes.at(i)->GetBoolProperty("binary", isSegmentation);
 
     // return first proper mitk::Image
     if (isImage && !isSegmentation) return nodes.at(i);
   }
 
   return NULL;
 }
 
 
 mitk::DataNode::Pointer QmitkSegmentationView::FindFirstSegmentation( std::vector<mitk::DataNode*> nodes )
 {
   if (nodes.empty()) return NULL;
 
 
   for(unsigned int i = 0; i < nodes.size(); ++i)
   {
     bool isImage(false);
     if (nodes.at(i)->GetData())
     {
       isImage = dynamic_cast<mitk::Image*>(nodes.at(i)->GetData()) != NULL;
     }
 
     bool isSegmentation(false);
     nodes.at(i)->GetBoolProperty("binary", isSegmentation);
 
     // return first proper binary mitk::Image
-    if (isImage && isSegmentation) 
+    if (isImage && isSegmentation)
     {
       return nodes.at(i);
     }
   }
 
   return NULL;
 }
 
 void QmitkSegmentationView::SetToolManagerSelection(const mitk::DataNode* referenceData, const mitk::DataNode* workingData)
 {
   // called as a result of new BlueBerry selections
   //   tells the ToolManager for manual segmentation about new selections
   //   updates GUI information about what the user should select
   mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
   toolManager->SetReferenceData(const_cast<mitk::DataNode*>(referenceData));
   toolManager->SetWorkingData(  const_cast<mitk::DataNode*>(workingData));
 
 
   // check original image
   m_Controls->btnNewSegmentation->setEnabled(referenceData != NULL);
   if (referenceData)
   {
     m_Controls->lblReferenceImageSelectionWarning->hide();
   }
   else
   {
     m_Controls->lblReferenceImageSelectionWarning->show();
     m_Controls->lblWorkingImageSelectionWarning->hide();
     m_Controls->lblSegImage->hide();
     m_Controls->lblSegmentation->hide();
   }
 
   //TODO remove statement
   // check, wheter reference image is aligned like render windows. Otherwise display a visible warning (because 2D tools will probably not work)
   CheckImageAlignment();
 
   // check segmentation
   if (referenceData)
-  { 
+  {
     if (!workingData)
     {
       m_Controls->lblWorkingImageSelectionWarning->show();
 
       if( m_Controls->widgetStack->currentIndex() == 0 )
       {
         m_Controls->lblSegImage->hide();
         m_Controls->lblSegmentation->hide();
       }
     }
     else
     {
       m_Controls->lblWorkingImageSelectionWarning->hide();
       this->FireNodeSelected(const_cast<mitk::DataNode*>(workingData));
 
       if( m_Controls->widgetStack->currentIndex() == 0 )
       {
         m_Controls->lblSegmentation->setText( workingData->GetName().c_str() );
         m_Controls->lblSegmentation->show();
         m_Controls->lblSegImage->show();
       }
     }
   }
 }
 
 //TODO remove function
 void QmitkSegmentationView::CheckImageAlignment()
 {
   bool wrongAlignment(true);
 
   mitk::DataNode::Pointer node = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
   if (node.IsNotNull())
   {
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
 
     if (image.IsNotNull() && m_MultiWidget)
     {
 
       wrongAlignment = !(    IsRenderWindowAligned(m_MultiWidget->GetRenderWindow1(), image )
         && IsRenderWindowAligned(m_MultiWidget->GetRenderWindow2(), image )
         && IsRenderWindowAligned(m_MultiWidget->GetRenderWindow3(), image )
         );
     }
   }
   m_Controls->lblAlignmentWarning->setVisible(wrongAlignment);
 }
 
 //TODO remove function
 bool QmitkSegmentationView::IsRenderWindowAligned(QmitkRenderWindow* renderWindow, mitk::Image* image)
 {
   if (!renderWindow) return false;
 
   // for all 2D renderwindows of m_MultiWidget check alignment
   mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( renderWindow->GetRenderer()->GetCurrentWorldGeometry2D() );
   if (displayPlane.IsNull()) return false;
 
   int affectedDimension(-1);
   int affectedSlice(-1);
   return mitk::SegTool2D::DetermineAffectedImageSlice( image, displayPlane, affectedDimension, affectedSlice );
 }
 
 //TODO remove function
 void QmitkSegmentationView::ForceDisplayPreferencesUponAllImages()
 {
   if (!m_Parent || !m_Parent->isVisible()) return;
 
   // check all images and segmentations in DataStorage:
   // (items in brackets are implicitly done by previous steps)
   // 1.
   //   if  a reference image is selected,
   //     show the reference image
   //     and hide all other images (orignal and segmentation),
   //     (and hide all segmentations of the other original images)
   //     and show all the reference's segmentations
   //   if no reference image is selected, do do nothing
   //
   // 2.
   //   if  a segmentation is selected,
   //     show it
   //     (and hide all all its siblings (childs of the same parent, incl, NULL parent))
   //   if no segmentation is selected, do nothing
 
   if (!m_Controls) return; // might happen on initialization (preferences loaded)
   mitk::DataNode::Pointer referenceData = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
   mitk::DataNode::Pointer workingData =   m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0);
 
   // 1.
   if (referenceData.IsNotNull())
   {
     // iterate all images
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
 
     mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDefaultDataStorage()->GetSubset( isImage );
     //mitk::DataStorage::SetOfObjects::ConstPointer allSegmentationChilds = this->GetDefaultDataStorage()->GetDerivations(referenceData, isImage );
     for ( mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin();
       iter != allImages->end();
       ++iter)
 
     {
       mitk::DataNode* node = *iter;
       // apply display preferences
       ApplyDisplayOptions(node);
 
       // set visibility
       if(!node->IsSelected() || (node->IsSelected() && !node->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")))))
         node->SetVisibility((node == referenceData) || node->IsSelected() );
     }
   }
 
   // 2.
   //if (workingData.IsNotNull() && !workingData->IsSelected())
   //{
   //  workingData->SetVisibility(true);
   //}
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSegmentationView::ApplyDisplayOptions(mitk::DataNode* node)
 {
   if (!node) return;
 
   bool isBinary(false);
   node->GetPropertyValue("binary", isBinary);
 
   if (isBinary)
   {
     node->SetProperty( "outline binary", mitk::BoolProperty::New( this->GetPreferences()->GetBool("draw outline", true)) );
     node->SetProperty( "outline width", mitk::FloatProperty::New( 2.0 ) );
     node->SetProperty( "opacity", mitk::FloatProperty::New( this->GetPreferences()->GetBool("draw outline", true) ? 1.0 : 0.3 ) );
     node->SetProperty( "volumerendering", mitk::BoolProperty::New( this->GetPreferences()->GetBool("volume rendering", false) ) );
   }
 }
 
 void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
 {
   // setup the basic GUI of this view
   m_Parent = parent;
 
   m_Controls = new Ui::QmitkSegmentationControls;
   m_Controls->setupUi(parent);
   m_Controls->lblWorkingImageSelectionWarning->hide();
   m_Controls->lblAlignmentWarning->hide();
   m_Controls->lblSegImage->hide();
   m_Controls->lblSegmentation->hide();
 
   m_Controls->refImageSelector->SetDataStorage(this->GetDefaultDataStorage());
   m_Controls->refImageSelector->SetPredicate(mitk::NodePredicateDataType::New("Image"));
 
   if( m_Controls->refImageSelector->GetSelectedNode().IsNotNull() )
     m_Controls->lblReferenceImageSelectionWarning->hide();
   else
     m_Controls->refImageSelector->hide();
 
 
   mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
   toolManager->SetDataStorage( *(this->GetDefaultDataStorage()) );
   assert ( toolManager );
 
   // all part of open source MITK
   m_Controls->m_ManualToolSelectionBox->SetGenerateAccelerators(true);
   m_Controls->m_ManualToolSelectionBox->SetToolGUIArea( m_Controls->m_ManualToolGUIContainer );
   m_Controls->m_ManualToolSelectionBox->SetDisplayedToolGroups("Add Subtract Paint Wipe 'Region Growing' Correction Fill Erase");
   m_Controls->m_ManualToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingData );
 
   // available only in the 3M application
   if ( !m_Controls->m_OrganToolSelectionBox->children().count() )
   {
     m_Controls->widgetStack->setItemEnabled( 1, false );
   }
   m_Controls->m_OrganToolSelectionBox->SetToolManager( *toolManager );
   m_Controls->m_OrganToolSelectionBox->SetToolGUIArea( m_Controls->m_OrganToolGUIContainer );
   m_Controls->m_OrganToolSelectionBox->SetDisplayedToolGroups("'Hippocampus left' 'Hippocampus right' 'Lung left' 'Lung right' 'Liver' 'Heart LV' 'Endocard LV' 'Epicard LV' 'Prostate'");
   m_Controls->m_OrganToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceData );
 
   // available only in the 3M application
   if ( !m_Controls->m_LesionToolSelectionBox->children().count() )
   {
     m_Controls->widgetStack->setItemEnabled( 2, false );
   }
   m_Controls->m_LesionToolSelectionBox->SetToolManager( *toolManager );
   m_Controls->m_LesionToolSelectionBox->SetToolGUIArea( m_Controls->m_LesionToolGUIContainer );
   m_Controls->m_LesionToolSelectionBox->SetDisplayedToolGroups("'Lymph Node'");
   m_Controls->m_LesionToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceData );
 
   toolManager->NewNodesGenerated +=
     mitk::MessageDelegate<QmitkSegmentationView>( this, &QmitkSegmentationView::NewNodesGenerated );          // update the list of segmentations
   toolManager->NewNodeObjectsGenerated +=
     mitk::MessageDelegate1<QmitkSegmentationView, mitk::ToolManager::DataVectorType*>( this, &QmitkSegmentationView::NewNodeObjectsGenerated );          // update the list of segmentations
 
   // create signal/slot connections
-  connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ), 
+  connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
     this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
   connect( m_Controls->btnNewSegmentation, SIGNAL(clicked()), this, SLOT(CreateNewSegmentation()) );
   connect( m_Controls->CreateSegmentationFromSurface, SIGNAL(clicked()), this, SLOT(CreateSegmentationFromSurface()) );
-  connect( m_Controls->m_ManualToolSelectionBox, SIGNAL(ToolSelected(int)), this, SLOT(ManualToolSelected(int)) );
   connect( m_Controls->widgetStack, SIGNAL(currentChanged(int)), this, SLOT(ToolboxStackPageChanged(int)) );
 
-  connect(m_Controls->MaskSurfaces,  SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ), 
+  connect(m_Controls->MaskSurfaces,  SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
     this, SLOT( OnSurfaceSelectionChanged( ) ) );
 
-  connect(m_Controls->MaskSurfaces,  SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ), 
+  connect(m_Controls->MaskSurfaces,  SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
     this, SLOT( OnSurfaceSelectionChanged( ) ) );
 
   connect(m_Controls->m_SlicesInterpolator, SIGNAL(SignalShowMarkerNodes(bool)), this, SLOT(OnShowMarkerNodes(bool)));
 
   m_Controls->MaskSurfaces->SetDataStorage(this->GetDefaultDataStorage());
   m_Controls->MaskSurfaces->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
 
   //// create helper class to provide context menus for segmentations in data manager
   // m_PostProcessing = new QmitkSegmentationPostProcessing(this->GetDefaultDataStorage(), this, m_Parent);
 
 }
 
 //void QmitkSegmentationView::OnPlaneModeChanged(int i)
 //{
 //  //if plane mode changes, disable all tools
 //  if (m_MultiWidget)
 //  {
 //    mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
 //
 //    if (toolManager)
 //    {
 //      if (toolManager->GetActiveToolID() >= 0)
 //      {
 //        toolManager->ActivateTool(-1);
 //      }
 //      else
 //      {
 //        m_MultiWidget->EnableNavigationControllerEventListening();
 //      }
 //    }
 //  }
 //}
 
 
 // ATTENTION some methods for handling the known list of (organ names, colors) are defined in QmitkSegmentationOrganNamesHandling.cpp
 
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
index 86802542e1..e049f1327f 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
@@ -1,166 +1,166 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
-Copyright (c) German Cancer Research Center, 
+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 
+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 QmitkSegmentationView_h
 #define QmitkSegmentationView_h
 
 #include "QmitkFunctionality.h"
 
 #include <berryIBerryPreferences.h>
 
 #include "ui_QmitkSegmentationControls.h"
 
 
 class QmitkRenderWindow;
 // class QmitkSegmentationPostProcessing;
 
 /**
  * \ingroup ToolManagerEtAl
  * \ingroup org_mitk_gui_qt_segmentation_internal
  * \warning Implementation of this class is split up into two .cpp files to make things more compact. Check both this file and QmitkSegmentationOrganNamesHandling.cpp
  */
 class QmitkSegmentationView : public QmitkFunctionality
 {
   Q_OBJECT
-  
+
 public:
-  
+
   QmitkSegmentationView();
 
   virtual ~QmitkSegmentationView();
 
   typedef std::map<mitk::DataNode*, unsigned long> NodeTagMapType;
 
   /*!
     \brief Invoked when the DataManager selection changed
     */
   virtual void OnSelectionChanged(mitk::DataNode* node);
   virtual void OnSelectionChanged(std::vector<mitk::DataNode*> nodes);
-  
+
   // reaction to new segmentations being created by segmentation tools
   void NewNodesGenerated();
   void NewNodeObjectsGenerated(mitk::ToolManager::DataVectorType*);
-  
+
   // QmitkFunctionality's activate/deactivate
   virtual void Activated();
-  virtual void Deactivated();    
-  
+  virtual void Deactivated();
+  virtual void Visible();
+
   // QmitkFunctionality's changes regarding THE QmitkStdMultiWidget
   virtual void StdMultiWidgetAvailable(QmitkStdMultiWidget& stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
   virtual void StdMultiWidgetClosed(QmitkStdMultiWidget& stdMultiWidget);
-  
+
   // BlueBerry's notification about preference changes (e.g. from a dialog)
   virtual void OnPreferencesChanged(const berry::IBerryPreferences*);
-  
+
   // observer to mitk::RenderingManager's RenderingManagerViewsInitializedEvent event
   void RenderingManagerReinitialized(const itk::EventObject&);
-  
+
   // observer to mitk::SliceController's SliceRotation event
   void SliceRotation(const itk::EventObject&);
-  
+
   static const std::string VIEW_ID;
 
 protected slots:
-  
+
   void OnComboBoxSelectionChanged(const mitk::DataNode* node);
-  
+
   // reaction to the button "New segmentation"
   void CreateNewSegmentation();
-  
+
   // reaction to the button "New segmentation"
   void CreateSegmentationFromSurface();
-  
-  // called when a segmentation tool is activated
-  void ManualToolSelected(int id);
-  
+
   // called when one of "Manual", "Organ", "Lesion" pages of the QToolbox is selected
   void ToolboxStackPageChanged(int id);
-  
+
   void OnSurfaceSelectionChanged();
-  
+
   //called when the checkbox Remember Contour Positions is selected/deselected
 
   void OnWorkingNodeVisibilityChanged();
 
   void OnShowMarkerNodes(bool);
 
 protected:
-  
+
   // a type for handling lists of DataNodes
   typedef std::vector<mitk::DataNode*> NodeList;
-  
+
   // set available multiwidget
   void SetMultiWidget(QmitkStdMultiWidget* multiWidget);
-  
+
   // actively query the current selection of data manager
   //void PullCurrentDataManagerSelection();
-  
+
   // reactions to selection events from data manager (and potential other senders)
   //void BlueBerrySelectionChanged(berry::IWorkbenchPart::Pointer sourcepart, berry::ISelection::ConstPointer selection);
   mitk::DataNode::Pointer FindFirstRegularImage( std::vector<mitk::DataNode*> nodes );
   mitk::DataNode::Pointer FindFirstSegmentation( std::vector<mitk::DataNode*> nodes );
-  
+
   // propagate BlueBerry selection to ToolManager for manual segmentation
   void SetToolManagerSelection(const mitk::DataNode* referenceData, const mitk::DataNode* workingData);
-  
+
   // checks if selected reference image is aligned with the slices stack orientation of the StdMultiWidget
   void CheckImageAlignment();
-  
+
   // checks if given render window aligns with the slices of given image
   bool IsRenderWindowAligned(QmitkRenderWindow* renderWindow, mitk::Image* image);
-  
+
   // make sure all images/segmentations look as selected by the users in this view's preferences
   void ForceDisplayPreferencesUponAllImages();
-  
+
   // decorates a DataNode according to the user preference settings
   void ApplyDisplayOptions(mitk::DataNode* node);
-  
+
   // GUI setup
   void CreateQtPartControl(QWidget* parent);
-  
+
   // handling of a list of known (organ name, organ color) combination
   // ATTENTION these methods are defined in QmitkSegmentationOrganNamesHandling.cpp
   QStringList GetDefaultOrganColorString();
   void UpdateOrganList(QStringList& organColors, const QString& organname, mitk::Color colorname);
   void AppendToOrganList(QStringList& organColors, const QString& organname, int r, int g, int b);
-  
+
   // If a contourmarker is selected, the plane in the related widget will be reoriented according to the marker`s geometry
   void OnContourMarkerSelected (const mitk::DataNode* node);
 
   void NodeRemoved(const mitk::DataNode* node);
 
   // the Qt parent of our GUI (NOT of this object)
   QWidget* m_Parent;
-  
+
   // our GUI
   Ui::QmitkSegmentationControls * m_Controls;
-  
+
   // THE currently existing QmitkStdMultiWidget
   QmitkStdMultiWidget * m_MultiWidget;
-  
+
   // QmitkSegmentationPostProcessing* m_PostProcessing;
-  
+
   unsigned long m_RenderingManagerObserverTag;
   unsigned long m_SlicesRotationObserverTag1;
   unsigned long m_SlicesRotationObserverTag2;
   unsigned long m_VisibilityChangedObserverTag;
 
+  bool m_DataSelectionChanged;
+
   NodeTagMapType  m_WorkingDataObserverTags;
 };
 
 #endif /*QMITKsegmentationVIEW_H_*/
 
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
index 8e261b9e80..7cd337c354 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
@@ -1,455 +1,455 @@
 /*===================================================================
 
 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 "QmitkStdMultiWidgetEditor.h"
 
 #include <berryUIException.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryIPartListener.h>
 
 #include <QWidget>
 
 #include <mitkColorProperty.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 #include <mitkDataStorageEditorInput.h>
 #include <mitkIDataStorageService.h>
 
 #include <QmitkMouseModeSwitcher.h>
 #include <QmitkStdMultiWidget.h>
 
 #include <mbilogo.h>
 
 class QmitkStdMultiWidgetEditorPrivate
 {
 public:
 
   QmitkStdMultiWidgetEditorPrivate();
   ~QmitkStdMultiWidgetEditorPrivate();
 
   QmitkStdMultiWidget* m_StdMultiWidget;
   QmitkMouseModeSwitcher* m_MouseModeToolbar;
   std::string m_FirstBackgroundColor;
   std::string m_SecondBackgroundColor;
   bool m_MenuWidgetsEnabled;
   berry::IPartListener::Pointer m_PartListener;
 
   QHash<QString, QmitkRenderWindow*> m_RenderWindows;
 
 };
 
 struct QmitkStdMultiWidgetPartListener : public berry::IPartListener
 {
   berryObjectMacro(QmitkStdMultiWidgetPartListener)
 
   QmitkStdMultiWidgetPartListener(QmitkStdMultiWidgetEditorPrivate* dd)
     : d(dd)
   {}
 
   Events::Types GetPartEventTypes() const
   {
     return Events::CLOSED | Events::HIDDEN | Events::VISIBLE;
   }
 
   void PartClosed (berry::IWorkbenchPartReference::Pointer partRef)
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         d->m_StdMultiWidget->RemovePlanesFromDataStorage();
         stdMultiWidgetEditor->RequestActivateMenuWidget(false);
       }
     }
   }
 
   void PartHidden (berry::IWorkbenchPartReference::Pointer partRef)
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         d->m_StdMultiWidget->RemovePlanesFromDataStorage();
         stdMultiWidgetEditor->RequestActivateMenuWidget(false);
       }
     }
   }
 
   void PartVisible (berry::IWorkbenchPartReference::Pointer partRef)
   {
     if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
     {
       QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
 
       if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget())
       {
         d->m_StdMultiWidget->AddPlanesToDataStorage();
         stdMultiWidgetEditor->RequestActivateMenuWidget(true);
       }
     }
   }
 
 private:
 
   QmitkStdMultiWidgetEditorPrivate* const d;
 
 };
 
 QmitkStdMultiWidgetEditorPrivate::QmitkStdMultiWidgetEditorPrivate()
   : m_StdMultiWidget(0), m_MouseModeToolbar(0)
   , m_MenuWidgetsEnabled(false)
   , m_PartListener(new QmitkStdMultiWidgetPartListener(this))
 {}
 
 QmitkStdMultiWidgetEditorPrivate::~QmitkStdMultiWidgetEditorPrivate()
 {
 }
 
 const std::string QmitkStdMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.stdmultiwidget";
 
 QmitkStdMultiWidgetEditor::QmitkStdMultiWidgetEditor()
   : d(new QmitkStdMultiWidgetEditorPrivate)
 {
 }
 
 QmitkStdMultiWidgetEditor::~QmitkStdMultiWidgetEditor()
 {
   this->GetSite()->GetPage()->RemovePartListener(d->m_PartListener);
 }
 
 QmitkStdMultiWidget* QmitkStdMultiWidgetEditor::GetStdMultiWidget()
 {
   return d->m_StdMultiWidget;
 }
 
-QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetActiveRenderWindow() const
+QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetActiveQmitkRenderWindow() const
 {
   if (d->m_StdMultiWidget) return d->m_StdMultiWidget->GetRenderWindow1();
   return 0;
 }
 
-QHash<QString, QmitkRenderWindow *> QmitkStdMultiWidgetEditor::GetRenderWindows() const
+QHash<QString, QmitkRenderWindow *> QmitkStdMultiWidgetEditor::GetQmitkRenderWindows() const
 {
   return d->m_RenderWindows;
 }
 
-QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetRenderWindow(const QString &id) const
+QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetQmitkRenderWindow(const QString &id) const
 {
   static bool alreadyWarned = false;
 
   if(!alreadyWarned)
   {
-    MITK_WARN(id == "axial") << "QmitkStdMultiWidgetEditor::GetRenderWindow(\"transversal\") is deprecated. Use \"axial\" instead.";
+    MITK_WARN(id == "transversal") << "QmitkStdMultiWidgetEditor::GetRenderWindow(\"transversal\") is deprecated. Use \"axial\" instead.";
     alreadyWarned = true;
   }
 
   if (d->m_RenderWindows.contains(id))
     return d->m_RenderWindows[id];
 
   return 0;
 }
 
 mitk::Point3D QmitkStdMultiWidgetEditor::GetSelectedPosition(const QString & /*id*/) const
 {
   return d->m_StdMultiWidget->GetCrossPosition();
 }
 
 void QmitkStdMultiWidgetEditor::SetSelectedPosition(const mitk::Point3D &pos, const QString &/*id*/)
 {
   d->m_StdMultiWidget->MoveCrossToPosition(pos);
 }
 
 void QmitkStdMultiWidgetEditor::EnableDecorations(bool enable, const QStringList &decorations)
 {
   if (decorations.isEmpty() || decorations.contains(DECORATION_BORDER))
   {
     enable ? d->m_StdMultiWidget->EnableColoredRectangles()
            : d->m_StdMultiWidget->DisableColoredRectangles();
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_LOGO))
   {
     enable ? d->m_StdMultiWidget->EnableDepartmentLogo()
            : d->m_StdMultiWidget->DisableDepartmentLogo();
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_MENU))
   {
     d->m_StdMultiWidget->ActivateMenuWidget(enable);
   }
   if (decorations.isEmpty() || decorations.contains(DECORATION_BACKGROUND))
   {
     enable ? d->m_StdMultiWidget->EnableGradientBackground()
            : d->m_StdMultiWidget->DisableGradientBackground();
   }
 }
 
 bool QmitkStdMultiWidgetEditor::IsDecorationEnabled(const QString &decoration) const
 {
   if (decoration == DECORATION_BORDER)
   {
     return d->m_StdMultiWidget->IsColoredRectanglesEnabled();
   }
   else if (decoration == DECORATION_LOGO)
   {
     return d->m_StdMultiWidget->IsColoredRectanglesEnabled();
   }
   else if (decoration == DECORATION_MENU)
   {
     return d->m_StdMultiWidget->IsMenuWidgetEnabled();
   }
   else if (decoration == DECORATION_BACKGROUND)
   {
     return d->m_StdMultiWidget->GetGradientBackgroundFlag();
   }
   return false;
 }
 
 QStringList QmitkStdMultiWidgetEditor::GetDecorations() const
 {
   QStringList decorations;
   decorations << DECORATION_BORDER << DECORATION_LOGO << DECORATION_MENU << DECORATION_BACKGROUND;
   return decorations;
 }
 
 mitk::SlicesRotator* QmitkStdMultiWidgetEditor::GetSlicesRotator() const
 {
   return d->m_StdMultiWidget->GetSlicesRotator();
 }
 
 mitk::SlicesSwiveller* QmitkStdMultiWidgetEditor::GetSlicesSwiveller() const
 {
   return d->m_StdMultiWidget->GetSlicesSwiveller();
 }
 
 void QmitkStdMultiWidgetEditor::EnableSlicingPlanes(bool enable)
 {
   d->m_StdMultiWidget->SetWidgetPlanesVisibility(enable);
 }
 
 bool QmitkStdMultiWidgetEditor::IsSlicingPlanesEnabled() const
 {
   mitk::DataNode::Pointer node = this->d->m_StdMultiWidget->GetWidgetPlane1();
   if (node.IsNotNull())
   {
     bool visible = false;
     node->GetVisibility(visible, 0);
     return visible;
   }
   else
   {
     return false;
   }
 }
 
 void QmitkStdMultiWidgetEditor::EnableLinkedNavigation(bool enable)
 {
   enable ? d->m_StdMultiWidget->EnableNavigationControllerEventListening()
          : d->m_StdMultiWidget->DisableNavigationControllerEventListening();
 }
 
 bool QmitkStdMultiWidgetEditor::IsLinkedNavigationEnabled() const
 {
   return d->m_StdMultiWidget->IsCrosshairNavigationEnabled();
 }
 
 void QmitkStdMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
 {
   if (d->m_StdMultiWidget == 0)
   {
     QHBoxLayout* layout = new QHBoxLayout(parent);
     layout->setContentsMargins(0,0,0,0);
 
     if (d->m_MouseModeToolbar == NULL)
     {
       d->m_MouseModeToolbar = new QmitkMouseModeSwitcher(parent); // delete by Qt via parent
       layout->addWidget(d->m_MouseModeToolbar);
     }
 
     d->m_StdMultiWidget = new QmitkStdMultiWidget(parent);
 
     d->m_RenderWindows.insert("transversal", d->m_StdMultiWidget->GetRenderWindow1());
     d->m_RenderWindows.insert("axial", d->m_StdMultiWidget->GetRenderWindow1());
     d->m_RenderWindows.insert("sagittal", d->m_StdMultiWidget->GetRenderWindow2());
     d->m_RenderWindows.insert("coronal", d->m_StdMultiWidget->GetRenderWindow3());
     d->m_RenderWindows.insert("3d", d->m_StdMultiWidget->GetRenderWindow4());
     
     d->m_MouseModeToolbar->setMouseModeSwitcher( d->m_StdMultiWidget->GetMouseModeSwitcher() );
     connect( d->m_MouseModeToolbar, SIGNAL( MouseModeSelected(mitk::MouseModeSwitcher::MouseMode) ),
       d->m_StdMultiWidget, SLOT( MouseModeSelected(mitk::MouseModeSwitcher::MouseMode) ) );
 
     layout->addWidget(d->m_StdMultiWidget);
 
     mitk::DataStorage::Pointer ds = this->GetDataStorage();
 
     // Tell the multiWidget which (part of) the tree to render
     d->m_StdMultiWidget->SetDataStorage(ds);
 
     // Initialize views as axial, sagittal, coronar to all data objects in DataStorage
     // (from top-left to bottom)
     mitk::TimeSlicedGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
     mitk::RenderingManager::GetInstance()->InitializeViews(geo);
 
     // Initialize bottom-right view as 3D view
     d->m_StdMultiWidget->GetRenderWindow4()->GetRenderer()->SetMapperID(
       mitk::BaseRenderer::Standard3D );
 
     // Enable standard handler for levelwindow-slider
     d->m_StdMultiWidget->EnableStandardLevelWindow();
 
     // Add the displayed views to the tree to see their positions
     // in 2D and 3D
     d->m_StdMultiWidget->AddDisplayPlaneSubTree();
 
     d->m_StdMultiWidget->EnableNavigationControllerEventListening();
 
     // Store the initial visibility status of the menu widget.
     d->m_MenuWidgetsEnabled = d->m_StdMultiWidget->IsMenuWidgetEnabled();
 
     this->GetSite()->GetPage()->AddPartListener(d->m_PartListener);
 
     berry::IPreferences::Pointer prefs = this->GetPreferences();
     this->OnPreferencesChanged(dynamic_cast<berry::IBerryPreferences*>(prefs.GetPointer()));
 
     this->RequestUpdate();
   }
 }
 
 void QmitkStdMultiWidgetEditor::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   // Enable change of logo. If no DepartmentLogo was set explicitly, MBILogo is used.
   // Set new department logo by prefs->Set("DepartmentLogo", "PathToImage");
   std::vector<std::string> keys = prefs->Keys();
   
   for( int i = 0; i < keys.size(); ++i )
   {
     if( keys[i] == "DepartmentLogo")
     {
       std::string departmentLogoLocation = prefs->Get("DepartmentLogo", "");
 
       if (departmentLogoLocation.empty())
       {
         d->m_StdMultiWidget->DisableDepartmentLogo();
       }
       else
       {
         d->m_StdMultiWidget->SetDepartmentLogoPath(departmentLogoLocation.c_str());
         d->m_StdMultiWidget->EnableDepartmentLogo();
       }
       break;
     }
   }
  
   // preferences for gradient background
   float color = 255.0;
   QString firstColorName = QString::fromStdString (prefs->GetByteArray("first background color", ""));
   QColor firstColor(firstColorName);
   mitk::Color upper;
   if (firstColorName=="") // default values
   {
     upper[0] = 0.1;
     upper[1] = 0.1;
     upper[2] = 0.1;
   }
   else
   {
     upper[0] = firstColor.red() / color;
     upper[1] = firstColor.green() / color;
     upper[2] = firstColor.blue() / color;
   }
 
   QString secondColorName = QString::fromStdString (prefs->GetByteArray("second background color", ""));
   QColor secondColor(secondColorName);
   mitk::Color lower;
   if (secondColorName=="") // default values
   {
     lower[0] = 0.5;
     lower[1] = 0.5;
     lower[2] = 0.5;
   }
   else
   {
     lower[0] = secondColor.red() / color;
     lower[1] = secondColor.green() / color;
     lower[2] = secondColor.blue() / color;
   }
   d->m_StdMultiWidget->SetGradientBackgroundColors(upper, lower);
   d->m_StdMultiWidget->EnableGradientBackground();
 
   // Set preferences respecting zooming and padding
   bool constrainedZooming = prefs->GetBool("Use constrained zooming and padding", false);
 
   mitk::RenderingManager::GetInstance()->SetConstrainedPaddingZooming(constrainedZooming);
 
   mitk::NodePredicateNot::Pointer pred
     = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
     , mitk::BoolProperty::New(false)));
 
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
   // calculate bounding geometry of these nodes
 
   mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
 
   // initialize the views to the bounding geometry
   mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   // level window setting
   bool showLevelWindowWidget = prefs->GetBool("Show level/window widget", true);
   if (showLevelWindowWidget)
   {
     d->m_StdMultiWidget->EnableStandardLevelWindow();
   }
   else
   {
     d->m_StdMultiWidget->DisableStandardLevelWindow();
   }
 
   // mouse modes toolbar
   bool newMode = prefs->GetBool("PACS like mouse interaction", false);
   d->m_MouseModeToolbar->setVisible( newMode );
   d->m_StdMultiWidget->GetMouseModeSwitcher()->SetInteractionScheme( newMode ? mitk::MouseModeSwitcher::PACS : mitk::MouseModeSwitcher::MITK );
 }
 
 void QmitkStdMultiWidgetEditor::SetFocus()
 {
   if (d->m_StdMultiWidget != 0)
     d->m_StdMultiWidget->setFocus();
 }
 
 void QmitkStdMultiWidgetEditor::RequestActivateMenuWidget(bool on)
 {
   if (d->m_StdMultiWidget)
   {
     if (on)
     {
       d->m_StdMultiWidget->ActivateMenuWidget(d->m_MenuWidgetsEnabled);
     }
     else
     {
       d->m_MenuWidgetsEnabled = d->m_StdMultiWidget->IsMenuWidgetEnabled();
       d->m_StdMultiWidget->ActivateMenuWidget(false);
     }
   }
 }
 
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.h b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.h
index 8ef9b88c1e..7bad6ef6a5 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.h
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.h
@@ -1,120 +1,120 @@
 /*===================================================================
 
 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 QMITKSTDMULTIWIDGETEDITOR_H_
 #define QMITKSTDMULTIWIDGETEDITOR_H_
 
 #include <QmitkAbstractRenderEditor.h>
 
 #include <mitkILinkedRenderWindowPart.h>
 
 #include <org_mitk_gui_qt_stdmultiwidgeteditor_Export.h>
 
 class QmitkStdMultiWidget;
 class QmitkMouseModeSwitcher;
 class QmitkStdMultiWidgetEditorPrivate;
 
 /**
  * \ingroup org_mitk_gui_qt_stdmultiwidgeteditor
  */
 class ORG_MITK_GUI_QT_STDMULTIWIDGETEDITOR QmitkStdMultiWidgetEditor
     : public QmitkAbstractRenderEditor, public mitk::ILinkedRenderWindowPart
 {
   Q_OBJECT
 
 public:
 
   berryObjectMacro(QmitkStdMultiWidgetEditor)
 
   static const std::string EDITOR_ID;
 
   QmitkStdMultiWidgetEditor();
   ~QmitkStdMultiWidgetEditor();
 
   QmitkStdMultiWidget* GetStdMultiWidget();
 
   /// \brief If on=true will request the QmitkStdMultiWidget set the Menu widget to
   /// whatever was the last known enabled state, and if on=false will turn the Menu widget off.
   void RequestActivateMenuWidget(bool on);
 
   // -------------------  mitk::IRenderWindowPart  ----------------------
 
   /**
-   * \see mitk::IRenderWindowPart::GetActiveRenderWindow()
+   * \see mitk::IRenderWindowPart::GetActiveQmitkRenderWindow()
    */
-  QmitkRenderWindow* GetActiveRenderWindow() const;
+  QmitkRenderWindow* GetActiveQmitkRenderWindow() const;
 
   /**
-   * \see mitk::IRenderWindowPart::GetRenderWindows()
+   * \see mitk::IRenderWindowPart::GetQmitkRenderWindows()
    */
-  QHash<QString,QmitkRenderWindow*> GetRenderWindows() const;
+  QHash<QString,QmitkRenderWindow*> GetQmitkRenderWindows() const;
 
   /**
-   * \see mitk::IRenderWindowPart::GetRenderWindow(QString)
+   * \see mitk::IRenderWindowPart::GetQmitkRenderWindow(QString)
    */
-  QmitkRenderWindow* GetRenderWindow(const QString& id) const;
+  QmitkRenderWindow* GetQmitkRenderWindow(const QString& id) const;
 
   /**
    * \see mitk::IRenderWindowPart::GetSelectionPosition()
    */
   mitk::Point3D GetSelectedPosition(const QString& id = QString()) const;
 
   /**
    * \see mitk::IRenderWindowPart::SetSelectedPosition()
    */
   void SetSelectedPosition(const mitk::Point3D& pos, const QString& id = QString());
 
   /**
    * \see mitk::IRenderWindowPart::EnableDecorations()
    */
   void EnableDecorations(bool enable, const QStringList& decorations = QStringList());
 
   /**
    * \see mitk::IRenderWindowPart::IsDecorationEnabled()
    */
   bool IsDecorationEnabled(const QString& decoration) const;
 
   /**
    * \see mitk::IRenderWindowPart::GetDecorations()
    */
   QStringList GetDecorations() const;
 
   // -------------------  mitk::ILinkedRenderWindowPart  ----------------------
 
   mitk::SlicesRotator* GetSlicesRotator() const;
   mitk::SlicesSwiveller* GetSlicesSwiveller() const;
 
   void EnableSlicingPlanes(bool enable);
   bool IsSlicingPlanesEnabled() const;
 
   void EnableLinkedNavigation(bool enable);
   bool IsLinkedNavigationEnabled() const;
 
 protected:
 
   void SetFocus();
 
   void OnPreferencesChanged(const berry::IBerryPreferences*);
 
   void CreateQtPartControl(QWidget* parent);
 
 private:
 
   const QScopedPointer<QmitkStdMultiWidgetEditorPrivate> d;
 
 };
 
 #endif /*QMITKSTDMULTIWIDGETEDITOR_H_*/
diff --git a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
index e298de274e..81259d43d7 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
@@ -1,605 +1,605 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 // Blueberry
 #include <mitkIRenderingManager.h>
 #include <mitkIRenderWindowPart.h>
 #include <mitkILinkedRenderWindowPart.h>
 
 
 // Qmitk
 #include "QmitkToFUtilView.h"
 #include <QmitkStdMultiWidget.h>
 #include <QmitkTextOverlay.h>
 
 // Qt
 #include <QMessageBox>
 #include <QString>
 
 // MITK
 #include <mitkBaseRenderer.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkToFDistanceImageToPointSetFilter.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 
 // VTK
 #include <vtkCamera.h>
 
 // ITK
 #include <itkCommand.h>
 
 const std::string QmitkToFUtilView::VIEW_ID = "org.mitk.views.tofutil";
 
 QmitkToFUtilView::QmitkToFUtilView()
 : QmitkAbstractView()
 , m_Controls(NULL), m_MultiWidget( NULL )
 , m_MitkDistanceImage(NULL), m_MitkAmplitudeImage(NULL), m_MitkIntensityImage(NULL), m_Surface(NULL)
 , m_DistanceImageNode(NULL), m_AmplitudeImageNode(NULL), m_IntensityImageNode(NULL), m_RGBImageNode(NULL), m_SurfaceNode(NULL)
 , m_ToFImageRecorder(NULL), m_ToFImageGrabber(NULL), m_ToFDistanceImageToSurfaceFilter(NULL), m_ToFCompositeFilter(NULL)
 , m_SurfaceDisplayCount(0), m_2DDisplayCount(0)
 , m_RealTimeClock(NULL)
 , m_StepsForFramerate(100)
 , m_2DTimeBefore(0.0)
 , m_2DTimeAfter(0.0)
 , m_VideoEnabled(false)
 {
   this->m_Frametimer = new QTimer(this);
 
   this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
   this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
   this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
 }
 
 QmitkToFUtilView::~QmitkToFUtilView()
 {
         OnToFCameraStopped();
         OnToFCameraDisconnected();
 }
 
 void QmitkToFUtilView::SetFocus()
 {
   m_Controls->m_ToFConnectionWidget->setFocus();
 }
 
 void QmitkToFUtilView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkToFUtilViewControls;
     m_Controls->setupUi( parent );
 
     connect(m_Frametimer, SIGNAL(timeout()), this, SLOT(OnUpdateCamera()));
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraConnected()), this, SLOT(OnToFCameraConnected()) );
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraDisconnected()), this, SLOT(OnToFCameraDisconnected()) );
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraSelected(const QString)), this, SLOT(OnToFCameraSelected(const QString)) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStarted()), this, SLOT(OnToFCameraStarted()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStopped()), this, SLOT(OnToFCameraStopped()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStarted()), this, SLOT(OnToFCameraStopped()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStopped()), this, SLOT(OnToFCameraStarted()) );
     connect( (QObject*)(m_Controls->m_TextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnTextureCheckBoxChecked(bool)) );
     connect( (QObject*)(m_Controls->m_VideoTextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnVideoTextureCheckBoxChecked(bool)) );
   }
 }
 
 void QmitkToFUtilView::Activated()
 {
   //get the current RenderWindowPart or open a new one if there is none
   if(this->GetRenderWindowPart(OPEN))
   {
     mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
     if(linkedRenderWindowPart == 0)
     {
       MITK_ERROR << "No linked StdMultiWidget avaiable!!!";
     }
     else
     {
       linkedRenderWindowPart->EnableSlicingPlanes(false);
     }
     GetRenderWindowPart()->GetRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOn();
     GetRenderWindowPart()->GetRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOn();
     GetRenderWindowPart()->GetRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOn();
 
     this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews();
 
     this->UseToFVisibilitySettings(true);
 
     m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
     m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
 
     if (this->m_ToFImageGrabber.IsNull())
     {
       m_Controls->m_ToFRecorderWidget->setEnabled(false);
       m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
       m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
       m_Controls->tofMeasurementWidget->setEnabled(false);
       m_Controls->SurfacePropertiesBox->setEnabled(false);
     }
   }
 }
 
 void QmitkToFUtilView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer /*zombieView*/)
 {
   ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::Deactivated()
 {
 
 }
 
 void QmitkToFUtilView::Visible()
 {
 }
 
 void QmitkToFUtilView::Hidden()
 {
 
     ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::OnToFCameraConnected()
 {
   this->m_SurfaceDisplayCount = 0;
   this->m_2DDisplayCount = 0;
   this->m_ToFImageGrabber = m_Controls->m_ToFConnectionWidget->GetToFImageGrabber();
 
   this->m_ToFImageRecorder->SetCameraDevice(this->m_ToFImageGrabber->GetCameraDevice());
   m_Controls->m_ToFRecorderWidget->SetParameter(this->m_ToFImageGrabber, this->m_ToFImageRecorder);
   m_Controls->m_ToFRecorderWidget->setEnabled(true);
   m_Controls->m_ToFRecorderWidget->ResetGUIToInitial();
 
   // initialize measurement widget
-  m_Controls->tofMeasurementWidget->InitializeWidget(this->GetRenderWindowPart()->GetRenderWindows(),this->GetDataStorage());
+  m_Controls->tofMeasurementWidget->InitializeWidget(this->GetRenderWindowPart()->GetQmitkRenderWindows(),this->GetDataStorage());
 
   //TODO
   this->m_RealTimeClock = mitk::RealTimeClock::New();
   this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
 
   try
   {
     this->m_VideoSource = mitk::OpenCVVideoSource::New();
 
     this->m_VideoSource->SetVideoCameraInput(0, false);
     this->m_VideoSource->StartCapturing();
     if(!this->m_VideoSource->IsCapturingEnabled())
     {
       MITK_INFO << "unable to initialize video grabbing/playback";
       this->m_VideoEnabled = false;
       m_Controls->m_VideoTextureCheckBox->setEnabled(false);
     }
     else
     {
       this->m_VideoEnabled = true;
       m_Controls->m_VideoTextureCheckBox->setEnabled(true);
     }
 
     if (this->m_VideoEnabled)
     {
 
       this->m_VideoSource->FetchFrame();
       this->m_VideoCaptureHeight = this->m_VideoSource->GetImageHeight();
       this->m_VideoCaptureWidth = this->m_VideoSource->GetImageWidth();
       this->m_VideoTexture = this->m_VideoSource->GetVideoTexture();
 
       this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageWidth(this->m_VideoCaptureWidth);
       this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageHeight(this->m_VideoCaptureHeight);
 
 
       this->m_ToFSurfaceVtkMapper3D->SetTextureWidth(this->m_VideoCaptureWidth);
       this->m_ToFSurfaceVtkMapper3D->SetTextureHeight(this->m_VideoCaptureHeight);
     }
   }
   catch (std::logic_error& e)
   {
     QMessageBox::warning(NULL, "Warning", QString(e.what()));
     MITK_ERROR << e.what();
     return;
   }
 
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkToFUtilView::ResetGUIToDefault()
 {
   if(this->GetRenderWindowPart())
   {
     mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
     if(linkedRenderWindowPart == 0)
     {
       MITK_ERROR << "No linked StdMultiWidget avaiable!!!";
     }
     else
     {
       linkedRenderWindowPart->EnableSlicingPlanes(true);
     }
     GetRenderWindowPart()->GetRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOff();
     GetRenderWindowPart()->GetRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
     GetRenderWindowPart()->GetRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOff();
     GetRenderWindowPart()->GetRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
     GetRenderWindowPart()->GetRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOff();
 
     this->UseToFVisibilitySettings(false);
 
     //global reinit
     this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(/*this->GetDataStorage()->ComputeBoundingGeometry3D(this->GetDataStorage()->GetAll())*/);
     this->RequestRenderWindowUpdate();
   }
 }
 
 void QmitkToFUtilView::OnToFCameraDisconnected()
 {
   m_Controls->m_ToFRecorderWidget->OnStop();
   m_Controls->m_ToFRecorderWidget->setEnabled(false);
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
   m_Controls->tofMeasurementWidget->setEnabled(false);
   m_Controls->SurfacePropertiesBox->setEnabled(false);
   //clean up measurement widget
   m_Controls->tofMeasurementWidget->CleanUpWidget();
 
   if(this->m_VideoSource)
   {
     this->m_VideoSource->StopCapturing();
     this->m_VideoSource = NULL;
   }
 }
 
 void QmitkToFUtilView::OnToFCameraStarted()
 {
   if (m_ToFImageGrabber.IsNotNull())
   {
     // initial update of image grabber
     this->m_ToFImageGrabber->Update();
 
     this->m_ToFCompositeFilter->SetInput(0,this->m_ToFImageGrabber->GetOutput(0));
     this->m_ToFCompositeFilter->SetInput(1,this->m_ToFImageGrabber->GetOutput(1));
     this->m_ToFCompositeFilter->SetInput(2,this->m_ToFImageGrabber->GetOutput(2));
 
     // initial update of composite filter
     this->m_ToFCompositeFilter->Update();
     this->m_MitkDistanceImage = m_ToFCompositeFilter->GetOutput(0);
     this->m_DistanceImageNode = ReplaceNodeData("Distance image",m_MitkDistanceImage);
     this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
     this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
     this->m_MitkIntensityImage = m_ToFCompositeFilter->GetOutput(2);
     this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
 
     std::string rgbFileName;
     m_ToFImageGrabber->GetCameraDevice()->GetStringProperty("RGBImageFileName",rgbFileName);
     if ((m_SelectedCamera=="Microsoft Kinect")||(rgbFileName!=""))
     {
       this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
     }
     else
     {
       this->m_RGBImageNode = NULL;
     }
 
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(0,m_MitkDistanceImage);
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(1,m_MitkAmplitudeImage);
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(2,m_MitkIntensityImage);
     this->m_Surface = this->m_ToFDistanceImageToSurfaceFilter->GetOutput(0);
     this->m_SurfaceNode = ReplaceNodeData("Surface",m_Surface);
 
     this->UseToFVisibilitySettings(true);
 
     m_Controls->m_ToFCompositeFilterWidget->UpdateFilterParameter();
     // initialize visualization widget
     m_Controls->m_ToFVisualisationSettingsWidget->Initialize(this->m_DistanceImageNode, this->m_AmplitudeImageNode, this->m_IntensityImageNode);
     // set distance image to measurement widget
     m_Controls->tofMeasurementWidget->SetDistanceImage(m_MitkDistanceImage);
 
     this->m_Frametimer->start(0);
 
     m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(true);
     m_Controls->m_ToFCompositeFilterWidget->setEnabled(true);
     m_Controls->tofMeasurementWidget->setEnabled(true);
     m_Controls->SurfacePropertiesBox->setEnabled(true);
 
     if (m_Controls->m_TextureCheckBox->isChecked())
     {
       OnTextureCheckBoxChecked(true);
     }
     if (m_Controls->m_VideoTextureCheckBox->isChecked())
     {
       OnVideoTextureCheckBoxChecked(true);
     }
   }
   m_Controls->m_TextureCheckBox->setEnabled(true);
 }
 
 void QmitkToFUtilView::OnToFCameraStopped()
 {
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
   m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
   m_Controls->tofMeasurementWidget->setEnabled(false);
   m_Controls->SurfacePropertiesBox->setEnabled(false);
 
   this->m_Frametimer->stop();
 }
 
 void QmitkToFUtilView::OnToFCameraSelected(const QString selected)
 {
   m_SelectedCamera = selected;
   if ((selected=="PMD CamBoard")||(selected=="PMD O3D"))
   {
     MITK_INFO<<"Surface representation currently not available for CamBoard and O3. Intrinsic parameters missing.";
     this->m_Controls->m_SurfaceCheckBox->setEnabled(false);
     this->m_Controls->m_TextureCheckBox->setEnabled(false);
     this->m_Controls->m_VideoTextureCheckBox->setEnabled(false);
     this->m_Controls->m_SurfaceCheckBox->setChecked(false);
     this->m_Controls->m_TextureCheckBox->setChecked(false);
     this->m_Controls->m_VideoTextureCheckBox->setChecked(false);
   }
   else
   {
     this->m_Controls->m_SurfaceCheckBox->setEnabled(true);
     this->m_Controls->m_TextureCheckBox->setEnabled(true); // TODO enable when bug 8106 is solved
     this->m_Controls->m_VideoTextureCheckBox->setEnabled(true);
   }
 }
 
 void QmitkToFUtilView::OnUpdateCamera()
 {
   if (m_Controls->m_VideoTextureCheckBox->isChecked() && this->m_VideoEnabled && this->m_VideoSource)
   {
     this->m_VideoTexture = this->m_VideoSource->GetVideoTexture();
     ProcessVideoTransform();
   }
 
   if (m_Controls->m_SurfaceCheckBox->isChecked())
   {
     // update surface
     m_ToFDistanceImageToSurfaceFilter->SetTextureIndex(m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedImageIndex());
     this->m_Surface->Update();
 
     vtkColorTransferFunction* colorTransferFunction = m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedColorTransferFunction();
 
     this->m_ToFSurfaceVtkMapper3D->SetVtkScalarsToColors(colorTransferFunction);
 
     if (this->m_SurfaceDisplayCount<2)
     {
       this->m_SurfaceNode->SetData(this->m_Surface);
       this->m_SurfaceNode->SetMapper(mitk::BaseRenderer::Standard3D, m_ToFSurfaceVtkMapper3D);
 
       this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(
         this->m_Surface->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS, true);
 
       mitk::Point3D surfaceCenter= this->m_Surface->GetGeometry()->GetCenter();
       vtkCamera* camera3d = GetRenderWindowPart()->GetRenderWindow("3d")->GetRenderer()->GetVtkRenderer()->GetActiveCamera();
       camera3d->SetPosition(0,0,-50);
       camera3d->SetViewUp(0,-1,0);
       camera3d->SetFocalPoint(0,0,surfaceCenter[2]);
       camera3d->SetViewAngle(40);
       camera3d->SetClippingRange(1, 10000);
     }
     this->m_SurfaceDisplayCount++;
 
   }
   else
   {
     // update pipeline
     this->m_MitkDistanceImage->Update();
   }
 
   this->RequestRenderWindowUpdate();
 
   this->m_2DDisplayCount++;
   if ((this->m_2DDisplayCount % this->m_StepsForFramerate) == 0)
   {
     this->m_2DTimeAfter = this->m_RealTimeClock->GetCurrentStamp() - this->m_2DTimeBefore;
     MITK_INFO << " 2D-Display-framerate (fps): " << this->m_StepsForFramerate / (this->m_2DTimeAfter/1000);
     this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
   }
 }
 
 void QmitkToFUtilView::ProcessVideoTransform()
 {
   IplImage *src, *dst;
   src = cvCreateImageHeader(cvSize(this->m_VideoCaptureWidth, this->m_VideoCaptureHeight), IPL_DEPTH_8U, 3);
   src->imageData = (char*)this->m_VideoTexture;
 
   CvPoint2D32f srcTri[3], dstTri[3];
   CvMat* rot_mat = cvCreateMat(2,3,CV_32FC1);
   CvMat* warp_mat = cvCreateMat(2,3,CV_32FC1);
   dst = cvCloneImage(src);
   dst->origin = src->origin;
   cvZero( dst );
 
   int xOffset = 0;//m_Controls->m_XOffsetSpinBox->value();
   int yOffset = 0;//m_Controls->m_YOffsetSpinBox->value();
   int zoom = 0;//m_Controls->m_ZoomSpinBox->value();
 
   // Compute warp matrix
   srcTri[0].x = 0 + zoom;
   srcTri[0].y = 0 + zoom;
   srcTri[1].x = src->width - 1 - zoom;
   srcTri[1].y = 0 + zoom;
   srcTri[2].x = 0 + zoom;
   srcTri[2].y = src->height - 1 - zoom;
 
   dstTri[0].x = 0;
   dstTri[0].y = 0;
   dstTri[1].x = src->width - 1;
   dstTri[1].y = 0;
   dstTri[2].x = 0;
   dstTri[2].y = src->height - 1;
 
   cvGetAffineTransform( srcTri, dstTri, warp_mat );
   cvWarpAffine( src, dst, warp_mat );
   cvCopy ( dst, src );
 
 
   // Compute warp matrix
   srcTri[0].x = 0;
   srcTri[0].y = 0;
   srcTri[1].x = src->width - 1;
   srcTri[1].y = 0;
   srcTri[2].x = 0;
   srcTri[2].y = src->height - 1;
 
   dstTri[0].x = srcTri[0].x + xOffset;
   dstTri[0].y = srcTri[0].y + yOffset;
   dstTri[1].x = srcTri[1].x + xOffset;
   dstTri[1].y = srcTri[1].y + yOffset;
   dstTri[2].x = srcTri[2].x + xOffset;
   dstTri[2].y = srcTri[2].y + yOffset;
 
   cvGetAffineTransform( srcTri, dstTri, warp_mat );
   cvWarpAffine( src, dst, warp_mat );
   cvCopy ( dst, src );
 
   src->imageData = NULL;
   cvReleaseImage( &src );
   cvReleaseImage( &dst );
   cvReleaseMat( &rot_mat );
   cvReleaseMat( &warp_mat );
 
 }
 
 void QmitkToFUtilView::OnTextureCheckBoxChecked(bool checked)
 {
   if(m_SurfaceNode.IsNotNull())
   {
     if (checked)
     {
       this->m_SurfaceNode->SetBoolProperty("scalar visibility", true);
     }
     else
     {
       this->m_SurfaceNode->SetBoolProperty("scalar visibility", false);
     }
   }
 }
 
 void QmitkToFUtilView::OnVideoTextureCheckBoxChecked(bool checked)
 {
   if (checked)
   {
     if (this->m_VideoEnabled)
     {
       this->m_ToFSurfaceVtkMapper3D->SetTexture(this->m_VideoTexture);
     }
     else
     {
       this->m_ToFSurfaceVtkMapper3D->SetTexture(NULL);
     }
   }
 }
 
 void QmitkToFUtilView::OnChangeCoronalWindowOutput(int index)
 {
   this->OnToFCameraStopped();
   if(index == 0)
   {
     if(this->m_IntensityImageNode.IsNotNull())
       this->m_IntensityImageNode->SetVisibility(false);
     if(this->m_RGBImageNode.IsNotNull())
       this->m_RGBImageNode->SetVisibility(true);
   }
   else if(index == 1)
   {
     if(this->m_IntensityImageNode.IsNotNull())
       this->m_IntensityImageNode->SetVisibility(true);
     if(this->m_RGBImageNode.IsNotNull())
       this->m_RGBImageNode->SetVisibility(false);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->OnToFCameraStarted();
 }
 
 mitk::DataNode::Pointer QmitkToFUtilView::ReplaceNodeData( std::string nodeName, mitk::BaseData* data )
 {
 
   mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode(nodeName);
   if (node.IsNull())
   {
     node = mitk::DataNode::New();
     node->SetData(data);
     node->SetName(nodeName);
     node->SetBoolProperty("binary",false);
     this->GetDataStorage()->Add(node);
   }
   else
   {
     node->SetData(data);
   }
   return node;
 }
 
 void QmitkToFUtilView::UseToFVisibilitySettings(bool useToF)
 {
   // set node properties
   if (m_DistanceImageNode.IsNotNull())
   {
     this->m_DistanceImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("sagittal")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("coronal")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("3d")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetBoolProperty("use color",!useToF);
     this->m_DistanceImageNode->GetPropertyList()->DeleteProperty("LookupTable");
   }
   if (m_AmplitudeImageNode.IsNotNull())
   {
     this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("axial")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("coronal")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("3d")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetBoolProperty("use color",!useToF);
     this->m_AmplitudeImageNode->GetPropertyList()->DeleteProperty("LookupTable");
   }
   if (m_IntensityImageNode.IsNotNull())
   {
     this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
     this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("axial")->GetRenderWindow() ) );
     this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("sagittal")->GetRenderWindow() ) );
     this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("3d")->GetRenderWindow() ) );
     this->m_IntensityImageNode->SetBoolProperty("use color",!useToF);
     this->m_IntensityImageNode->GetPropertyList()->DeleteProperty("LookupTable");
   }
   if ((m_RGBImageNode.IsNotNull()))
   {
     this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
     this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("axial")->GetRenderWindow() ) );
     this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("sagittal")->GetRenderWindow() ) );
     this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("3d")->GetRenderWindow() ) );
   }
   // initialize images
   if (m_MitkDistanceImage.IsNotNull())
   {
     this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(
       this->m_MitkDistanceImage->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS, true);
   }
   if(this->m_SurfaceNode.IsNotNull())
   {
-    QHash<QString, QmitkRenderWindow*> renderWindowHashMap = this->GetRenderWindowPart()->GetRenderWindows();
+    QHash<QString, QmitkRenderWindow*> renderWindowHashMap = this->GetRenderWindowPart()->GetQmitkRenderWindows();
     QHashIterator<QString, QmitkRenderWindow*> i(renderWindowHashMap);
     while (i.hasNext()){
       i.next();
       this->m_SurfaceNode->SetVisibility( false, mitk::BaseRenderer::GetInstance(i.value()->GetRenderWindow()) );
     }
     this->m_SurfaceNode->SetVisibility( true, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("3d")->GetRenderWindow() ) );
   }
   //disable/enable gradient background
   this->GetRenderWindowPart()->EnableDecorations(!useToF, QStringList(QString("background")));
 }
diff --git a/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualizationUserManual.dox b/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualizationUserManual.dox
index c69d9027ee..dbe3b81009 100644
--- a/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualizationUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualizationUserManual.dox
@@ -1,150 +1,150 @@
 /**
-\page org_volvis The Volume Visualization Module
+\page org_mitk_views_volumevisualization The Volume Visualization Plugin
 
-\image html icon.png "Icon of the Module"
+\image html icon.png "Icon of the Plugin"
 
 Available sections:
 <ul>
 <li> \ref QVV_Overview
 <li> \ref QVV_EnableVRPage
 <li> \ref QVV_PresetPage
 <li> \ref QVV_ThresholdBell
 <li> \ref QVV_Editing
 </ul>
 
 \section QVV_Overview Overview
 
-The <b> Volume Visualization Module </b> is a basic tool for visualizing three dimensional medical images. 
+The <b> Volume Visualization Plugin </b> is a basic tool for visualizing three dimensional medical images. 
 MITK provides generic transfer function presets for medical CT data. 
 These functions, that map the gray-value to color and opacity, can be interactively edited. 
 Additionally, there are controls to quickly generate common used transfer function shapes 
 like the threshold and bell curve to help identify a range of grey-values.
 
 \image html vroverview.png ""
 
 \section QVV_EnableVRPage Enable Volume Rendering
 
 \subsection QVV_LoadingImage Loading an image into the application
 
 Load an image into the application by
 
 <ul>
 <li> dragging a file into the application window.
 <li> selecting file / load from the menu.
 </ul>
 
 Volume Visualization imposes following restrictions on images:
 
 <ul>
 <li> It has to be a 3D-Image Scalar image, that means a normal CT or MRT.
 <li> 3D+T are supported for rendering, but the histograms are not computed.
 <li> Also be aware that volume visualization requires a huge amount of memory. 
      Very large images may not work, unless you use the 64bit version.
 </ul>
 
 \subsection QVV_EnableVR Enable Volumerendering
 
 \image html checkboxen.png ""
 
 Select an image in datamanager and click on the checkbox left of "Volumerendering".
 Please be patient, while the image is prepared for rendering, which can take up to a half minute.
 
 \subsection QVV_LODGPU The LOD & GPU checkboxes
 
 Volume Rendering requires a lot of computing resources including processor, memory and graphics card.
 
 To run volume rendering on smaller platforms,
 enable the LOD checkbox (level-of-detail rendering).
 Level-of-detail first renders a lower quality preview to increase interactivity.
 If the user stops to interact a normal quality rendering is issued.
 
 The GPU checkbox tries to use computing resources on the graphics card to accelerate volume rendering.
 It requires a powerful graphics card and OpenGL hardware support for shaders, but achieves much higher frame rates than software-rendering.
 
 \section QVV_PresetPage Applying premade presets
 
 \subsection QVV_Preset Internal presets
 
 There are some internal presets given, that can be used with normal CT data (given in Houndsfield units).
 A large set of medical data has been tested with that presets, but it may not suit on some special cases.
 
 Click on the "Preset" tab for using internal or custom presets.
 
 \image html mitkInternalPresets.png ""
 
 <ul>
 <li> "CT Generic" is the default transferfunction that is first applied.  
 <li> "CT Black&White" does not use any colors, as it may be distracting on some data.
 <li> "CT Cardiac" tries to increase detail on CTs from the heart. 
 <li> "CT Bone" emphasizes bones and shows other areas more transparent. 
 <li> "CT Bone (Gradient)" is like "CT Bone", but shows  from other organs only the surface by using the gradient.
 <li> "MR Generic" is the default transferfunction that we use on MRT data (which is not normalized like CT data).  
 <li> "CT Thorax small" tries to increase detail.  
 <li> "CT Thorax large" tries to increase detail.  
 </ul>
 
 \subsection QVV_CustomPreset Saving and loading custom presets
 
 After creating or editing a transferfunction (see \ref QVV_Editing or \ref QVV_ThresholdBell), 
 the custom transferfunction can be stored and later retrieved on the filesystem.
 Click "Save" (respectively "Load") button to save (load) the threshold-, color- and gradient function combined in a single .xml file.
 
 \section QVV_ThresholdBell Interactively create transferfunctions
 
 Beside the possibility to directly edit the transferfunctions (\ref QVV_Editing),
 a one-click generation of two commonly known shapes is given.
 
 Both generators have two parameters, that can be modified by first clicking on the cross and then moving the mouse up/down and left/right.
 
 The first parameter "center" (controlled by horizontal movement of the mouse) specifies the gravalue where the center of the shape will be located.
 
 The second parameter "width" (controlled by vertical movement of the mouse) specifies the width (or steepness) of the shape.
 
 \subsection Threshold
 
 Click on the "Threshold" tab to active the threshold function generator.
 \image html threshold.png ""
 A threshold shape begins with zero and raises to one across the "center" parameter. Lower widths results in steeper threshold functions.
 
 \subsection Bell
 
 Click on the "Bell" tab to active the threshold function generator.
 \image html bell.png ""
 A threshold shape begins with zero and raises to one at the "center" parameter and the lowers agains to zero. The "width" parameter correspondens to the width of the bell.
 
 \section QVV_Editing Customize transferfunctions in detail
 
 \subsection QVV_Navigate Choosing grayvalue interval to edit
 
 \image html slider.png ""
 To navigate across the grayvalue range or to zoom in some ranges use the "range"-slider.
 
 All three function editors have in common following:
 
 <ul>
 <li> By left-clicking a new point is added.
 <li> By right-clicking a point is deleted.
 <li> By left-clicking and holding, an exisiting point can be dragged.
 <li> By pressing arrow keys, the currently selected point is moved.
 <li> By pressing the "DELETE" key, the currently selected point is deleted.
 <li> Between points the transferfunctions are linear interpolated.
 </ul>
 
 There are three transferfunctions to customize:
 
 \subsection QVV_GO Grayvalue -> Opacity
 
 \image html opacity.png "grayvalues will be mapped to opacity." 
 An opacity of 0 means total transparent, an opacity of 1 means total opaque.  
 
 \subsection QVV_GC Grayvalue -> Color
 
 \image html color.png "grayvalues will be mapped to color." 
 The color transferfunction editor also allows by double-clicking a point to change its color.
 
 \subsection QVV_GGO Grayvalue and Gradient -> Opacity
 
 \image html gradient.png ""
 Here the influence of the gradient is controllable at specific grayvalues. 
 
 */
diff --git a/mitkVersion.h.in b/mitkVersion.h.in
index 8047bcae0d..4849c4876a 100644
--- a/mitkVersion.h.in
+++ b/mitkVersion.h.in
@@ -1,13 +1,13 @@
 /*
   mitkVersion.h
   this file is generated. Do not change!
 */
 
 #define MITK_VERSION_MAJOR @MITK_VERSION_MAJOR@
 #define MITK_VERSION_MINOR @MITK_VERSION_MINOR@
 #define MITK_VERSION_PATCH @MITK_VERSION_PATCH@
 #define MITK_VERSION_STRING "@MITK_VERSION_STRING@"
 
 #define MITK_REVISION "@MITK_REVISION_ID@"
 #define MITK_REVISION_NAME "@MITK_REVISION_NAME@"
-
+#define MITK_REVISION_DESC "@MITK_REVISION_DESC@"