diff --git a/Applications/Diffusion/CMakeLists.txt b/Applications/Diffusion/CMakeLists.txt
index a07c306ded..3d7b42d903 100644
--- a/Applications/Diffusion/CMakeLists.txt
+++ b/Applications/Diffusion/CMakeLists.txt
@@ -1,80 +1,81 @@
 project(MitkDiffusion)
 
 set(DIFFUSIONAPP_NAME MitkDiffusion)
 
 set(_app_options)
 if(MITK_SHOW_CONSOLE_WINDOW)
   list(APPEND _app_options SHOW_CONSOLE)
 endif()
 
 # Create a cache entry for the provisioning file which is used to export
 # the file name in the MITKConfig.cmake file. This will keep external projects
 # which rely on this file happy.
 set(DIFFUSIONIMAGINGAPP_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${DIFFUSIONAPP_NAME}.provisioning" CACHE INTERNAL "${DIFFUSIONAPP_NAME} provisioning file" FORCE)
 
 set(_plugins
   org.commontk.configadmin
   org.commontk.eventadmin
   org.blueberry.osgi
   org.blueberry.compat
   org.blueberry.core.runtime
   org.blueberry.core.expressions
   org.blueberry.solstice.common
   org.blueberry.core.commands
   org.blueberry.ui
   org.blueberry.ui.qt
   org.blueberry.ui.qt.log
   org.blueberry.ui.qt.help
   org.mitk.core.services
   org.mitk.gui.common
   org.mitk.planarfigure
   org.mitk.core.ext
   org.mitk.diffusionimaging
   org.mitk.gui.qt.application
   org.mitk.gui.qt.ext
   org.mitk.gui.qt.diffusionimagingapp
   org.mitk.gui.qt.common
   org.mitk.gui.qt.stdmultiwidgeteditor
   org.mitk.gui.qt.common.legacy
   org.mitk.gui.qt.datamanager
   org.mitk.gui.qt.measurementtoolbox
   org.mitk.gui.qt.segmentation
   org.mitk.gui.qt.volumevisualization
   org.mitk.gui.qt.diffusionimaging
   org.mitk.gui.qt.imagenavigator
   org.mitk.gui.qt.moviemaker
   org.mitk.gui.qt.basicimageprocessing
   org.mitk.gui.qt.registration
   org.mitk.gui.qt.properties
+  org.mitk.gui.qt.viewbrowser
 )
 
 # Plug-ins listed below will not be
 #  - added as a build-time dependency to the executable
 #  - listed in the provisioning file for the executable
 #  - installed if they are external plug-ins
 
 set(_exclude_plugins
   org.blueberry.test
   org.blueberry.uitest
   org.mitk.gui.qt.coreapplication
   org.mitk.gui.qt.extapplication
 )
 
 FunctionCreateBlueBerryApplication(
   NAME ${DIFFUSIONAPP_NAME}
   DESCRIPTION "MITK Diffusion"
   PLUGINS ${_plugins}
   EXCLUDE_PLUGINS ${_exclude_plugins}
   ${_app_options}
 )
 mitk_use_modules(TARGET ${DIFFUSIONAPP_NAME} MODULES qtsingleapplication)
 
 # Add meta dependencies (e.g. on auto-load modules from depending modules)
 if(ALL_META_DEPENDENCIES)
   add_dependencies(${DIFFUSIONAPP_NAME} ${ALL_META_DEPENDENCIES})
 endif()
 
 # Add a build time dependency to legacy BlueBerry bundles.
 if(MITK_MODULES_ENABLED_PLUGINS)
   add_dependencies(${DIFFUSIONAPP_NAME} ${MITK_MODULES_ENABLED_PLUGINS})
 endif()
diff --git a/BlueBerry/Bundles/org.blueberry.ui/src/berryIWorkbenchWindow.h b/BlueBerry/Bundles/org.blueberry.ui/src/berryIWorkbenchWindow.h
index 0b63ae0e9b..a4263d0c0f 100644
--- a/BlueBerry/Bundles/org.blueberry.ui/src/berryIWorkbenchWindow.h
+++ b/BlueBerry/Bundles/org.blueberry.ui/src/berryIWorkbenchWindow.h
@@ -1,208 +1,213 @@
 /*===================================================================
 
 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 BERRYIWORKBENCHWINDOW_H_
 #define BERRYIWORKBENCHWINDOW_H_
 
 #include <berryMacros.h>
 #include <berryIAdaptable.h>
 
 #include <org_blueberry_ui_Export.h>
 
 #include "berryIPageService.h"
 #include "berryShell.h"
 
 #include "services/berryIServiceLocator.h"
 
 namespace berry {
 
 struct IPartService;
 struct ISelectionService;
 struct IWorkbenchPage;
 struct IWorkbench;
 
 /**
  * \ingroup org_blueberry_ui
  *
  * A workbench window is a top level window in a workbench. Visually, a
  * workbench window has a menubar, a toolbar, a status bar, and a main area for
  * displaying a single page consisting of a collection of views and editors.
  * <p>
  * Each workbench window has a collection of 0 or more pages; the active page is
  * the one that is being presented to the end user; at most one page is active
  * in a window at a time.
  * </p>
  * <p>
  * The workbench window supports a few {@link IServiceLocator services} by
  * default. If these services are used to allocate resources, it is important to
  * remember to clean up those resources after you are done with them. Otherwise,
  * the resources will exist until the workbench window is closed. The supported
  * services are:
  * </p>
  * <ul>
  * <li>{@link ICommandService}</li>
  * <li>{@link IContextService}</li>
  * <li>{@link IHandlerService}</li>
  * <li>{@link IBindingService}. Resources allocated through this service will
  * not be cleaned up until the workbench shuts down.</li>
  * </ul>
  * <p>
  * This interface is not intended to be implemented by clients.
  * </p>
  *
  * @see IWorkbenchPage
  * @noimplement This interface is not intended to be implemented by clients.
  *
  */
 struct BERRY_UI IWorkbenchWindow : public IPageService, public IServiceLocator, public virtual Object
 {
 
   berryInterfaceMacro(IWorkbenchWindow, berry);
 
   /**
    * Closes this workbench window.
    * <p>
    * If the window has an open editor with unsaved content, the user will be
    * given the opportunity to save it.
    * </p>
    *
    * @return <code>true</code> if the window was successfully closed, and
    *         <code>false</code> if it is still open
    */
   virtual bool Close() = 0;
 
   virtual SmartPointer<IWorkbenchPage> GetPage(int i) = 0;
 
   /**
    * Returns the currently active page for this workbench window.
    *
    * @return the active page, or <code>null</code> if none
    */
   virtual SmartPointer<IWorkbenchPage> GetActivePage() = 0;
 
   /**
    * Sets or clears the currently active page for this workbench window.
    *
    * @param page
    *            the new active page
    */
   virtual void SetActivePage(SmartPointer<IWorkbenchPage> page) = 0;
 
   /**
    * Returns the part service which tracks part activation within this
    * workbench window.
    *
    * @return the part service
    */
   virtual IPartService* GetPartService() = 0;
 
   /**
    * Returns the selection service which tracks selection within this
    * workbench window.
    *
    * @return the selection service
    */
   virtual ISelectionService* GetSelectionService() = 0;
 
   /**
    * Returns this workbench window's shell.
    *
    * @return the shell containing this window's controls or <code>null</code>
    *   if the shell has not been created yet or if the window has been closed
    */
   virtual Shell::Pointer GetShell() = 0;
 
   /**
    * Returns the workbench for this window.
    *
    * @return the workbench
    */
   virtual IWorkbench* GetWorkbench() = 0;
 
   /**
    * Returns whether the specified menu is an application menu as opposed to
    * a part menu. Application menus contain items which affect the workbench
    * or window. Part menus contain items which affect the active part (view
    * or editor).
    * <p>
    * This is typically used during "in place" editing. Application menus
    * should be preserved during menu merging. All other menus may be removed
    * from the window.
    * </p>
    *
    * @param menuId
    *            the menu id
    * @return <code>true</code> if the specified menu is an application
    *         menu, and <code>false</code> if it is not
    */
   //virtual bool IsApplicationMenu(const std::string& menuId) = 0;
 
   /**
    * Creates and opens a new workbench page. The perspective of the new page
    * is defined by the specified perspective ID. The new page become active.
    * <p>
    * <b>Note:</b> Since release 2.0, a window is limited to contain at most
    * one page. If a page exist in the window when this method is used, then
    * another window is created for the new page. Callers are strongly
    * recommended to use the <code>IWorkbench.showPerspective</code> APIs to
    * programmatically show a perspective.
    * </p>
    *
    * @param perspectiveId
    *            the perspective id for the window's initial page
    * @param input
    *            the page input, or <code>null</code> if there is no current
    *            input. This is used to seed the input for the new page's
    *            views.
    * @return the new workbench page
    * @exception WorkbenchException
    *                if a page could not be opened
    *
    * @see IWorkbench#showPerspective(String, IWorkbenchWindow, IAdaptable)
    */
   virtual SmartPointer<IWorkbenchPage> OpenPage(const std::string& perspectiveId, IAdaptable* input) = 0;
 
   /**
    * Creates and opens a new workbench page. The default perspective is used
    * as a template for creating the page. The page becomes active.
    * <p>
    * <b>Note:</b> Since release 2.0, a window is limited to contain at most
    * one page. If a page exist in the window when this method is used, then
    * another window is created for the new page. Callers are strongly
    * recommended to use the <code>IWorkbench.showPerspective</code> APIs to
    * programmatically show a perspective.
    * </p>
    *
    * @param input
    *            the page input, or <code>null</code> if there is no current
    *            input. This is used to seed the input for the new page's
    *            views.
    * @return the new workbench window
    * @exception WorkbenchException
    *                if a page could not be opened
    *
    * @see IWorkbench#showPerspective(String, IWorkbenchWindow, IAdaptable)
    */
   virtual SmartPointer<IWorkbenchPage> OpenPage(IAdaptable* input) = 0;
 
+  virtual void SetPerspectiveExcludeList(std::vector<std::string> v) = 0;
+  virtual std::vector<std::string> GetPerspectiveExcludeList() = 0;
+
+  virtual void SetViewExcludeList(std::vector<std::string> v) = 0;
+  virtual std::vector<std::string> GetViewExcludeList() = 0;
 
   virtual ~IWorkbenchWindow();
 
 };
 
 }
 
 #endif /*BERRYIWORKBENCHWINDOW_H_*/
diff --git a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.cpp b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.cpp
index 70996f34a9..891f15e5fd 100644
--- a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.cpp
@@ -1,1806 +1,1825 @@
 /*===================================================================
 
 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 "berryWorkbenchWindow.h"
 
 #include "berryIWorkbenchPage.h"
 #include "berryIPerspectiveDescriptor.h"
 #include "berryUIException.h"
 #include "berryConstants.h"
 
 #include "intro/berryIntroConstants.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryWorkbenchPage.h"
 #include "berryWorkbench.h"
 #include "berryWorkbenchConstants.h"
 #include "berryPartSite.h"
 #include "berryIServiceLocatorCreator.h"
 
 #include "tweaklets/berryGuiWidgetsTweaklet.h"
 #include "tweaklets/berryWorkbenchTweaklet.h"
 
 #include "services/berryIServiceFactory.h"
 
 #include "berryPlatformUI.h"
 
 #include "berryDebugUtil.h"
 
 namespace berry
 {
 
 const int WorkbenchWindow::FILL_ALL_ACTION_BARS =
     ActionBarAdvisor::FILL_MENU_BAR | ActionBarAdvisor::FILL_COOL_BAR
         | ActionBarAdvisor::FILL_STATUS_LINE;
 
 WorkbenchWindow::WorkbenchWindow(int number) :
   Window(Shell::Pointer(0)), pageComposite(0), windowAdvisor(0),
       actionBarAdvisor(0), number(number), largeUpdates(0), closing(false),
       shellActivated(false), updateDisabled(true), emptyWindowContentsCreated(
           false), emptyWindowContents(0), asMaximizedState(false), partService(
           this), serviceLocatorOwner(
           new ServiceLocatorOwner(this))
 {
   this->Register(); // increase the reference count to avoid deleting
   // this object when temporary smart pointers
   // go out of scope
 
   // Make sure there is a workbench. This call will throw
   // an exception if workbench not created yet.
   IWorkbench* workbench = PlatformUI::GetWorkbench();
   IServiceLocatorCreator::Pointer slc =
       workbench->GetService(IServiceLocatorCreator::GetManifestName()).Cast<
           IServiceLocatorCreator> ();
 
   IServiceLocator::Pointer locator(workbench);
   this->serviceLocator = slc->CreateServiceLocator(IServiceLocator::WeakPtr(
       locator), IServiceFactory::ConstPointer(0), IDisposable::WeakPtr(
       serviceLocatorOwner)).Cast<ServiceLocator> ();
 
   //  initializeDefaultServices();
 
   // Add contribution managers that are exposed to other plugins.
   //addMenuBar();
   //addCoolBar(SWT.NONE);  // style is unused
   //addStatusLine();
 
   this->FireWindowOpening();
 
   // Fill the action bars
   this->FillActionBars(FILL_ALL_ACTION_BARS);
 
   this->UnRegister(false); // decrease reference count and avoid deleting
   // the window
 }
 
 WorkbenchWindow::~WorkbenchWindow()
 {
   //BERRY_INFO << "WorkbenchWindow::~WorkbenchWindow()";
 }
 
 Object::Pointer WorkbenchWindow::GetService(const std::string& key)
 {
   return serviceLocator->GetService(key);
 }
 
 bool WorkbenchWindow::HasService(const std::string& key) const
 {
   return serviceLocator->HasService(key);
 }
 
 Shell::Pointer WorkbenchWindow::GetShell()
 {
   return Window::GetShell();
 }
 
 bool WorkbenchWindow::ClosePage(IWorkbenchPage::Pointer in, bool save)
 {
   // Validate the input.
   if (!pageList.Contains(in))
   {
     return false;
   }
   WorkbenchPage::Pointer oldPage = in.Cast<WorkbenchPage> ();
 
   // Save old perspective.
   if (save && oldPage->IsSaveNeeded())
   {
     if (!oldPage->SaveAllEditors(true))
     {
       return false;
     }
   }
 
   // If old page is activate deactivate.
   bool oldIsActive = (oldPage == this->GetActivePage());
   if (oldIsActive)
   {
     this->SetActivePage(IWorkbenchPage::Pointer(0));
   }
 
   // Close old page.
   pageList.Remove(oldPage);
   partService.PageClosed(oldPage);
   //this->FirePageClosed(oldPage);
   //oldPage->Dispose();
 
   // Activate new page.
   if (oldIsActive)
   {
     IWorkbenchPage::Pointer newPage = pageList.GetNextActive();
     if (newPage != 0)
     {
       this->SetActivePage(newPage);
     }
   }
   if (!closing && pageList.IsEmpty())
   {
     this->ShowEmptyWindowContents();
   }
   return true;
 }
 
 void WorkbenchWindow::AddPerspectiveListener(IPerspectiveListener::Pointer l)
 {
   perspectiveEvents.AddListener(l);
 }
 
 void WorkbenchWindow::RemovePerspectiveListener(IPerspectiveListener::Pointer l)
 {
   perspectiveEvents.RemoveListener(l);
 }
 
 IPerspectiveListener::Events& WorkbenchWindow::GetPerspectiveEvents()
 {
   return perspectiveEvents;
 }
 
 void WorkbenchWindow::FireWindowOpening()
 {
   // let the application do further configuration
   this->GetWindowAdvisor()->PreWindowOpen();
 }
 
 void WorkbenchWindow::FireWindowRestored()
 {
   //StartupThreading.runWithWorkbenchExceptions(new StartupRunnable() {
   //  public void runWithException() throws Throwable {
   this->GetWindowAdvisor()->PostWindowRestore();
   //  }
   //});
 }
 
 void WorkbenchWindow::FireWindowCreated()
 {
   this->GetWindowAdvisor()->PostWindowCreate();
 }
 
 void WorkbenchWindow::FireWindowOpened()
 {
   this->GetWorkbenchImpl()->FireWindowOpened(IWorkbenchWindow::Pointer(this));
   this->GetWindowAdvisor()->PostWindowOpen();
 }
 
 bool WorkbenchWindow::FireWindowShellClosing()
 {
   return this->GetWindowAdvisor()->PreWindowShellClose();
 }
 
 void WorkbenchWindow::FireWindowClosed()
 {
   // let the application do further deconfiguration
   this->GetWindowAdvisor()->PostWindowClose();
   this->GetWorkbenchImpl()->FireWindowClosed(IWorkbenchWindow::Pointer(this));
 }
 
 ///**
 // * Fires page activated
 // */
 //void WorkbenchWindow::FirePageActivated(IWorkbenchPage::Pointer page) {
 ////  String label = null; // debugging only
 ////  if (UIStats.isDebugging(UIStats.NOTIFY_PAGE_LISTENERS)) {
 ////    label = "activated " + page.getLabel(); //$NON-NLS-1$
 ////  }
 ////  try {
 ////    UIStats.start(UIStats.NOTIFY_PAGE_LISTENERS, label);
 ////    UIListenerLogging.logPageEvent(this, page,
 ////        UIListenerLogging.WPE_PAGE_ACTIVATED);
 //    pageEvents.FirePageActivated(page);
 //    partService.pageActivated(page);
 ////  } finally {
 ////    UIStats.end(UIStats.NOTIFY_PAGE_LISTENERS, page.getLabel(), label);
 ////  }
 //}
 //
 ///**
 // * Fires page closed
 // */
 //void WorkbenchWindow::FirePageClosed(IWorkbenchPage::Pointer page) {
 //  String label = null; // debugging only
 //  if (UIStats.isDebugging(UIStats.NOTIFY_PAGE_LISTENERS)) {
 //    label = "closed " + page.getLabel(); //$NON-NLS-1$
 //  }
 //  try {
 //    UIStats.start(UIStats.NOTIFY_PAGE_LISTENERS, label);
 //    UIListenerLogging.logPageEvent(this, page,
 //        UIListenerLogging.WPE_PAGE_CLOSED);
 //    pageListeners.firePageClosed(page);
 //    partService.pageClosed(page);
 //  } finally {
 //    UIStats.end(UIStats.NOTIFY_PAGE_LISTENERS, page.getLabel(), label);
 //  }
 //
 //}
 //
 ///**
 // * Fires page opened
 // */
 //void WorkbenchWindow::FirePageOpened(IWorkbenchPage::Pointer page) {
 //  String label = null; // debugging only
 //  if (UIStats.isDebugging(UIStats.NOTIFY_PAGE_LISTENERS)) {
 //    label = "opened " + page.getLabel(); //$NON-NLS-1$
 //  }
 //  try {
 //    UIStats.start(UIStats.NOTIFY_PAGE_LISTENERS, label);
 //    UIListenerLogging.logPageEvent(this, page,
 //        UIListenerLogging.WPE_PAGE_OPENED);
 //    pageListeners.firePageOpened(page);
 //    partService.pageOpened(page);
 //  } finally {
 //    UIStats.end(UIStats.NOTIFY_PAGE_LISTENERS, page.getLabel(), label);
 //  }
 //}
 
 void WorkbenchWindow::FirePerspectiveActivated(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer perspective)
 {
   //  UIListenerLogging.logPerspectiveEvent(this, page, perspective,
   //      UIListenerLogging.PLE_PERSP_ACTIVATED);
   perspectiveEvents.perspectiveActivated(page, perspective);
 }
 
 void WorkbenchWindow::FirePerspectivePreDeactivate(
     IWorkbenchPage::Pointer page, IPerspectiveDescriptor::Pointer perspective)
 {
   //  UIListenerLogging.logPerspectiveEvent(this, page, perspective,
   //      UIListenerLogging.PLE_PERSP_PRE_DEACTIVATE);
   perspectiveEvents.perspectivePreDeactivate(page, perspective);
 }
 
 void WorkbenchWindow::FirePerspectiveDeactivated(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer perspective)
 {
   //  UIListenerLogging.logPerspectiveEvent(this, page, perspective,
   //      UIListenerLogging.PLE_PERSP_DEACTIVATED);
   perspectiveEvents.perspectiveDeactivated(page, perspective);
 }
 
 void WorkbenchWindow::FirePerspectiveChanged(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer perspective, const std::string& changeId)
 {
   // Some callers call this even when there is no active perspective.
   // Just ignore this case.
   if (perspective != 0)
   {
     //    UIListenerLogging.logPerspectiveChangedEvent(this, page,
     //        perspective, null, changeId);
     perspectiveEvents.perspectiveChanged(page, perspective, changeId);
   }
 }
 
 void WorkbenchWindow::FirePerspectiveChanged(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer perspective,
     IWorkbenchPartReference::Pointer partRef, const std::string& changeId)
 {
   // Some callers call this even when there is no active perspective.
   // Just ignore this case.
   if (perspective != 0)
   {
     //    UIListenerLogging.logPerspectiveChangedEvent(this, page,
     //        perspective, partRef, changeId);
     perspectiveEvents.perspectivePartChanged(page, perspective, partRef,
         changeId);
   }
 }
 
 void WorkbenchWindow::FirePerspectiveClosed(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer perspective)
 {
   //  UIListenerLogging.logPerspectiveEvent(this, page, perspective,
   //      UIListenerLogging.PLE_PERSP_CLOSED);
   perspectiveEvents.perspectiveClosed(page, perspective);
 }
 
 void WorkbenchWindow::FirePerspectiveOpened(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer perspective)
 {
   //  UIListenerLogging.logPerspectiveEvent(this, page, perspective,
   //      UIListenerLogging.PLE_PERSP_OPENED);
   perspectiveEvents.perspectiveOpened(page, perspective);
 }
 
 void WorkbenchWindow::FirePerspectiveSavedAs(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer oldPerspective,
     IPerspectiveDescriptor::Pointer newPerspective)
 {
   //  UIListenerLogging.logPerspectiveSavedAs(this, page, oldPerspective,
   //      newPerspective);
   perspectiveEvents.perspectiveSavedAs(page, oldPerspective, newPerspective);
 }
 
 void WorkbenchWindow::FillActionBars(int flags)
 {
   //  Workbench workbench = getWorkbenchImpl();
   //  workbench.largeUpdateStart();
   //try {
   this->GetActionBarAdvisor()->FillActionBars(flags);
 
   //    final IMenuService menuService = (IMenuService) serviceLocator
   //        .getService(IMenuService.class);
   //    menuService.populateContributionManager(
   //        (ContributionManager) getActionBars().getMenuManager(),
   //        MenuUtil.MAIN_MENU);
   //    ICoolBarManager coolbar = getActionBars().getCoolBarManager();
   //    if (coolbar != null) {
   //      menuService.populateContributionManager(
   //          (ContributionManager) coolbar,
   //          MenuUtil.MAIN_TOOLBAR);
   //    }
   //
   //  } finally {
   //    workbench.largeUpdateEnd();
   //  }
 }
 
 Point WorkbenchWindow::GetInitialSize()
 {
   return this->GetWindowConfigurer()->GetInitialSize();
 }
 
 bool WorkbenchWindow::Close()
 {
   //BERRY_INFO << "WorkbenchWindow::Close()";
 
   if (controlResizeListener)
   {
     Tweaklets::Get(GuiWidgetsTweaklet::KEY)->RemoveControlListener(GetShell()->GetControl(), controlResizeListener);
   }
 
   bool ret = false;
   //BusyIndicator.showWhile(null, new Runnable() {
   //      public void run() {
   ret = this->BusyClose();
   //      }
   //    });
 
   if (!ret && controlResizeListener)
   {
     Tweaklets::Get(GuiWidgetsTweaklet::KEY)->AddControlListener(GetShell()->GetControl(), controlResizeListener);
   }
 
   return ret;
 }
 
 bool WorkbenchWindow::BusyClose()
 {
   // Whether the window was actually closed or not
   bool windowClosed = false;
 
   // Setup internal flags to indicate window is in
   // progress of closing and no update should be done.
   closing = true;
   updateDisabled = true;
 
   try
   {
     // Only do the check if it is OK to close if we are not closing
     // via the workbench as the workbench will check this itself.
     Workbench* workbench = this->GetWorkbenchImpl();
     std::size_t count = workbench->GetWorkbenchWindowCount();
 
     // also check for starting - if the first window dies on startup
     // then we'll need to open a default window.
     if (!workbench->IsStarting() && !workbench->IsClosing() && count <= 1
         && workbench->GetWorkbenchConfigurer() ->GetExitOnLastWindowClose())
     {
       windowClosed = workbench->Close();
     }
     else
     {
       if (this->OkToClose())
       {
         windowClosed = this->HardClose();
       }
     }
   } catch (std::exception& exc)
   {
     if (!windowClosed)
     {
       // Reset the internal flags if window was not closed.
       closing = false;
       updateDisabled = false;
     }
 
     throw exc;
   }
 
   //    if (windowClosed && tracker != null) {
   //      tracker.close();
   //    }
 
   return windowClosed;
 }
 
 void WorkbenchWindow::MakeVisible()
 {
   Shell::Pointer shell = GetShell();
   if (shell)
   {
     // see bug 96700 and bug 4414 for a discussion on the use of open()
     // here
     shell->Open();
   }
 }
 
 bool WorkbenchWindow::OkToClose()
 {
   // Save all of the editors.
   if (!this->GetWorkbenchImpl()->IsClosing())
   {
     if (!this->SaveAllPages(true))
     {
       return false;
     }
   }
   return true;
 }
 
 bool WorkbenchWindow::SaveAllPages(bool bConfirm)
 {
   bool bRet = true;
   PageList::iterator itr = pageList.Begin();
   while (bRet && itr != pageList.End())
   {
     bRet = (*itr)->SaveAllEditors(bConfirm);
     ++itr;
   }
   return bRet;
 }
 
 bool WorkbenchWindow::HardClose()
 {
   std::exception exc;
   bool exceptionOccured = false;
 
   try
   {
     // Clear the action sets, fix for bug 27416.
     //getActionPresentation().clearActionSets();
 
     // Remove the handler submissions. Bug 64024.
     /*
      final IWorkbench workbench = getWorkbench();
      final IHandlerService handlerService = (IHandlerService) workbench.getService(IHandlerService.class);
      handlerService.deactivateHandlers(handlerActivations);
      final Iterator activationItr = handlerActivations.iterator();
      while (activationItr.hasNext()) {
      final IHandlerActivation activation = (IHandlerActivation) activationItr
      .next();
      activation.getHandler().dispose();
      }
      handlerActivations.clear();
      globalActionHandlersByCommandId.clear();
      */
 
     // Remove the enabled submissions. Bug 64024.
     /*
      final IContextService contextService = (IContextService) workbench.getService(IContextService.class);
      contextService.unregisterShell(getShell());
      */
 
     this->CloseAllPages();
 
     this->FireWindowClosed();
 
     // time to wipe out our populate
     /*
      IMenuService menuService = (IMenuService) workbench
      .getService(IMenuService.class);
      menuService
      .releaseContributions(((ContributionManager) getActionBars()
      .getMenuManager()));
      ICoolBarManager coolbar = getActionBars().getCoolBarManager();
      if (coolbar != null) {
      menuService
      .releaseContributions(((ContributionManager) coolbar));
      }
      */
 
     //getActionBarAdvisor().dispose();
     //getWindowAdvisor().dispose();
     //detachedWindowShells.dispose();
     delete windowAdvisor;
     windowAdvisor = 0;
 
     // Null out the progress region. Bug 64024.
     //progressRegion = null;
 
     // Remove drop targets
     /*
      DragUtil.removeDragTarget(null, trimDropTarget);
      DragUtil.removeDragTarget(getShell(), trimDropTarget);
      trimDropTarget = null;
 
      if (trimMgr2 != null) {
      trimMgr2.dispose();
      trimMgr2 = null;
      }
 
      if (trimContributionMgr != null) {
      trimContributionMgr.dispose();
      trimContributionMgr = null;
      }
      */
   } catch (std::exception& e)
   {
     exc = e;
     exceptionOccured = true;
   }
 
   bool result = Window::Close();
   // Bring down all of the services ... after the window goes away
   serviceLocator->Dispose();
   //menuRestrictions.clear();
 
   if (exceptionOccured)
     throw exc;
 
   return result;
 }
 
 void WorkbenchWindow::CloseAllPages()
 {
   // Deactivate active page.
   this->SetActivePage(IWorkbenchPage::Pointer(0));
 
   // Clone and deref all so that calls to getPages() returns
   // empty list (if called by pageClosed event handlers)
   PageList oldList = pageList;
   pageList.Clear();
 
   // Close all.
   for (PageList::iterator itr = oldList.Begin(); itr != oldList.End(); ++itr)
   {
     partService.PageClosed(*itr);
     //(*itr)->FirePageClosed(page);
     //page.dispose();
   }
   if (!closing)
   {
     this->ShowEmptyWindowContents();
   }
 }
 
+void WorkbenchWindow::SetPerspectiveExcludeList(std::vector<std::string> v)
+{
+    perspectiveExcludeList = v;
+}
+
+std::vector<std::string> WorkbenchWindow::GetPerspectiveExcludeList()
+{
+    return perspectiveExcludeList;
+}
+
+void WorkbenchWindow::SetViewExcludeList(std::vector<std::string> v)
+{
+    viewExcludeList = v;
+}
+
+std::vector<std::string> WorkbenchWindow::GetViewExcludeList()
+{
+    return viewExcludeList;
+}
 
 IWorkbenchPage::Pointer WorkbenchWindow::GetPage(int i)
 {
     std::list<IWorkbenchPage::Pointer> pages = pageList.GetPages();
     std::list<IWorkbenchPage::Pointer>::iterator it;
     int j=-1;
     for (it = pages.begin(); it!=pages.end(); it++)
     {
         j++;
         if (j==i)
             break;
     }
     if (j==i)
         return *it;
 }
 
 IWorkbenchPage::Pointer WorkbenchWindow::GetActivePage()
 {
   return pageList.GetActive();
 }
 
 IWorkbench* WorkbenchWindow::GetWorkbench()
 {
   return PlatformUI::GetWorkbench();
 }
 
 IPartService* WorkbenchWindow::GetPartService()
 {
   return &partService;
 }
 
 ISelectionService* WorkbenchWindow::GetSelectionService()
 {
   return partService.GetSelectionService();
 }
 
 bool WorkbenchWindow::IsClosing()
 {
   return closing || this->GetWorkbenchImpl()->IsClosing();
 }
 
 int WorkbenchWindow::Open()
 {
   if (pageList.IsEmpty())
   {
     this->ShowEmptyWindowContents();
   }
 
   this->FireWindowCreated();
   this->GetWindowAdvisor()->OpenIntro();
 
   int result = Window::Open();
 
   // It's time for a layout ... to insure that if TrimLayout
   // is in play, it updates all of the trim it's responsible
   // for. We have to do this before updating in order to get
   // the PerspectiveBar management correct...see defect 137334
   //getShell().layout();
 
   this->FireWindowOpened();
   //  if (perspectiveSwitcher != null) {
   //    perspectiveSwitcher.updatePerspectiveBar();
   //    perspectiveSwitcher.updateBarParent();
   //  }
 
   return result;
 }
 
 void* WorkbenchWindow::GetPageComposite()
 {
   return pageComposite;
 }
 
 void* WorkbenchWindow::CreateContents(Shell::Pointer parent)
 {
   // we know from Window.create that the parent is a Shell.
   this->GetWindowAdvisor()->CreateWindowContents(parent);
   // the page composite must be set by createWindowContents
   poco_assert(pageComposite != 0)
 ; // "createWindowContents must call configurer.createPageComposite"); //$NON-NLS-1$
   return pageComposite;
 }
 
 void WorkbenchWindow::CreateDefaultContents(Shell::Pointer shell)
 {
   //pageComposite = Tweaklets::Get(WorkbenchTweaklet::KEY)->CreateDefaultWindowContents(shell);
   this->CreatePageComposite(shell->GetControl());
 }
 
 bool WorkbenchWindow::UnableToRestorePage(IMemento::Pointer pageMem)
 {
   std::string pageName;
   pageMem->GetString(WorkbenchConstants::TAG_LABEL, pageName);
 
   //  return new Status(IStatus.ERROR, PlatformUI.PLUGIN_ID, 0, NLS.bind(
   //      WorkbenchMessages.WorkbenchWindow_unableToRestorePerspective,
   //      pageName), null);
   WorkbenchPlugin::Log("Unable to restore perspective: " + pageName);
   return false;
 }
 
 bool WorkbenchWindow::RestoreState(IMemento::Pointer memento,
     IPerspectiveDescriptor::Pointer activeDescriptor)
 {
   //TODO WorkbenchWindow restore state
   poco_assert(GetShell());
 
   //  final MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK,
   //      WorkbenchMessages.WorkbenchWindow_problemsRestoringWindow, null);
   bool result = true;
 
   // Restore the window advisor state.
   IMemento::Pointer windowAdvisorState = memento
   ->GetChild(WorkbenchConstants::TAG_WORKBENCH_WINDOW_ADVISOR);
   if (windowAdvisorState)
   {
     //result.add(getWindowAdvisor().restoreState(windowAdvisorState));
     result &= GetWindowAdvisor()->RestoreState(windowAdvisorState);
   }
 
   // Restore actionbar advisor state.
   IMemento::Pointer actionBarAdvisorState = memento
   ->GetChild(WorkbenchConstants::TAG_ACTION_BAR_ADVISOR);
   if (actionBarAdvisorState)
   {
     //    result.add(getActionBarAdvisor()
     //        .restoreState(actionBarAdvisorState));
     result &= GetActionBarAdvisor()
     ->RestoreState(actionBarAdvisorState);
   }
 
   // Read window's bounds and state.
   Rectangle displayBounds;
   //  StartupThreading.runWithoutExceptions(new StartupRunnable() {
   //
   //    public void runWithException() {
   displayBounds = Tweaklets::Get(GuiWidgetsTweaklet::KEY)->GetScreenSize();
   //displayBounds = GetShell()->GetDisplay()->GetBounds();
 
   //    }});
   Rectangle shellBounds;
 
   //  final IMemento fastViewMem = memento
   //      .getChild(IWorkbenchConstants.TAG_FAST_VIEW_DATA);
   //  if (fastViewMem != null) {
   //    if (fastViewBar != null) {
   //      StartupThreading.runWithoutExceptions(new StartupRunnable() {
   //
   //        public void runWithException() {
   //          fastViewBar.restoreState(fastViewMem);
   //        }});
   //
   //    }
   //  }
 
   memento->GetInteger(WorkbenchConstants::TAG_X, shellBounds.x);
   memento->GetInteger(WorkbenchConstants::TAG_Y, shellBounds.y);
   memento->GetInteger(WorkbenchConstants::TAG_WIDTH, shellBounds.width);
   memento->GetInteger(WorkbenchConstants::TAG_HEIGHT, shellBounds.height);
   if (!shellBounds.IsEmpty())
   {
     //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
     //
     //      public void runWithException() {
     if (!shellBounds.Intersects(displayBounds))
     {
       Rectangle clientArea(Tweaklets::Get(GuiWidgetsTweaklet::KEY)->GetAvailableScreenSize());
       shellBounds.x = clientArea.x;
       shellBounds.y = clientArea.y;
     }
     GetShell()->SetBounds(shellBounds);
     //      }});
   }
   std::string maximized; memento->GetString(WorkbenchConstants::TAG_MAXIMIZED, maximized);
   if (maximized == "true")
   {
     //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
     //
     //      public void runWithException() {
     GetShell()->SetMaximized(true);
     //      }});
 
   }
   std::string minimized; memento->GetString(WorkbenchConstants::TAG_MINIMIZED, minimized);
   if (minimized == "true")
   {
     // getShell().setMinimized(true);
   }
 
   //  // restore the width of the perspective bar
   //  if (perspectiveSwitcher != null) {
   //    perspectiveSwitcher.restoreState(memento);
   //  }
 
   //  // Restore the cool bar order by creating all the tool bar contribution
   //  // items
   //  // This needs to be done before pages are created to ensure proper
   //  // canonical creation
   //  // of cool items
   //  final ICoolBarManager2 coolBarMgr = (ICoolBarManager2) getCoolBarManager2();
   //      if (coolBarMgr != null) {
   //    IMemento coolBarMem = memento
   //        .getChild(IWorkbenchConstants.TAG_COOLBAR_LAYOUT);
   //    if (coolBarMem != null) {
   //      // Check if the layout is locked
   //      final Integer lockedInt = coolBarMem
   //          .getInteger(IWorkbenchConstants.TAG_LOCKED);
   //      StartupThreading.runWithoutExceptions(new StartupRunnable(){
   //
   //        public void runWithException() {
   //          if ((lockedInt != null) && (lockedInt.intValue() == 1)) {
   //            coolBarMgr.setLockLayout(true);
   //          } else {
   //            coolBarMgr.setLockLayout(false);
   //          }
   //        }});
   //
   //      // The new layout of the cool bar manager
   //      ArrayList coolBarLayout = new ArrayList();
   //      // Traverse through all the cool item in the memento
   //      IMemento contributionMems[] = coolBarMem
   //          .getChildren(IWorkbenchConstants.TAG_COOLITEM);
   //      for (int i = 0; i < contributionMems.length; i++) {
   //        IMemento contributionMem = contributionMems[i];
   //        String type = contributionMem
   //            .getString(IWorkbenchConstants.TAG_ITEM_TYPE);
   //        if (type == null) {
   //          // Do not recognize that type
   //          continue;
   //        }
   //        String id = contributionMem
   //            .getString(IWorkbenchConstants.TAG_ID);
   //
   //        // Prevent duplicate items from being read back in.
   //        IContributionItem existingItem = coolBarMgr.find(id);
   //        if ((id != null) && (existingItem != null)) {
   //          if (Policy.DEBUG_TOOLBAR_DISPOSAL) {
   //            System.out
   //                .println("Not loading duplicate cool bar item: " + id); //$NON-NLS-1$
   //          }
   //          coolBarLayout.add(existingItem);
   //          continue;
   //        }
   //        IContributionItem newItem = null;
   //        if (type.equals(IWorkbenchConstants.TAG_TYPE_SEPARATOR)) {
   //          if (id != null) {
   //            newItem = new Separator(id);
   //          } else {
   //            newItem = new Separator();
   //          }
   //        } else if (id != null) {
   //          if (type
   //              .equals(IWorkbenchConstants.TAG_TYPE_GROUPMARKER)) {
   //            newItem = new GroupMarker(id);
   //
   //          } else if (type
   //              .equals(IWorkbenchConstants.TAG_TYPE_TOOLBARCONTRIBUTION)
   //              || type
   //                  .equals(IWorkbenchConstants.TAG_TYPE_PLACEHOLDER)) {
   //
   //            // Get Width and height
   //            Integer width = contributionMem
   //                .getInteger(IWorkbenchConstants.TAG_ITEM_X);
   //            Integer height = contributionMem
   //                .getInteger(IWorkbenchConstants.TAG_ITEM_Y);
   //            // Look for the object in the current cool bar
   //            // manager
   //            IContributionItem oldItem = coolBarMgr.find(id);
   //            // If a tool bar contribution item already exists
   //            // for this id then use the old object
   //            if (oldItem != null) {
   //              newItem = oldItem;
   //            } else {
   //              IActionBarPresentationFactory actionBarPresentation = getActionBarPresentationFactory();
   //              newItem = actionBarPresentation.createToolBarContributionItem(
   //                  actionBarPresentation.createToolBarManager(), id);
   //              if (type
   //                  .equals(IWorkbenchConstants.TAG_TYPE_PLACEHOLDER)) {
   //                IToolBarContributionItem newToolBarItem = (IToolBarContributionItem) newItem;
   //                if (height != null) {
   //                  newToolBarItem.setCurrentHeight(height
   //                      .intValue());
   //                }
   //                if (width != null) {
   //                  newToolBarItem.setCurrentWidth(width
   //                      .intValue());
   //                }
   //                newItem = new PlaceholderContributionItem(
   //                    newToolBarItem);
   //              }
   //              // make it invisible by default
   //              newItem.setVisible(false);
   //              // Need to add the item to the cool bar manager
   //              // so that its canonical order can be preserved
   //              IContributionItem refItem = findAlphabeticalOrder(
   //                  IWorkbenchActionConstants.MB_ADDITIONS,
   //                  id, coolBarMgr);
   //              if (refItem != null) {
   //                coolBarMgr.insertAfter(refItem.getId(),
   //                    newItem);
   //              } else {
   //                coolBarMgr.add(newItem);
   //              }
   //            }
   //            // Set the current height and width
   //            if ((width != null)
   //                && (newItem instanceof IToolBarContributionItem)) {
   //              ((IToolBarContributionItem) newItem)
   //                  .setCurrentWidth(width.intValue());
   //            }
   //            if ((height != null)
   //                && (newItem instanceof IToolBarContributionItem)) {
   //              ((IToolBarContributionItem) newItem)
   //                  .setCurrentHeight(height.intValue());
   //            }
   //          }
   //        }
   //        // Add new item into cool bar manager
   //        if (newItem != null) {
   //          coolBarLayout.add(newItem);
   //          newItem.setParent(coolBarMgr);
   //          coolBarMgr.markDirty();
   //        }
   //      }
   //
   //      // We need to check if we have everything we need in the layout.
   //      boolean newlyAddedItems = false;
   //      IContributionItem[] existingItems = coolBarMgr.getItems();
   //      for (int i = 0; i < existingItems.length && !newlyAddedItems; i++) {
   //        IContributionItem existingItem = existingItems[i];
   //
   //        /*
   //         * This line shouldn't be necessary, but is here for
   //         * robustness.
   //         */
   //        if (existingItem == null) {
   //          continue;
   //        }
   //
   //        boolean found = false;
   //        Iterator layoutItemItr = coolBarLayout.iterator();
   //        while (layoutItemItr.hasNext()) {
   //          IContributionItem layoutItem = (IContributionItem) layoutItemItr
   //              .next();
   //          if ((layoutItem != null)
   //              && (layoutItem.equals(existingItem))) {
   //            found = true;
   //            break;
   //          }
   //        }
   //
   //        if (!found) {
   //          if (existingItem != null) {
   //            newlyAddedItems = true;
   //          }
   //        }
   //      }
   //
   //      // Set the cool bar layout to the given layout.
   //      if (!newlyAddedItems) {
   //        final IContributionItem[] itemsToSet = new IContributionItem[coolBarLayout
   //            .size()];
   //        coolBarLayout.toArray(itemsToSet);
   //        StartupThreading
   //            .runWithoutExceptions(new StartupRunnable() {
   //
   //              public void runWithException() {
   //                coolBarMgr.setItems(itemsToSet);
   //              }
   //            });
   //      }
   //
   //    } else {
   //      // For older workbenchs
   //      coolBarMem = memento
   //          .getChild(IWorkbenchConstants.TAG_TOOLBAR_LAYOUT);
   //      if (coolBarMem != null) {
   //        // Restore an older layout
   //        restoreOldCoolBar(coolBarMem);
   //      }
   //    }
   //  }
 
   // Recreate each page in the window.
   IWorkbenchPage::Pointer newActivePage;
   std::vector<IMemento::Pointer> pageArray = memento
   ->GetChildren(WorkbenchConstants::TAG_PAGE);
   for (std::size_t i = 0; i < pageArray.size(); i++)
   {
     IMemento::Pointer pageMem = pageArray[i];
     std::string strFocus; pageMem->GetString(WorkbenchConstants::TAG_FOCUS, strFocus);
     if (strFocus.empty())
     {
       continue;
     }
 
     // Get the input factory.
     IAdaptable* input = 0;
     IMemento::Pointer inputMem = pageMem->GetChild(WorkbenchConstants::TAG_INPUT);
     if (inputMem)
     {
       std::string factoryID; inputMem->GetString(WorkbenchConstants::TAG_FACTORY_ID, factoryID);
       if (factoryID.empty())
       {
         WorkbenchPlugin
         ::Log("Unable to restore page - no input factory ID.");
         //result.add(unableToRestorePage(pageMem));
         result &= UnableToRestorePage(pageMem);
         continue;
       }
       //      try {
       //        UIStats.start(UIStats.RESTORE_WORKBENCH,
       //            "WorkbenchPageFactory"); //$NON-NLS-1$
       //        StartupThreading
       //            .runWithoutExceptions(new StartupRunnable() {
       //
       //              public void runWithException() throws Throwable {
       //                IElementFactory factory = PlatformUI
       //                    .getWorkbench().getElementFactory(
       //                        factoryID);
       //                if (factory == null) {
       //                  WorkbenchPlugin
       //                      .log("Unable to restore page - cannot instantiate input factory: " + factoryID); //$NON-NLS-1$
       //                  result
       //                      .add(unableToRestorePage(pageMem));
       //                  return;
       //                }
       //
       //                // Get the input element.
       //                input[0] = factory.createElement(inputMem);
       //              }
       //            });
       //
       //        if (input[0] == null) {
       //          WorkbenchPlugin
       //              .log("Unable to restore page - cannot instantiate input element: " + factoryID); //$NON-NLS-1$
       //          result.add(unableToRestorePage(pageMem));
       //          continue;
       //        }
       //      } finally {
       //        UIStats.end(UIStats.RESTORE_WORKBENCH, factoryID,
       //            "WorkbenchPageFactory"); //$NON-NLS-1$
       //      }
     }
     // Open the perspective.
     IAdaptable* finalInput = input;
     WorkbenchPage::Pointer newPage;
     try
     {
       //      StartupThreading.runWithWorkbenchExceptions(new StartupRunnable(){
       //
       //        public void runWithException() throws WorkbenchException {
       newPage = new WorkbenchPage(this, finalInput);
       //        }});
 
       //result.add(newPage[0].restoreState(pageMem, activeDescriptor));
       result &= newPage->RestoreState(pageMem, activeDescriptor);
       pageList.Add(newPage);
       //      StartupThreading.runWithoutExceptions(new StartupRunnable() {
       //
       //        public void runWithException() throws Throwable {
       partService.PageOpened(newPage);
       //          firePageOpened(newPage[0]);
       //        }});
 
     }
     catch (const WorkbenchException& e)
     {
       WorkbenchPlugin::Log(
           "Unable to restore perspective - constructor failed.", e); //$NON-NLS-1$
       //result.add(e.getStatus());
       continue;
     }
 
     if (!strFocus.empty())
     {
       newActivePage = newPage;
     }
   }
 
   // If there are no pages create a default.
   if (pageList.IsEmpty())
   {
     try
     {
       const std::string defPerspID = this->GetWorkbenchImpl()->GetPerspectiveRegistry()
       ->GetDefaultPerspective();
       if (!defPerspID.empty())
       {
         WorkbenchPage::Pointer newPage;
         //StartupThreading.runWithWorkbenchExceptions(new StartupRunnable() {
 
         //  public void runWithException() throws Throwable {
         newPage = new WorkbenchPage(this, defPerspID,
             this->GetDefaultPageInput());
         //  }});
 
         pageList.Add(newPage);
         //StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
         //  public void runWithException() throws Throwable {
         //    firePageOpened(newPage[0]);
         partService.PageOpened(newPage);
         //  }});
       }
     }
     catch (WorkbenchException& e)
     {
       WorkbenchPlugin
       ::Log(
           "Unable to create default perspective - constructor failed.", e);
       result = false;
       //TODO set product name
       //      String productName = WorkbenchPlugin.getDefault()
       //          .getProductName();
       //      if (productName == null) {
       //        productName = ""; //$NON-NLS-1$
       //      }
       //      getShell().setText(productName);
     }
   }
 
   // Set active page.
   if (newActivePage.IsNull())
   {
     newActivePage = pageList.GetNextActive().Cast<IWorkbenchPage>();
   }
 
   //StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
   //  public void runWithException() throws Throwable {
   this->SetActivePage(newActivePage);
   //  }});
 
 
   IMemento::Pointer introMem = memento->GetChild(WorkbenchConstants::TAG_INTRO);
   if (introMem) {
 //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
 //
 //      public void runWithException() throws Throwable {
     bool isStandby = false;
     introMem->GetBoolean(WorkbenchConstants::TAG_STANDBY, isStandby);
         GetWorkbench()->GetIntroManager()->ShowIntro(
                 IWorkbenchWindow::Pointer(this), isStandby);
 //      }
 //    });
   }
   //
   //  // Only restore the trim state if we're using the default layout
   //  if (defaultLayout != null) {
   //    // Restore the trim state. We pass in the 'root'
   //    // memento since we have to check for pre-3.2
   //    // state.
   //    result.add(restoreTrimState(memento));
   //  }
 
   return result;
 }
 
 IAdaptable* WorkbenchWindow::GetDefaultPageInput()
 {
   return this->GetWorkbenchImpl()->GetDefaultPageInput();
 }
 
 IWorkbenchPage::Pointer WorkbenchWindow::OpenPage(
     const std::string& perspId, IAdaptable* input)
 {
   // Run op in busy cursor.
   IWorkbenchPage::Pointer result;
   //BusyIndicator.showWhile(null, new Runnable() {
   //  public void run() {
   result = this->BusyOpenPage(perspId, input);
 
   // }
 
   return result;
 }
 
 SmartPointer<IWorkbenchPage> WorkbenchWindow::OpenPage(IAdaptable* input)
 {
   std::string perspId = this->GetWorkbenchImpl()->GetDefaultPerspectiveId();
   return this->OpenPage(perspId, input);
 }
 
 IWorkbenchPage::Pointer WorkbenchWindow::BusyOpenPage(
     const std::string& perspID, IAdaptable* input)
 {
   IWorkbenchPage::Pointer newPage;
 
   if (pageList.IsEmpty())
   {
     newPage = new WorkbenchPage(this, perspID, input);
     pageList.Add(newPage);
     //this->FirePageOpened(newPage);
     partService.PageOpened(newPage);
     this->SetActivePage(newPage);
   }
   else
   {
     IWorkbenchWindow::Pointer window = this->GetWorkbench()->OpenWorkbenchWindow(perspID, input);
     newPage = window->GetActivePage();
   }
 
   return newPage;
 }
 
 int WorkbenchWindow::GetNumber()
 {
   return number;
 }
 
 void WorkbenchWindow::LargeUpdateStart()
 {
   largeUpdates++;
 }
 
 void WorkbenchWindow::LargeUpdateEnd()
 {
   if (--largeUpdates == 0)
   {
     //TODO WorkbenchWindow update action bars after large update
     //this->UpdateActionBars();
   }
 }
 
 void WorkbenchWindow::SetActivePage(IWorkbenchPage::Pointer in)
 {
   if (this->GetActivePage() == in)
   {
     return;
   }
 
   // 1FVGTNR: ITPUI:WINNT - busy cursor for switching perspectives
   //BusyIndicator.showWhile(getShell().getDisplay(), new Runnable() {
   //  public void run() {
   // Deactivate old persp.
   WorkbenchPage::Pointer currentPage = pageList.GetActive();
   if (currentPage.IsNotNull())
   {
     currentPage->OnDeactivate();
   }
 
   // Activate new persp.
   if (in.IsNull() || pageList.Contains(in))
   {
     pageList.SetActive(in);
   }
   WorkbenchPage::Pointer newPage = pageList.GetActive();
   //Composite parent = getPageComposite();
   //StackLayout layout = (StackLayout) parent.getLayout();
   if (newPage.IsNotNull())
   {
     //layout.topControl = newPage.getClientComposite();
     //parent.layout();
     this->HideEmptyWindowContents();
     newPage->OnActivate();
     //this->FirePageActivated(newPage);
     partService.PageActivated(newPage);
     //TODO perspective
     if (newPage->GetPerspective() != 0)
     {
       this->FirePerspectiveActivated(newPage, newPage->GetPerspective());
     }
   }
   else
   {
     //layout.topControl = null;
     //parent.layout();
   }
 
   //updateFastViewBar();
 
   if (this->IsClosing())
   {
     return;
   }
 
   updateDisabled = false;
 
   // Update action bars ( implicitly calls updateActionBars() )
   //updateActionSets();
   //submitGlobalActions();
 
   //if (perspectiveSwitcher != null) {
   //  perspectiveSwitcher.update(false);
   //}
 
   //getMenuManager().update(IAction.TEXT);
   //  }
   //});
 }
 
 bool WorkbenchWindow::SaveState(IMemento::Pointer memento)
 {
   //  MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK,
   //        WorkbenchMessages.WorkbenchWindow_problemsSavingWindow, null);
   bool result = true;
 
   // Save the window's state and bounds.
   if (GetShell()->GetMaximized() || asMaximizedState)
   {
     memento->PutString(WorkbenchConstants::TAG_MAXIMIZED, "true");
   }
   if (GetShell()->GetMinimized())
   {
     memento->PutString(WorkbenchConstants::TAG_MINIMIZED, "true");
   }
   if (normalBounds.IsEmpty())
   {
     normalBounds = GetShell()->GetBounds();
   }
 
   //  IMemento fastViewBarMem = memento
   //      .createChild(IWorkbenchConstants.TAG_FAST_VIEW_DATA);
   //  if (fastViewBar != null) {
   //    fastViewBar.saveState(fastViewBarMem);
   //  }
 
   memento->PutInteger(WorkbenchConstants::TAG_X, normalBounds.x);
   memento->PutInteger(WorkbenchConstants::TAG_Y, normalBounds.y);
   memento->PutInteger(WorkbenchConstants::TAG_WIDTH, normalBounds.width);
   memento->PutInteger(WorkbenchConstants::TAG_HEIGHT, normalBounds.height);
 
   IWorkbenchPage::Pointer activePage = GetActivePage();
   if (activePage
       && activePage->FindView(IntroConstants::INTRO_VIEW_ID))
   {
     IMemento::Pointer introMem = memento
         ->CreateChild(WorkbenchConstants::TAG_INTRO);
     bool isStandby = GetWorkbench()->GetIntroManager()
         ->IsIntroStandby(GetWorkbench()->GetIntroManager()->GetIntro());
     introMem->PutBoolean(WorkbenchConstants::TAG_STANDBY, isStandby);
   }
 
   //  // save the width of the perspective bar
   //  IMemento persBarMem = memento
   //      .createChild(IWorkbenchConstants.TAG_PERSPECTIVE_BAR);
   //  if (perspectiveSwitcher != null) {
   //    perspectiveSwitcher.saveState(persBarMem);
   //  }
 
   //  // / Save the order of the cool bar contribution items
   //        ICoolBarManager2 coolBarMgr = (ICoolBarManager2) getCoolBarManager2();
   //        if (coolBarMgr != null) {
   //          coolBarMgr.refresh();
   //      IMemento coolBarMem = memento
   //          .createChild(IWorkbenchConstants.TAG_COOLBAR_LAYOUT);
   //            if (coolBarMgr.getLockLayout() == true) {
   //        coolBarMem.putInteger(IWorkbenchConstants.TAG_LOCKED, 1);
   //      } else {
   //        coolBarMem.putInteger(IWorkbenchConstants.TAG_LOCKED, 0);
   //      }
   //            IContributionItem[] items = coolBarMgr.getItems();
   //      for (int i = 0; i < items.length; i++) {
   //        IMemento coolItemMem = coolBarMem
   //            .createChild(IWorkbenchConstants.TAG_COOLITEM);
   //        IContributionItem item = items[i];
   //        // The id of the contribution item
   //        if (item.getId() != null) {
   //          coolItemMem.putString(IWorkbenchConstants.TAG_ID, item
   //              .getId());
   //        }
   //        // Write out type and size if applicable
   //        if (item.isSeparator()) {
   //          coolItemMem.putString(IWorkbenchConstants.TAG_ITEM_TYPE,
   //              IWorkbenchConstants.TAG_TYPE_SEPARATOR);
   //        } else if (item.isGroupMarker() && !item.isSeparator()) {
   //          coolItemMem.putString(IWorkbenchConstants.TAG_ITEM_TYPE,
   //              IWorkbenchConstants.TAG_TYPE_GROUPMARKER);
   //        } else {
   //          if (item instanceof PlaceholderContributionItem) {
   //            coolItemMem.putString(
   //                IWorkbenchConstants.TAG_ITEM_TYPE,
   //                IWorkbenchConstants.TAG_TYPE_PLACEHOLDER);
   //          } else {
   //            // Store the identifier.
   //            coolItemMem
   //                .putString(
   //                    IWorkbenchConstants.TAG_ITEM_TYPE,
   //                    IWorkbenchConstants.TAG_TYPE_TOOLBARCONTRIBUTION);
   //          }
   //
   //          /*
   //           * Retrieve a reasonable approximation of the height and
   //           * width, if possible.
   //           */
   //          final int height;
   //          final int width;
   //          if (item instanceof IToolBarContributionItem) {
   //            IToolBarContributionItem toolBarItem = (IToolBarContributionItem) item;
   //            toolBarItem.saveWidgetState();
   //            height = toolBarItem.getCurrentHeight();
   //            width = toolBarItem.getCurrentWidth();
   //          } else if (item instanceof PlaceholderContributionItem) {
   //            PlaceholderContributionItem placeholder = (PlaceholderContributionItem) item;
   //            height = placeholder.getHeight();
   //            width = placeholder.getWidth();
   //          } else {
   //            height = -1;
   //            width = -1;
   //          }
   //
   //          // Store the height and width.
   //          coolItemMem.putInteger(IWorkbenchConstants.TAG_ITEM_X,
   //              width);
   //          coolItemMem.putInteger(IWorkbenchConstants.TAG_ITEM_Y,
   //              height);
   //        }
   //      }
   //    }
 
 
   // Save each page.
   for (PageList::iterator itr = pageList.Begin();
       itr != pageList.End(); ++itr)
   {
     WorkbenchPage::Pointer page = itr->Cast<WorkbenchPage>();
 
     // Save perspective.
     IMemento::Pointer pageMem = memento
     ->CreateChild(WorkbenchConstants::TAG_PAGE);
     pageMem->PutString(WorkbenchConstants::TAG_LABEL, page->GetLabel());
     //result.add(page.saveState(pageMem));
     result &= page->SaveState(pageMem);
 
     if (page == GetActivePage().Cast<WorkbenchPage>())
     {
       pageMem->PutString(WorkbenchConstants::TAG_FOCUS, "true");
     }
 
     //    // Get the input.
     //    IAdaptable* input = page->GetInput();
     //    if (input != 0) {
     //      IPersistableElement persistable = (IPersistableElement) Util.getAdapter(input,
     //          IPersistableElement.class);
     //      if (persistable == null) {
     //        WorkbenchPlugin
     //            .log("Unable to save page input: " //$NON-NLS-1$
     //                + input
     //                + ", because it does not adapt to IPersistableElement"); //$NON-NLS-1$
     //      } else {
     //        // Save input.
     //        IMemento inputMem = pageMem
     //            .createChild(IWorkbenchConstants.TAG_INPUT);
     //        inputMem.putString(IWorkbenchConstants.TAG_FACTORY_ID,
     //            persistable.getFactoryId());
     //        persistable.saveState(inputMem);
     //      }
     //    }
   }
 
   // Save window advisor state.
   IMemento::Pointer windowAdvisorState = memento
   ->CreateChild(WorkbenchConstants::TAG_WORKBENCH_WINDOW_ADVISOR);
   //result.add(getWindowAdvisor().saveState(windowAdvisorState));
   result &= GetWindowAdvisor()->SaveState(windowAdvisorState);
 
   // Save actionbar advisor state.
   IMemento::Pointer actionBarAdvisorState = memento
   ->CreateChild(WorkbenchConstants::TAG_ACTION_BAR_ADVISOR);
   //result.add(getActionBarAdvisor().saveState(actionBarAdvisorState));
   result &= GetActionBarAdvisor()->SaveState(actionBarAdvisorState);
 
   //  // Only save the trim state if we're using the default layout
   //  if (defaultLayout != null) {
   //    IMemento trimState = memento.createChild(IWorkbenchConstants.TAG_TRIM);
   //    result.add(saveTrimState(trimState));
   //  }
 
   return result;
 }
 
 WorkbenchWindowConfigurer::Pointer WorkbenchWindow::GetWindowConfigurer()
 {
   if (windowConfigurer.IsNull())
   {
     // lazy initialize
     windowConfigurer = new WorkbenchWindowConfigurer(WorkbenchWindow::Pointer(this));
   }
   return windowConfigurer;
 }
 
 bool WorkbenchWindow::CanHandleShellCloseEvent()
 {
   if (!Window::CanHandleShellCloseEvent())
   {
     return false;
   }
 
   // let the advisor or other interested parties
   // veto the user's explicit request to close the window
   return FireWindowShellClosing();
 }
 
 void WorkbenchWindow::ConfigureShell(Shell::Pointer shell)
 {
   Window::ConfigureShell(shell);
 
   detachedWindowShells = new ShellPool(shell, Constants::TITLE
       | Constants::MAX | Constants::CLOSE | Constants::RESIZE | Constants::BORDER );
 
   std::string title = this->GetWindowConfigurer()->BasicGetTitle();
   if (title != "")
   {
     shell->SetText(title);
   }
 
   //  final IWorkbench workbench = getWorkbench();
   //  workbench.getHelpSystem().setHelp(shell,
   //      IWorkbenchHelpContextIds.WORKBENCH_WINDOW);
 
   //    final IContextService contextService = (IContextService) getWorkbench().getService(IContextService.class);
   //    contextService.registerShell(shell, IContextService.TYPE_WINDOW);
 
   this->TrackShellActivation(shell);
   this->TrackShellResize(shell);
 }
 
 ShellPool::Pointer WorkbenchWindow::GetDetachedWindowPool()
 {
   return detachedWindowShells;
 }
 
 WorkbenchAdvisor* WorkbenchWindow::GetAdvisor()
 {
   return this->GetWorkbenchImpl()->GetAdvisor();
 }
 
 WorkbenchWindowAdvisor* WorkbenchWindow::GetWindowAdvisor()
 {
   if (windowAdvisor == 0)
   {
     windowAdvisor = this->GetAdvisor()->CreateWorkbenchWindowAdvisor(this->GetWindowConfigurer());
     poco_check_ptr(windowAdvisor);
   }
   return windowAdvisor;
 }
 
 ActionBarAdvisor::Pointer WorkbenchWindow::GetActionBarAdvisor()
 {
   if (actionBarAdvisor.IsNull())
   {
     actionBarAdvisor = this->GetWindowAdvisor()->CreateActionBarAdvisor(this->GetWindowConfigurer()->GetActionBarConfigurer());
     poco_assert(actionBarAdvisor.IsNotNull());
   }
   return actionBarAdvisor;
 }
 
 Workbench* WorkbenchWindow::GetWorkbenchImpl()
 {
   return dynamic_cast<Workbench*>(this->GetWorkbench());
 }
 
 void WorkbenchWindow::ShowEmptyWindowContents()
 {
   if (!emptyWindowContentsCreated)
   {
     void* parent = this->GetPageComposite();
     emptyWindowContents = this->GetWindowAdvisor()->CreateEmptyWindowContents(
         parent);
     emptyWindowContentsCreated = true;
     //    // force the empty window composite to be layed out
     //    ((StackLayout) parent.getLayout()).topControl = emptyWindowContents;
     //    parent.layout();
   }
 }
 
 void WorkbenchWindow::HideEmptyWindowContents()
 {
   if (emptyWindowContentsCreated)
   {
     if (emptyWindowContents != 0)
     {
       Tweaklets::Get(GuiWidgetsTweaklet::KEY)->Dispose(emptyWindowContents);
       emptyWindowContents = 0;
       //this->GetPageComposite().layout();
     }
     emptyWindowContentsCreated = false;
   }
 }
 
 WorkbenchWindow::ServiceLocatorOwner::ServiceLocatorOwner(WorkbenchWindow* wnd)
 : window(wnd)
 {
 
 }
 
 void WorkbenchWindow::ServiceLocatorOwner::Dispose()
 {
   Shell::Pointer shell = window->GetShell();
   if (shell != 0)
   {
     window->Close();
   }
 }
 
 bool WorkbenchWindow::PageList::Add(IWorkbenchPage::Pointer object)
 {
   pagesInCreationOrder.push_back(object);
   pagesInActivationOrder.push_front(object);
   // It will be moved to top only when activated.
   return true;
 }
 
 WorkbenchWindow::PageList::iterator WorkbenchWindow::PageList::Begin()
 {
   return pagesInCreationOrder.begin();
 }
 
 WorkbenchWindow::PageList::iterator WorkbenchWindow::PageList::End()
 {
   return pagesInCreationOrder.end();
 }
 
 bool WorkbenchWindow::PageList::Contains(IWorkbenchPage::Pointer object)
 {
   return std::find(pagesInCreationOrder.begin(), pagesInCreationOrder.end(),
       object) != pagesInCreationOrder.end();
 }
 
 bool WorkbenchWindow::PageList::Remove(IWorkbenchPage::Pointer object)
 {
   if (active == object)
   {
     active = 0;
   }
   pagesInActivationOrder.remove(object);
   std::size_t origSize = pagesInCreationOrder.size();
   pagesInCreationOrder.remove(object);
   return origSize != pagesInCreationOrder.size();
 }
 
 void WorkbenchWindow::PageList::Clear()
 {
   pagesInCreationOrder.clear();
   pagesInActivationOrder.clear();
   active = 0;
 }
 
 bool WorkbenchWindow::PageList::IsEmpty()
 {
   return pagesInCreationOrder.empty();
 }
 
 const std::list<IWorkbenchPage::Pointer>& WorkbenchWindow::PageList::GetPages()
 {
   return pagesInCreationOrder;
 }
 
 void WorkbenchWindow::PageList::SetActive(IWorkbenchPage::Pointer page)
 {
   if (active == page)
   {
     return;
   }
 
   active = page;
 
   if (page.IsNotNull())
   {
     pagesInActivationOrder.remove(page);
     pagesInActivationOrder.push_back(page);
   }
 }
 
 WorkbenchPage::Pointer WorkbenchWindow::PageList::GetActive()
 {
   return active.Cast<WorkbenchPage>();
 }
 
 WorkbenchPage::Pointer WorkbenchWindow::PageList::GetNextActive()
 {
   if (active.IsNull())
   {
     if (pagesInActivationOrder.empty())
     {
       return WorkbenchPage::Pointer(0);
     }
 
     return pagesInActivationOrder.back().Cast<WorkbenchPage>();
   }
 
   if (pagesInActivationOrder.size() < 2)
   {
     return WorkbenchPage::Pointer(0);
   }
 
   std::list<IWorkbenchPage::Pointer>::reverse_iterator riter =
   pagesInActivationOrder.rbegin();
   return (++riter)->Cast<WorkbenchPage>();
 }
 
 WorkbenchWindow::ShellActivationListener::ShellActivationListener(WorkbenchWindow::Pointer w) :
 window(w)
 {
 }
 
 void WorkbenchWindow::ShellActivationListener::ShellActivated(ShellEvent::Pointer /*event*/)
 {
   WorkbenchWindow::Pointer wnd(window);
 
   wnd->shellActivated = true;
   wnd->serviceLocator->Activate();
   wnd->GetWorkbenchImpl()->SetActivatedWindow(wnd);
   WorkbenchPage::Pointer currentPage = wnd->GetActivePage().Cast<WorkbenchPage>();
   if (currentPage != 0)
   {
     IWorkbenchPart::Pointer part = currentPage->GetActivePart();
     if (part != 0)
     {
       PartSite::Pointer site = part->GetSite().Cast<PartSite>();
       site->GetPane()->ShellActivated();
     }
     IEditorPart::Pointer editor = currentPage->GetActiveEditor();
     if (editor != 0)
     {
       PartSite::Pointer site = editor->GetSite().Cast<PartSite>();
       site->GetPane()->ShellActivated();
     }
     wnd->GetWorkbenchImpl()->FireWindowActivated(wnd);
   }
   //liftRestrictions();
 }
 
 void WorkbenchWindow::ShellActivationListener::ShellDeactivated(ShellEvent::Pointer /*event*/)
 {
   WorkbenchWindow::Pointer wnd(window);
 
   wnd->shellActivated = false;
   //imposeRestrictions();
   wnd->serviceLocator->Deactivate();
   WorkbenchPage::Pointer currentPage = wnd->GetActivePage().Cast<WorkbenchPage>();
   if (currentPage != 0)
   {
     IWorkbenchPart::Pointer part = currentPage->GetActivePart();
     if (part != 0)
     {
       PartSite::Pointer site = part->GetSite().Cast<PartSite>();
       site->GetPane()->ShellDeactivated();
     }
     IEditorPart::Pointer editor = currentPage->GetActiveEditor();
     if (editor != 0)
     {
       PartSite::Pointer site = editor->GetSite().Cast<PartSite>();
       site->GetPane()->ShellDeactivated();
     }
     wnd->GetWorkbenchImpl()->FireWindowDeactivated(wnd);
   }
 }
 
 void WorkbenchWindow::TrackShellActivation(Shell::Pointer shell)
 {
   shellActivationListener = new ShellActivationListener(WorkbenchWindow::Pointer(this));
   shell->AddShellListener(shellActivationListener);
 }
 
 WorkbenchWindow::ControlResizeListener::ControlResizeListener(WorkbenchWindow* w)
 : window(w)
 {
 }
 
 GuiTk::IControlListener::Events::Types WorkbenchWindow::ControlResizeListener::GetEventTypes() const
 {
   return Events::MOVED | Events::RESIZED;
 }
 
 void WorkbenchWindow::
 ControlResizeListener::ControlMoved(GuiTk::ControlEvent::Pointer /*e*/)
 {
   this->SaveBounds();
 }
 
 void WorkbenchWindow::
 ControlResizeListener::ControlResized(GuiTk::ControlEvent::Pointer /*e*/)
 {
   this->SaveBounds();
 }
 
 void WorkbenchWindow::ControlResizeListener::SaveBounds()
 {
   WorkbenchWindow::Pointer wnd(window);
 
   Shell::Pointer shell = wnd->GetShell();
   if (shell == 0)
   {
     return;
   }
   //  if (shell->IsDisposed())
   //  {
   //    return;
   //  }
   if (shell->GetMinimized())
   {
     return;
   }
   if (shell->GetMaximized())
   {
     wnd->asMaximizedState = true;
     return;
   }
   wnd->asMaximizedState = false;
   wnd->normalBounds = shell->GetBounds();
 }
 
 void WorkbenchWindow::TrackShellResize(Shell::Pointer newShell)
 {
   controlResizeListener = new ControlResizeListener(this);
   Tweaklets::Get(GuiWidgetsTweaklet::KEY)->AddControlListener(newShell->GetControl(), controlResizeListener);
 }
 
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.h b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.h
index 7254efeb9b..8b09882b9c 100644
--- a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.h
+++ b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.h
@@ -1,634 +1,643 @@
 /*===================================================================
 
 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 BERRYWORKBENCHWINDOW_H_
 #define BERRYWORKBENCHWINDOW_H_
 
 #include "berryIWorkbenchWindow.h"
 
 #include "berryIPerspectiveListener.h"
 #include "guitk/berryGuiTkIControlListener.h"
 #include "berryWindow.h"
 
 #include "berryWorkbenchWindowConfigurer.h"
 #include "berryShellPool.h"
 #include "berryServiceLocator.h"
 #include "berryWWinPartService.h"
 
 #include "application/berryWorkbenchAdvisor.h"
 #include "application/berryWorkbenchWindowAdvisor.h"
 #include "application/berryActionBarAdvisor.h"
 
 #include <list>
 
 namespace berry
 {
 
 struct IWorkbench;
 struct IWorkbenchPage;
 class WorkbenchPage;
 struct IPartService;
 struct ISelectionService;
 struct IPerspectiveDescriptor;
 
 class Workbench;
 
 /**
  * \ingroup org_blueberry_ui
  *
  */
 class BERRY_UI WorkbenchWindow: public Window, public IWorkbenchWindow
 {
 
 public:
 
   berryObjectMacro(WorkbenchWindow);
 
   WorkbenchWindow(int number);
 
   ~WorkbenchWindow();
 
   Object::Pointer GetService(const std::string& key);
 
   bool HasService(const std::string& key) const;
 
   int Open();
   bool Close();
 
   Shell::Pointer GetShell();
 
   /**
    * @see org.blueberry.ui.IPageService
    */
   void AddPerspectiveListener(IPerspectiveListener::Pointer l);
 
   /**
    * @see org.blueberry.ui.IPageService
    */
   void RemovePerspectiveListener(IPerspectiveListener::Pointer l);
 
   /**
    * @see org.blueberry.ui.IPageService
    */
   IPerspectiveListener::Events& GetPerspectiveEvents();
 
   SmartPointer<IWorkbenchPage> GetActivePage();
 
   SmartPointer<IWorkbenchPage> GetPage(int i);
 
+  void SetPerspectiveExcludeList(std::vector<std::string> v);
+  std::vector<std::string> GetPerspectiveExcludeList();
+
+  void SetViewExcludeList(std::vector<std::string> v);
+  std::vector<std::string> GetViewExcludeList();
+
   /**
    * Sets the active page within the window.
    *
    * @param in
    *            identifies the new active page, or <code>null</code> for no
    *            active page
    */
   void SetActivePage(SmartPointer<IWorkbenchPage> in);
 
   IWorkbench* GetWorkbench();
 
   IPartService* GetPartService();
 
   ISelectionService* GetSelectionService();
 
   SmartPointer<IWorkbenchPage> OpenPage(const std::string& perspectiveId,
       IAdaptable* input);
 
   SmartPointer<IWorkbenchPage> OpenPage(IAdaptable* input);
 
   //TODO menu manager
   //virtual void* GetMenuManager() = 0;
 
   virtual bool SaveState(IMemento::Pointer memento);
 
   /**
    * Called when this window is about to be closed.
    *
    * Subclasses may overide to add code that returns <code>false</code> to
    * prevent closing under certain conditions.
    */
   virtual bool OkToClose();
 
   bool RestoreState(IMemento::Pointer memento, SmartPointer<
       IPerspectiveDescriptor> activeDescriptor);
 
   /**
    * Returns the number. This corresponds to a page number in a window or a
    * window number in the workbench.
    */
   int GetNumber();
 
   /**
    * <p>
    * Indicates the start of a large update within this window. This is used to
    * disable CPU-intensive, change-sensitive services that were temporarily
    * disabled in the midst of large changes. This method should always be
    * called in tandem with <code>largeUpdateEnd</code>, and the event loop
    * should not be allowed to spin before that method is called.
    * </p>
    * <p>
    * Important: always use with <code>largeUpdateEnd</code>!
    * </p>
    *
    * @since 3.1
    */
   void LargeUpdateStart();
 
   /**
    * <p>
    * Indicates the end of a large update within this window. This is used to
    * re-enable services that were temporarily disabled in the midst of large
    * changes. This method should always be called in tandem with
    * <code>largeUpdateStart</code>, and the event loop should not be
    * allowed to spin before this method is called.
    * </p>
    * <p>
    * Important: always protect this call by using <code>finally</code>!
    * </p>
    *
    * @since 3.1
    */
   void LargeUpdateEnd();
 
 protected:
 
   friend class WorkbenchConfigurer;
   friend class WorkbenchWindowConfigurer;
   friend class WorkbenchWindowConfigurer::WindowActionBarConfigurer;
   friend class Workbench;
   friend class LayoutPartSash;
   friend class EditorSashContainer;
   friend class WorkbenchPage;
   friend class DetachedWindow;
 
   /**
    * Returns the GUI dependent page composite, under which the window's
    * pages create their controls.
    */
   void* GetPageComposite();
 
   /**
    * Creates and remembers the client composite, under which workbench pages
    * create their controls.
    *
    * @since 3.0
    */
   virtual void* CreatePageComposite(void* parent) = 0;
 
   /**
    * Creates the contents of the workbench window, including trim controls and
    * the client composite. This MUST create the client composite via a call to
    * <code>createClientComposite</code>.
    *
    * @since 3.0
    */
   void* CreateContents(Shell::Pointer parent);
 
   /**
    * Creates the default contents and layout of the shell.
    *
    * @param shell
    *            the shell
    */
   virtual void CreateDefaultContents(Shell::Pointer shell);
 
   /**
    * Returns the unique object that applications use to configure this window.
    * <p>
    * IMPORTANT This method is declared package-private to prevent regular
    * plug-ins from downcasting IWorkbenchWindow to WorkbenchWindow and getting
    * hold of the workbench window configurer that would allow them to tamper
    * with the workbench window. The workbench window configurer is available
    * only to the application.
    * </p>
    */
   WorkbenchWindowConfigurer::Pointer GetWindowConfigurer();
 
   bool CanHandleShellCloseEvent();
 
   /*
    * @see berry::Window#configureShell(Shell::Pointer)
    */
   void ConfigureShell(Shell::Pointer shell);
 
   ShellPool::Pointer GetDetachedWindowPool();
 
   /**
    * Fills the window's real action bars.
    *
    * @param flags
    *            indicate which bars to fill
    */
   void FillActionBars(int flags);
 
   /**
    * The <code>WorkbenchWindow</code> implementation of this method
    * delegates to the window configurer.
    *
    * @since 3.0
    */
   Point GetInitialSize();
 
   /**
    * Returns the default page input for workbench pages opened in this window.
    *
    * @return the default page input or <code>null</code> if none
    * @since 3.1
    */
   IAdaptable* GetDefaultPageInput();
 
   bool IsClosing();
 
   /**
    * Opens a new page. Assumes that busy cursor is active.
    * <p>
    * <b>Note:</b> Since release 2.0, a window is limited to contain at most
    * one page. If a page exist in the window when this method is used, then
    * another window is created for the new page. Callers are strongly
    * recommended to use the <code>IWorkbench.openPerspective</code> APIs to
    * programmatically show a perspective.
    * </p>
    */
   SmartPointer<IWorkbenchPage> BusyOpenPage(const std::string& perspID,
       IAdaptable* input);
 
   bool ClosePage(SmartPointer<IWorkbenchPage> in, bool save);
 
   /**
    * Makes the window visible and frontmost.
    */
   void MakeVisible();
 
   /**
    * The composite under which workbench pages create their controls.
    *
    * @since 3.0
    */
   void* pageComposite;
 
 private:
 
   /**
    * Constant indicating that all the actions bars should be filled.
    *
    * @since 3.0
    */
   static const int FILL_ALL_ACTION_BARS;
 
   ShellPool::Pointer detachedWindowShells;
 
   /**
    * Object for configuring this workbench window. Lazily initialized to an
    * instance unique to this window.
    *
    * @since 3.0
    */
   WorkbenchWindowConfigurer::Pointer windowConfigurer;
 
   WorkbenchWindowAdvisor* windowAdvisor;
 
   ActionBarAdvisor::Pointer actionBarAdvisor;
 
   int number;
 
   /**
    * The number of large updates that are currently going on. If this is
    * number is greater than zero, then UI updateActionBars is a no-op.
    */
   int largeUpdates;
 
   bool closing;
   bool shellActivated;
   bool updateDisabled;
 
   /**
    * The map of services maintained by the workbench window. These services
    * are initialized during workbench window during the
    * {@link #configureShell(Shell)}.
    */
   ServiceLocator::Pointer serviceLocator;
 
   bool emptyWindowContentsCreated;
   void* emptyWindowContents;
 
   Rectangle normalBounds;
 
   bool asMaximizedState;
 
   IPerspectiveListener::Events perspectiveEvents;
 
   WWinPartService partService;
 
+  std::vector<std::string> perspectiveExcludeList;
+  std::vector<std::string> viewExcludeList;
+
   struct ServiceLocatorOwner: public IDisposable
   {
     ServiceLocatorOwner(WorkbenchWindow* wnd);
 
     WorkbenchWindow* window;
 
     void Dispose();
   };
 
   IDisposable::Pointer serviceLocatorOwner;
 
   class PageList
   {
 
   private:
     // List of pages in the order they were created;
     std::list<SmartPointer<IWorkbenchPage> > pagesInCreationOrder;
 
     // List of pages where the top is the last activated.
     std::list<SmartPointer<IWorkbenchPage> > pagesInActivationOrder;
 
     // The page explicitly activated
     SmartPointer<IWorkbenchPage> active;
 
   public:
 
     typedef std::list<SmartPointer<IWorkbenchPage> >::iterator iterator;
 
     bool Add(SmartPointer<IWorkbenchPage> object);
 
     iterator Begin();
 
     iterator End();
 
     void Clear();
 
     bool Contains(SmartPointer<IWorkbenchPage> object);
 
     bool Remove(SmartPointer<IWorkbenchPage> object);
 
     bool IsEmpty();
 
     const std::list<SmartPointer<IWorkbenchPage> >& GetPages();
 
     void SetActive(SmartPointer<IWorkbenchPage> page);
 
     SmartPointer<WorkbenchPage> GetActive();
 
     SmartPointer<WorkbenchPage> GetNextActive();
   };
 
   PageList pageList;
 
   /**
    * Notifies interested parties (namely the advisor) that the window is about
    * to be opened.
    *
    * @since 3.1
    */
   void FireWindowOpening();
 
   /**
    * Notifies interested parties (namely the advisor) that the window has been
    * restored from a previously saved state.
    *
    * @throws WorkbenchException
    *             passed through from the advisor
    * @since 3.1
    */
   void FireWindowRestored();
 
   /**
    * Notifies interested parties (namely the advisor) that the window has been
    * created.
    *
    * @since 3.1
    */
   void FireWindowCreated();
 
   /**
    * Notifies interested parties (namely the advisor and the window listeners)
    * that the window has been opened.
    *
    * @since 3.1
    */
   void FireWindowOpened();
 
   /**
    * Notifies interested parties (namely the advisor) that the window's shell
    * is closing. Allows the close to be vetoed.
    *
    * @return <code>true</code> if the close should proceed,
    *         <code>false</code> if it should be canceled
    * @since 3.1
    */
   bool FireWindowShellClosing();
 
   /**
    * Notifies interested parties (namely the advisor and the window listeners)
    * that the window has been closed.
    *
    * @since 3.1
    */
   void FireWindowClosed();
 
   //  /**
   //   * Fires page activated
   //   */
   //  void FirePageActivated(IWorkbenchPage::Pointer page);
   //
   //  /**
   //   * Fires page closed
   //   */
   //  void FirePageClosed(IWorkbenchPage::Pointer page);
   //
   //  /**
   //   * Fires page opened
   //   */
   //  void FirePageOpened(IWorkbenchPage::Pointer page);
 
   /**
    * Fires perspective activated
    */
   void FirePerspectiveActivated(SmartPointer<IWorkbenchPage> page,
       IPerspectiveDescriptor::Pointer perspective);
 
   /**
    * Fires perspective deactivated.
    *
    * @since 3.2
    */
   void FirePerspectivePreDeactivate(SmartPointer<IWorkbenchPage> page,
       IPerspectiveDescriptor::Pointer perspective);
 
   /**
    * Fires perspective deactivated.
    *
    * @since 3.1
    */
   void FirePerspectiveDeactivated(SmartPointer<IWorkbenchPage> page,
       IPerspectiveDescriptor::Pointer perspective);
 
   /**
    * Fires perspective changed
    */
   void FirePerspectiveChanged(SmartPointer<IWorkbenchPage> ,
       IPerspectiveDescriptor::Pointer perspective, const std::string& changeId);
 
   /**
    * Fires perspective changed for an affected part
    */
   void FirePerspectiveChanged(SmartPointer<IWorkbenchPage> ,
       IPerspectiveDescriptor::Pointer perspective,
       IWorkbenchPartReference::Pointer partRef, const std::string& changeId);
 
   /**
    * Fires perspective closed
    */
   void FirePerspectiveClosed(SmartPointer<IWorkbenchPage> ,
       IPerspectiveDescriptor::Pointer perspective);
 
   /**
    * Fires perspective opened
    */
   void FirePerspectiveOpened(SmartPointer<IWorkbenchPage> ,
       IPerspectiveDescriptor::Pointer perspective);
 
   /**
    * Fires perspective saved as.
    *
    * @since 3.1
    */
   void FirePerspectiveSavedAs(SmartPointer<IWorkbenchPage> ,
       IPerspectiveDescriptor::Pointer oldPerspective,
       IPerspectiveDescriptor::Pointer newPerspective);
 
   /**
    * Returns the workbench advisor. Assumes the workbench has been created
    * already.
    * <p>
    * IMPORTANT This method is declared private to prevent regular plug-ins
    * from downcasting IWorkbenchWindow to WorkbenchWindow and getting hold of
    * the workbench advisor that would allow them to tamper with the workbench.
    * The workbench advisor is internal to the application.
    * </p>
    */
   /* private - DO NOT CHANGE */
   WorkbenchAdvisor* GetAdvisor();
 
   /**
    * Returns the window advisor, creating a new one for this window if needed.
    * <p>
    * IMPORTANT This method is declared private to prevent regular plug-ins
    * from downcasting IWorkbenchWindow to WorkbenchWindow and getting hold of
    * the window advisor that would allow them to tamper with the window. The
    * window advisor is internal to the application.
    * </p>
    */
   /* private - DO NOT CHANGE */
   WorkbenchWindowAdvisor* GetWindowAdvisor();
 
   /**
    * Returns the action bar advisor, creating a new one for this window if
    * needed.
    * <p>
    * IMPORTANT This method is declared private to prevent regular plug-ins
    * from downcasting IWorkbenchWindow to WorkbenchWindow and getting hold of
    * the action bar advisor that would allow them to tamper with the window's
    * action bars. The action bar advisor is internal to the application.
    * </p>
    */
   /* private - DO NOT CHANGE */
   ActionBarAdvisor::Pointer GetActionBarAdvisor();
 
   /*
    * Returns the IWorkbench implementation.
    */
   Workbench* GetWorkbenchImpl();
 
   bool UnableToRestorePage(IMemento::Pointer pageMem);
 
   /**
    * Close the window.
    *
    * Assumes that busy cursor is active.
    */
   bool BusyClose();
 
   /**
    * Unconditionally close this window. Assumes the proper flags have been set
    * correctly (e.i. closing and updateDisabled)
    */
   bool HardClose();
 
   /**
    * Close all of the pages.
    */
   void CloseAllPages();
 
   /**
    * Save all of the pages. Returns true if the operation succeeded.
    */
   bool SaveAllPages(bool bConfirm);
 
   void ShowEmptyWindowContents();
 
   void HideEmptyWindowContents();
 
   struct ShellActivationListener: public IShellListener
   {
     ShellActivationListener(WorkbenchWindow::Pointer window);
 
     void ShellActivated(ShellEvent::Pointer event);
 
     void ShellDeactivated(ShellEvent::Pointer event);
 
   private:
 
     WorkbenchWindow::WeakPtr window;
   };
 
   IShellListener::Pointer shellActivationListener;
 
   /**
    * Hooks a listener to track the activation and deactivation of the window's
    * shell. Notifies the active part and editor of the change
    */
   void TrackShellActivation(Shell::Pointer shell);
 
   struct ControlResizeListener: public GuiTk::IControlListener
   {
     ControlResizeListener(WorkbenchWindow* window);
 
     GuiTk::IControlListener::Events::Types GetEventTypes() const;
 
     void ControlMoved(GuiTk::ControlEvent::Pointer e);
 
     void ControlResized(GuiTk::ControlEvent::Pointer e);
 
   private:
 
     void SaveBounds();
 
     WorkbenchWindow* window;
   };
 
   GuiTk::IControlListener::Pointer controlResizeListener;
 
   /**
    * Hooks a listener to track the resize of the window's shell. Stores the
    * new bounds if in normal state - that is, not in minimized or maximized
    * state)
    */
   void TrackShellResize(Shell::Pointer newShell);
 
 };
 
 }
 
 #endif /*BERRYWORKBENCHWINDOW_H_*/
diff --git a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
index a7123b9663..43d670f049 100644
--- a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
+++ b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
@@ -1,1308 +1,1311 @@
 /*===================================================================
 
 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 <QmitkOpenXnatEditorAction.h>
 
 #include <itkConfigure.h>
 #include <vtkConfigure.h>
 #include <mitkVersion.h>
 #include <mitkIDataStorageService.h>
 #include <mitkIDataStorageReference.h>
 #include <mitkDataStorageEditorInput.h>
 #include <mitkWorkbenchUtil.h>
 #include <vtkVersionMacros.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 PartListenerForViewBrowser: public berry::IPartListener
 {
 public:
 
     PartListenerForViewBrowser(QAction* act) :
         viewBrowserAction(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.viewbrowser")
         {
             viewBrowserAction->setChecked(true);
         }
     }
 
     void PartClosed(berry::IWorkbenchPartReference::Pointer ref)
     {
         if (ref->GetId()=="org.mitk.views.viewbrowser")
         {
             viewBrowserAction->setChecked(false);
         }
     }
 
     void PartVisible(berry::IWorkbenchPartReference::Pointer ref)
     {
         if (ref->GetId()=="org.mitk.views.viewbrowser")
         {
             viewBrowserAction->setChecked(true);
         }
     }
 
     void PartHidden(berry::IWorkbenchPartReference::Pointer ref)
     {
         if (ref->GetId()=="org.mitk.views.viewbrowser")
         {
             viewBrowserAction->setChecked(false);
         }
     }
 
 private:
     QAction* viewBrowserAction;
 
 };
 
 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);
             }
             if(windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.xnat.browser"))
             {
                 windowAdvisor->openXnatEditorAction->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);
             }
             if(windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.xnat.browser"))
             {
                 windowAdvisor->openXnatEditorAction->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 = 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());
 
+    window->SetPerspectiveExcludeList(perspectiveExcludeList);
+    window->SetViewExcludeList(viewExcludeList);
+
     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(QIcon(":/org.mitk.gui.qt.ext/dcm-icon.png"),window);
     }
     if(this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.xnat.browser"))
     {
         openXnatEditorAction = new QmitkOpenXnatEditorAction(QIcon(":/org.mitk.gui.qt.ext/xnat-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");
+        imageNavigatorAction->setToolTip("Toggle image navigator for navigating through image");
     }
 
     // add view browser
     viewBrowserAction = new QAction(QIcon(":/org.mitk.gui.qt.ext/Slider.png"), "&View Browser", NULL);
     bool viewBrowserFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.viewbrowser");
     if (viewBrowserFound)
     {
         QObject::connect(viewBrowserAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onViewBrowser()));
         viewBrowserAction->setCheckable(true);
 
         // add part listener for view browser
         viewBrowserPartListener = new PartListenerForViewBrowser(viewBrowserAction);
         window->GetPartService()->AddPartListener(viewBrowserPartListener);
         berry::IViewPart::Pointer viewBrowser = window->GetActivePage()->FindView("org.mitk.views.viewbrowser");
 
         viewBrowserAction->setChecked(false);
         if (viewBrowser)
         {
             bool isviewBrowserVisible = window->GetActivePage()->IsPartVisible(viewBrowser);
             if (isviewBrowserVisible)
                 viewBrowserAction->setChecked(true);
         }
-        viewBrowserAction->setToolTip("Open view browser");
+        viewBrowserAction->setToolTip("Toggle view browser");
     }
 
     // toolbar for showing file open, undo, redo and other main actions
     QToolBar* mainActionsToolBar = new QToolBar;
     mainActionsToolBar->setObjectName("mainActionsToolBar");
     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(this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.xnat.browser"))
     {
         mainActionsToolBar->addAction(openXnatEditorAction);
     }
     if (imageNavigatorViewFound)
     {
         mainActionsToolBar->addAction(imageNavigatorAction);
     }
     if (viewBrowserFound)
     {
         mainActionsToolBar->addAction(viewBrowserAction);
     }
     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;
     qPerspectiveToolbar->setObjectName("perspectiveToolBar");
 
     if (showPerspectiveToolbar)
     {
         qPerspectiveToolbar->addActions(perspGroup->actions());
         mainWindow->addToolBar(qPerspectiveToolbar);
     }
     else
         delete qPerspectiveToolbar;
 
     // ==== View Toolbar ==================================
     QToolBar* qToolbar = new QToolBar;
     qToolbar->setObjectName("viewToolBar");
 
     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");
     helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
     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::onHelpOpenHelpPerspective()
 {
     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::onViewBrowser()
 {
     // get view browser
     berry::IViewPart::Pointer viewBrowser =
             berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->FindView("org.mitk.views.viewbrowser");
     if (viewBrowser)
     {
         bool isVisible = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->IsPartVisible(viewBrowser);
         if (isVisible)
         {
             berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->HideView(viewBrowser);
             return;
         }
     }
     berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ShowView("org.mitk.views.viewbrowser");
 }
 
 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); //text file only for reading
 
         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::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.viewbrowser/src/internal/ViewBrowserView.cpp b/Plugins/org.mitk.gui.qt.viewbrowser/src/internal/ViewBrowserView.cpp
index f99bb8a788..616d550bdb 100644
--- a/Plugins/org.mitk.gui.qt.viewbrowser/src/internal/ViewBrowserView.cpp
+++ b/Plugins/org.mitk.gui.qt.viewbrowser/src/internal/ViewBrowserView.cpp
@@ -1,398 +1,419 @@
 /*===================================================================
 
 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 <berryIPerspectiveRegistry.h>
 #include <berryPlatformUI.h>
 #include <berryIWorkbenchPage.h>
 
 // Qmitk
 #include "ViewBrowserView.h"
 #include <src/internal/mitkQtPerspectiveItem.h>
 #include <src/internal/mitkQtViewItem.h>
 #include <src/internal/QmitkNewPerspectiveDialog.h>
 
 // Qt
 #include <QMessageBox>
 #include <QTreeView>
 #include <QStandardItem>
 
 
 struct ViewBrowserViewListener : public berry::IPerspectiveListener
 {
     ViewBrowserViewListener(ViewBrowserView* switcher)
         : switcher(switcher)
     {}
 
     Events::Types GetPerspectiveEventTypes() const
     {
         return Events::ACTIVATED;
     }
 
     virtual void PerspectiveChanged(berry::SmartPointer<berry::IWorkbenchPage> /*page*/,
                                     berry::IPerspectiveDescriptor::Pointer /*perspective*/, const std::string& /*changeId*/)
     {
         switcher->FillTreeList();
     }
 
     void PerspectiveActivated(berry::IWorkbenchPage::Pointer /*page*/,
                               berry::IPerspectiveDescriptor::Pointer perspective)
     {
         switcher->FillTreeList();
     }
 
 private:
     ViewBrowserView* switcher;
 };
 
 const std::string ViewBrowserView::VIEW_ID = "org.mitk.views.viewbrowser";
 
 bool compareViews(berry::IViewDescriptor::Pointer a, berry::IViewDescriptor::Pointer b)
 {
     if (a.IsNull() || b.IsNull())
         return false;
     return a->GetLabel().compare(b->GetLabel()) < 0;
 }
 
 void ViewBrowserView::SetFocus()
 {
 
 }
 
 void ViewBrowserView::CreateQtPartControl( QWidget *parent )
 {
     // create GUI widgets from the Qt Designer's .ui file
     m_Parent = parent;
     m_Controls.setupUi( parent );
     connect( m_Controls.m_PluginTreeView, SIGNAL(customContextMenuRequested(QPoint)), SLOT(CustomMenuRequested(QPoint)));
-    connect( m_Controls.m_PluginTreeView, SIGNAL(clicked(const QModelIndex&)), SLOT(ItemClicked(const QModelIndex&)));
+    connect( m_Controls.m_PluginTreeView, SIGNAL(doubleClicked(const QModelIndex&)), SLOT(ItemClicked(const QModelIndex&)));
     connect( m_Controls.pushButton, SIGNAL(clicked()), SLOT(ButtonClicked()) );
 
     m_ContextMenu = new QMenu(m_Controls.m_PluginTreeView);
     m_Controls.m_PluginTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
 
     // Create a new TreeModel for the data
     m_TreeModel = new QStandardItemModel();
     FillTreeList();
     m_Controls.m_PluginTreeView->setModel(m_TreeModel);
 
     this->perspListener = new ViewBrowserViewListener(this);
     //berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->AddPerspectiveListener(this->perspListener);
 }
 
 void ViewBrowserView::ButtonClicked()
 {
     berry::IWorkbenchPage::Pointer page = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
     berry::IPerspectiveDescriptor::Pointer currentPersp = page->GetPerspective();
 
     berry::IPerspectiveRegistry* perspRegistry = berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry();
     std::vector<berry::IPerspectiveDescriptor::Pointer> perspectives(perspRegistry->GetPerspectives());
     for (unsigned int i=0; i<perspectives.size(); i++)
         berry::PlatformUI::GetWorkbench()->ShowPerspective( perspectives.at(i)->GetId(), berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow() );
 
     FillTreeList();
     berry::PlatformUI::GetWorkbench()->ShowPerspective( currentPersp->GetId(), berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow() );
 }
 
 void ViewBrowserView::FillTreeList()
 {
     m_TreeModel->clear();
     QStandardItem *treeRootItem = m_TreeModel->invisibleRootItem();
 
     // Get all available views and create a map of all views
     std::map<std::string, berry::IViewDescriptor::Pointer> viewMap;
     berry::IViewRegistry* viewRegistry = berry::PlatformUI::GetWorkbench()->GetViewRegistry();
     std::vector<berry::IViewDescriptor::Pointer> views(viewRegistry->GetViews());
     for (unsigned int i=0; i<views.size(); i++)
     {
         viewMap[views[i]->GetId()] = views[i];
     }
     std::sort(views.begin(), views.end(), compareViews);
 
     // Get all available perspectives
     berry::IPerspectiveRegistry* perspRegistry = berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry();
     std::vector<berry::IPerspectiveDescriptor::Pointer> perspectives(perspRegistry->GetPerspectives());
 
     // workbench window available?
     if (berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow().IsNull())
         return;
 
     // Fill the TreeModel
     berry::IWorkbenchPage::Pointer page = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
     QModelIndex currentIndex;
     berry::IPerspectiveDescriptor::Pointer currentPersp = page->GetPerspective();
+    std::vector<std::string> perspectiveExcludeList = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetPerspectiveExcludeList();
+    std::vector<std::string> viewExcludeList = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetViewExcludeList();
 
     for (unsigned int i=0; i<perspectives.size(); i++)
     {
         berry::IPerspectiveDescriptor::Pointer p = perspectives.at(i);
+
+        bool skipPerspective = false;
+        for(unsigned int e=0; e<perspectiveExcludeList.size(); e++)
+            if(perspectiveExcludeList.at(e)==p->GetId())
+            {
+                skipPerspective = true;
+                break;
+            }
+        if (skipPerspective)
+            continue;
+
         QList< QStandardItem*> preparedRow;
         mitk::QtPerspectiveItem* pItem = new mitk::QtPerspectiveItem(QString::fromStdString(p->GetLabel()));
         pItem->m_Perspective = p;
-        //pItem->setCheckable(true);
-        //pItem->setCheckState(Qt::Checked);
         preparedRow << pItem;
         treeRootItem->appendRow(preparedRow);
 
         if (currentPersp->GetId()==p->GetId())
             currentIndex = pItem->index();
 
         for (unsigned int i = 0; i < views.size(); ++i)
         {
+            bool skipView = false;
+            for(unsigned int e=0; e<viewExcludeList.size(); e++)
+                if(viewExcludeList.at(e)==views.at(i)->GetId())
+                {
+                    skipView = true;
+                    break;
+                }
+            if (skipView)
+                continue;
+
             if ( page->HasView(p->GetId(), views.at(i)->GetId()) )
             {
               QList<QStandardItem *> secondRow;
               QIcon* icon = static_cast<QIcon*>(views[i]->GetImageDescriptor()->CreateImage());
               mitk::QtViewItem* vItem = new mitk::QtViewItem(*icon, QString::fromStdString(views[i]->GetLabel()));
               vItem->m_View = views[i];
               secondRow << vItem;
               preparedRow.first()->appendRow(secondRow);
             }
         }
 
 //        // If the current perspective is the active perspective add current views
 //        if (currentPersp.compare(p->GetId())==0)
 //        {
 //            if (curWin.IsNull())
 //                continue;
 
 //            berry::IWorkbenchPage::Pointer activePage = curWin->GetActivePage();
 //            std::vector< std::string > currentViews = activePage->GetShowViewShortcuts();
 //            // Create a vector with all current elements
 //            std::vector<berry::IViewDescriptor::Pointer> activeViews;
 //            for (int j = 0; j < currentViews.size(); ++j)
 //            {
 //                berry::IViewDescriptor::Pointer view = viewMap[currentViews[j]];
 //                if (view.IsNull())
 //                    continue;
 //                activeViews.push_back(view);
 //            }
 //            std::sort(activeViews.begin(), activeViews.end(), compareViews);
 
 
 //            for (int j = 0; j < activeViews.size(); ++j)
 //            {
 //                berry::IViewDescriptor::Pointer view =activeViews[j];
 //                QList<QStandardItem *> secondRow;
 //                QIcon* icon = static_cast<QIcon*>(view->GetImageDescriptor()->CreateImage());
 //                mitk::QtViewItem* vItem = new mitk::QtViewItem(*icon,QString::fromStdString(view->GetLabel()));
 //                vItem->m_View = view;
 //                secondRow << vItem;
 //                preparedRow.first()->appendRow(secondRow);
 //            }
 //        }
     }
 
     // Add a list with all available views
     QList< QStandardItem*> preparedRow;
     QStandardItem* pItem = new QStandardItem(QIcon(),"All Views");
     preparedRow << pItem;
     treeRootItem->appendRow(preparedRow);
     for (unsigned int i = 0; i < views.size(); ++i)
     {
         QList<QStandardItem *> secondRow;
         QIcon* icon = static_cast<QIcon*>(views[i]->GetImageDescriptor()->CreateImage());
         mitk::QtViewItem* vItem = new mitk::QtViewItem(*icon, QString::fromStdString(views[i]->GetLabel()));
         vItem->m_View = views[i];
         secondRow << vItem;
         preparedRow.first()->appendRow(secondRow);
     }
 
     m_Controls.m_PluginTreeView->setCurrentIndex(currentIndex);
 }
 
 void ViewBrowserView::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*source*/, const QList<mitk::DataNode::Pointer>& nodes )
 {
 
 }
 
 void ViewBrowserView::ItemClicked(const QModelIndex &index)
 {
     QStandardItem* item = m_TreeModel->itemFromIndex(index);
     if ( dynamic_cast< mitk::QtPerspectiveItem* >(item) )
     {
         try
         {
             mitk::QtPerspectiveItem* pItem = dynamic_cast< mitk::QtPerspectiveItem* >(item);
             berry::PlatformUI::GetWorkbench()->ShowPerspective( pItem->m_Perspective->GetId(), berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow() );
         }
         catch (...)
         {
             QMessageBox::critical(0, "Opening Perspective Failed", QString("The requested perspective could not be opened.\nSee the log for details."));
         }
     }
     else if ( dynamic_cast< mitk::QtViewItem* >(item) )
     {
         berry::IWorkbenchPage::Pointer page = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
 
         if (page.IsNotNull())
         {
             try
             {
                 mitk::QtViewItem* vItem = dynamic_cast< mitk::QtViewItem* >(item);
                 page->ShowView(vItem->m_View->GetId());
             }
             catch (berry::PartInitException e)
             {
                 BERRY_ERROR << "Error: " << e.displayText() << std::endl;
             }
         }
     }
 }
 
 void ViewBrowserView::AddPerspective()
 {
     QmitkNewPerspectiveDialog* dialog = new QmitkNewPerspectiveDialog( m_Parent );
 
     int dialogReturnValue = dialog->exec();
     if ( dialogReturnValue == QDialog::Rejected )
         return;
 
     berry::IPerspectiveRegistry* perspRegistry = berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry();
     try
     {
         perspRegistry->CreatePerspective(dialog->GetPerspectiveName().toStdString(), perspRegistry->FindPerspectiveWithId(perspRegistry->GetDefaultPerspective()));
     }
     catch(...)
     {
         QMessageBox::warning(m_Parent, "Error", "Duplication of selected perspective failed. Please make sure the specified perspective name is not already in use!");
     }
     FillTreeList();
 }
 
 void ViewBrowserView::ClonePerspective()
 {
     if (m_RegisteredPerspective.IsNotNull())
     {
         QmitkNewPerspectiveDialog* dialog = new QmitkNewPerspectiveDialog( m_Parent );
         QString defaultName(m_RegisteredPerspective->GetLabel().c_str());
         defaultName.append(" Copy");
         dialog->SetPerspectiveName(defaultName);
 
         int dialogReturnValue = dialog->exec();
         if ( dialogReturnValue == QDialog::Rejected )
             return;
 
         berry::IPerspectiveRegistry* perspRegistry = berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry();
         try
         {
             perspRegistry->ClonePerspective(dialog->GetPerspectiveName().toStdString(), dialog->GetPerspectiveName().toStdString(), m_RegisteredPerspective);
         }
         catch(...)
         {
             QMessageBox::warning(m_Parent, "Error", "Duplication of selected perspective failed. Please make sure the specified perspective name is not already in use!");
         }
         FillTreeList();
     }
 }
 
 void ViewBrowserView::ResetPerspective()
 {
     if (QMessageBox::Yes == QMessageBox(QMessageBox::Question, "Please confirm", "Do you really want to reset the curent perspective?", QMessageBox::Yes|QMessageBox::No).exec())
         berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ResetPerspective();
 }
 
 void ViewBrowserView::DeletePerspective()
 {
     if (m_RegisteredPerspective.IsNotNull())
     {
         QString question = "Do you really want to remove the perspective '";
         question.append(m_RegisteredPerspective->GetLabel().c_str());
         question.append("'?");
         if (QMessageBox::Yes == QMessageBox(QMessageBox::Question, "Please confirm", question, QMessageBox::Yes|QMessageBox::No).exec())
         {
             berry::IPerspectiveRegistry* perspRegistry = berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry();
             perspRegistry->DeletePerspective(m_RegisteredPerspective);
             FillTreeList();
         }
     }
 }
 
 void ViewBrowserView::ClosePerspective()
 {
     if (QMessageBox::Yes == QMessageBox(QMessageBox::Question, "Please confirm", "Do you really want to close the curent perspective?", QMessageBox::Yes|QMessageBox::No).exec())
     {
         berry::IWorkbenchPage::Pointer page = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
         page->CloseCurrentPerspective(true, true);
 
         if ( page->GetPerspective().IsNull() )
         {
             berry::IPerspectiveRegistry* perspRegistry = berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry();
             berry::PlatformUI::GetWorkbench()->ShowPerspective( perspRegistry->GetDefaultPerspective(), berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow() );
         }
     }
 }
 
 void ViewBrowserView::ClosePerspectives()
 {
     if (QMessageBox::Yes == QMessageBox(QMessageBox::Question, "Please confirm", "Do you really want to close all perspectives?", QMessageBox::Yes|QMessageBox::No).exec())
     {
         berry::IWorkbenchPage::Pointer page = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
         page->CloseAllPerspectives(true, true);
 
         berry::IPerspectiveRegistry* perspRegistry = berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry();
         berry::PlatformUI::GetWorkbench()->ShowPerspective( perspRegistry->GetDefaultPerspective(), berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow() );
     }
 }
 
 void ViewBrowserView::CustomMenuRequested(QPoint pos)
 {
     QStandardItem* item = m_TreeModel->itemFromIndex(m_Controls.m_PluginTreeView->indexAt(pos));
     m_ContextMenu->clear();
     m_RegisteredPerspective = NULL;
 
     QAction* addAction = new QAction("Create new perspective", this);
     m_ContextMenu->addAction(addAction);
     connect(addAction, SIGNAL(triggered()), SLOT(AddPerspective()));
 
     if (m_ContextMenu!=NULL && item!=NULL && dynamic_cast< mitk::QtPerspectiveItem* >(item) )
     {
         m_RegisteredPerspective = dynamic_cast< mitk::QtPerspectiveItem* >(item)->m_Perspective;
 
         m_ContextMenu->addSeparator();
 
         QAction* cloneAction = new QAction("Duplicate perspective", this);
         m_ContextMenu->addAction(cloneAction);
         connect(cloneAction, SIGNAL(triggered()), SLOT(ClonePerspective()));
 
         if (!m_RegisteredPerspective->IsPredefined())
         {
             QAction* deleteAction = new QAction("Remove perspective", this);
             m_ContextMenu->addAction(deleteAction);
             connect(deleteAction, SIGNAL(triggered()), SLOT(DeletePerspective()));
         }
 
         m_ContextMenu->addSeparator();
     }
 
     QAction* resetAction = new QAction("Reset current perspective", this);
     m_ContextMenu->addAction(resetAction);
     connect(resetAction, SIGNAL(triggered()), SLOT(ResetPerspective()));
 
     QAction* closeAction = new QAction("Close current perspective", this);
     m_ContextMenu->addAction(closeAction);
     connect(closeAction, SIGNAL(triggered()), SLOT(ClosePerspective()));
 
     m_ContextMenu->addSeparator();
 
     QAction* closeAllAction = new QAction("Close all perspectives", this);
     m_ContextMenu->addAction(closeAllAction);
     connect(closeAllAction, SIGNAL(triggered()), SLOT(ClosePerspectives()));
 
     m_ContextMenu->popup(m_Controls.m_PluginTreeView->viewport()->mapToGlobal(pos));
 }