diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/files.cmake b/BlueBerry/Bundles/org.blueberry.ui.qt/files.cmake
index 77c88fca81..98d70da05e 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/files.cmake
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/files.cmake
@@ -1,470 +1,462 @@
 set(SRC_CPP_FILES
   berryAbstractSourceProvider.cpp
   berryAbstractUICTKPlugin.cpp
   berryConstants.cpp
   berryDisplay.cpp
   berryEditorPart.cpp
   berryFileEditorInput.cpp
   berryGeometry.cpp
 
   berryIActionBars.h
   berryIContextService.cpp
   berryIContributionRoot.h
   berryIDropTargetListener.cpp
   berryIEditorDescriptor.cpp
   berryIEditorInput.cpp
   berryIEditorMatchingStrategy.cpp
   berryIEditorPart.cpp
   berryIEditorReference.cpp
   berryIEditorRegistry.cpp
   berryIEditorSite.cpp
   berryIFileEditorMapping.cpp
   berryIFolderLayout.cpp
   berryImageDescriptor.cpp
   berryIMemento.cpp
   berryINullSelectionListener.cpp
   berryIPageLayout.cpp
   berryIPartListener.cpp
   berryIPageService.cpp
   berryIPartService.cpp
   berryIPathEditorInput.cpp
   berryIPerspectiveDescriptor.cpp
   berryIPerspectiveFactory.cpp
   berryIPerspectiveListener.cpp
   berryIPerspectiveRegistry.cpp
   berryIPlaceholderFolderLayout.cpp
   berryIPluginContribution.h
   berryIPostSelectionProvider.cpp
   berryIPreferencePage.cpp
   berryIPropertyChangeListener.cpp
   berryIQtPreferencePage.cpp
   berryIQtStyleManager.cpp
   berryIReusableEditor.cpp
   berryISaveablePart.cpp
   berryISaveablesLifecycleListener.cpp
   berryISaveablesSource.cpp
   berryISelection.cpp
   berryISelectionChangedListener.cpp
   berryISelectionListener.cpp
   berryISelectionProvider.cpp
   berryISelectionService.cpp
   berryIShellListener.cpp
   berryIShellProvider.cpp
   berryIShowInSource.h
   berryIShowInTarget.h
   berryISizeProvider.cpp
   berryISourceProvider.cpp
   berryISourceProviderListener.cpp
   berryISources.cpp
   berryIStickyViewDescriptor.cpp
   berryIStructuredSelection.cpp
   berryIViewCategory.cpp
   berryIViewDescriptor.cpp
   berryIViewLayout.cpp
   berryIViewPart.cpp
   berryIViewReference.cpp
   berryIViewRegistry.cpp
   berryIViewSite.cpp
   berryIWorkbenchCommandConstants.cpp
   berryIWindowListener.cpp
   berryIWorkbench.cpp
   berryIWorkbenchListener.cpp
   berryIWorkbenchPage.cpp
   berryIWorkbenchPart.cpp
   berryIWorkbenchPartConstants.cpp
   berryIWorkbenchPartDescriptor.cpp
   berryIWorkbenchPartReference.cpp
   berryIWorkbenchPartSite.cpp
   berryIWorkbenchSite.cpp
   berryIWorkbenchWindow.cpp
   berryMenuUtil.cpp
   berryPlatformUI.cpp
   berryPoint.cpp
   berryPropertyChangeEvent.cpp
   berryQModelIndexObject.cpp
   berryQtEditorPart.cpp
   berryQtItemSelection.cpp
   berryQtIntroPart.cpp
   berryQtPreferences.cpp
   berryQtSelectionProvider.cpp
   berryQtViewPart.cpp
   berryRectangle.cpp
   berrySameShellProvider.cpp
   berrySaveable.cpp
   berrySaveablesLifecycleEvent.cpp
   berrySelectionChangedEvent.cpp
   berryShell.cpp
   berryShellEvent.cpp
   berryShowInContext.cpp
   berryUIException.cpp
   berryViewPart.cpp
   berryWindow.cpp
   berryWorkbenchActionConstants.cpp
   berryWorkbenchPart.cpp
   berryWorkbenchPreferenceConstants.cpp
   berryXMLMemento.cpp
 
   #actions
   actions/berryAbstractContributionFactory.cpp
   actions/berryAbstractGroupMarker.cpp
   #actions/berryAction.cpp
   #actions/berryActionContributionItem.cpp
   actions/berryCommandContributionItem.h
   actions/berryCommandContributionItem.cpp
   actions/berryContributionItem.cpp
   actions/berryContributionItemFactory.cpp
   actions/berryContributionManager.cpp
   actions/berryIContributionItem.h
   actions/berryIContributionManager.h
   actions/berryIContributionManagerOverrides.cpp
   actions/berryIMenuManager.h
   #actions/berryMenuBarManager.cpp
   actions/berryMenuManager.cpp
   actions/berrySeparator.cpp
   actions/berrySubContributionItem.cpp
 
 
   #application
   application/berryActionBarAdvisor.cpp
   application/berryIActionBarConfigurer.cpp
   application/berryIWorkbenchConfigurer.cpp
   application/berryIWorkbenchWindowConfigurer.cpp
   application/berryWorkbenchAdvisor.cpp
   application/berryWorkbenchWindowAdvisor.cpp
 
   #commands
   commands/berryICommandImageService.cpp
   commands/berryICommandService.cpp
   commands/berryIElementReference.h
   commands/berryIElementUpdater.h
   commands/berryIMenuService.h
   commands/berryUIElement.cpp
 
-  #dialogs
-  dialogs/berryIDialog.cpp
-  dialogs/berryIShowViewDialog.cpp
-  dialogs/berryMessageDialog.cpp
-
   #guitk
   guitk/berryGuiTkControlEvent.cpp
   guitk/berryGuiTkEvent.cpp
   guitk/berryGuiTkIControlListener.cpp
   guitk/berryGuiTkIMenuListener.cpp
   guitk/berryGuiTkISelectionListener.cpp
   guitk/berryGuiTkSelectionEvent.cpp
 
   #handlers
   handlers/berryHandlerUtil.cpp
   handlers/berryIHandlerActivation.cpp
   handlers/berryIHandlerService.cpp
   handlers/berryRadioState.cpp
   handlers/berryRegistryToggleState.cpp
   handlers/berryShowViewHandler.cpp
   handlers/berryToggleState.cpp
 
   #intro
   intro/berryIIntroManager.cpp
   intro/berryIIntroPart.cpp
   intro/berryIIntroSite.cpp
   intro/berryIntroPart.cpp
 
   #tweaklets
   tweaklets/berryDnDTweaklet.cpp
   tweaklets/berryGuiWidgetsTweaklet.cpp
   tweaklets/berryImageTweaklet.cpp
-  tweaklets/berryMessageDialogTweaklet.cpp
   tweaklets/berryITracker.cpp
   tweaklets/berryWorkbenchPageTweaklet.cpp
   tweaklets/berryWorkbenchTweaklet.cpp
 
   #presentations
   presentations/berryIPresentablePart.cpp
   presentations/berryIPresentationFactory.cpp
   presentations/berryIPresentationSerializer.cpp
   presentations/berryIStackPresentationSite.cpp
   presentations/berryStackDropResult.cpp
   presentations/berryStackPresentation.cpp
 
   #services
   services/berryIDisposable.cpp
   services/berryIEvaluationReference.h
   services/berryIEvaluationService.cpp
   services/berryINestable.cpp
   services/berryIServiceFactory.cpp
   services/berryIServiceLocator.cpp
   services/berryIServiceScopes.cpp
   services/berryIServiceWithSources.cpp
   services/berryISourceProviderService.cpp
 
   #testing
   testing/berryTestableObject.cpp
 
   #util
   util/berryISafeRunnableRunner.cpp
   util/berrySafeRunnable.cpp
 
   # application
   application/berryQtWorkbenchAdvisor.cpp
 )
 
 set(INTERNAL_CPP_FILES
 
   defaultpresentation/berryEmptyTabFolder.cpp
   defaultpresentation/berryEmptyTabItem.cpp
   defaultpresentation/berryNativeTabFolder.cpp
   defaultpresentation/berryNativeTabItem.cpp
   defaultpresentation/berryQCTabBar.cpp
   defaultpresentation/berryQtWorkbenchPresentationFactory.cpp
 
   util/berryAbstractTabFolder.cpp
   util/berryAbstractTabItem.cpp
   util/berryIPresentablePartList.cpp
   util/berryLeftToRightTabOrder.cpp
   util/berryPartInfo.cpp
   util/berryPresentablePartFolder.cpp
   util/berryReplaceDragHandler.cpp
   util/berryTabbedStackPresentation.cpp
   util/berryTabDragHandler.cpp
   util/berryTabFolderEvent.cpp
   util/berryTabOrder.cpp
 
   #intro
   intro/berryEditorIntroAdapterPart.cpp
   intro/berryIIntroDescriptor.cpp
   intro/berryIIntroRegistry.cpp
   intro/berryIntroConstants.cpp
   intro/berryIntroDescriptor.cpp
   intro/berryIntroPartAdapterSite.cpp
   intro/berryIntroRegistry.cpp
   intro/berryViewIntroAdapterPart.cpp
   intro/berryWorkbenchIntroManager.cpp
 
   berryAbstractMenuAdditionCacheEntry.cpp
   berryAbstractPartSelectionTracker.cpp
   berryAbstractSelectionService.cpp
   berryActivePartExpression.cpp
   berryAlwaysEnabledExpression.cpp
   berryAndExpression.cpp
   berryBundleUtility.cpp
   berryCommandContributionItemParameter.cpp
   berryCommandParameter.cpp
   berryCommandPersistence.cpp
   berryCommandService.cpp
   berryCommandServiceFactory.cpp
   berryCommandStateProxy.cpp
   berryCompositeExpression.cpp
   berryContainerPlaceholder.cpp
   berryContributionRoot.cpp
   berryDetachedPlaceHolder.cpp
   berryDefaultSaveable.cpp
   berryDefaultStackPresentationSite.cpp
   berryDetachedWindow.cpp
   berryDragUtil.cpp
   berryEditorAreaHelper.cpp
   berryEditorDescriptor.cpp
   berryEditorManager.cpp
   berryEditorReference.cpp
   berryEditorRegistry.cpp
   berryEditorRegistryReader.cpp
   berryEditorSashContainer.cpp
   berryEditorSite.cpp
   berryElementReference.cpp
   berryErrorViewPart.cpp
   berryEvaluationAuthority.cpp
   berryEvaluationReference.cpp
   berryEvaluationResultCache.cpp
   berryEvaluationService.cpp
   berryExpressionAuthority.cpp
   berryFileEditorMapping.cpp
   berryFolderLayout.cpp
   berryHandlerActivation.cpp
   berryHandlerAuthority.cpp
   berryHandlerPersistence.cpp
   berryHandlerProxy.cpp
   berryHandlerService.cpp
   berryHandlerServiceFactory.cpp
   berryIDragOverListener.cpp
   berryIDropTarget.cpp
   berryIEvaluationResultCache.cpp
   berryILayoutContainer.cpp
   berryInternalMenuService.h
   berryIServiceLocatorCreator.cpp
   berryIStickyViewManager.cpp
   berryIWorkbenchLocationService.cpp
   berryLayoutHelper.cpp
   berryLayoutPart.cpp
   berryLayoutPartSash.cpp
   berryLayoutTree.cpp
   berryLayoutTreeNode.cpp
   berryMenuServiceFactory.cpp
   berryMMMenuListener.cpp
   berryNestableHandlerService.cpp
   berryNullEditorInput.cpp
   berryPageLayout.cpp
   berryPagePartSelectionTracker.cpp
   berryPageSelectionService.cpp
   berryParameterValueConverterProxy.cpp
   berryPartList.cpp
   berryPartPane.cpp
   berryPartPlaceholder.cpp
   berryPartSashContainer.cpp
   berryPartService.cpp
   berryPartSite.cpp
   berryPartStack.cpp
   berryPartTester.cpp
   berryPersistentState.cpp
   berryPerspective.cpp
   berryPerspectiveDescriptor.cpp
   berryPerspectiveExtensionReader.cpp
   berryPerspectiveHelper.cpp
   berryPerspectiveRegistry.cpp
   berryPerspectiveRegistryReader.cpp
   berryPlaceholderFolderLayout.cpp
   berryPreferenceConstants.cpp
   berryPresentablePart.cpp
   berryPresentationFactoryUtil.cpp
   berryPresentationSerializer.cpp
   berryQtControlWidget.cpp
   berryQtDnDControlWidget.cpp
   berryQtDisplay.cpp
   berryQtDnDTweaklet.cpp
   berryQtFileImageDescriptor.cpp
   berryQtGlobalEventFilter.cpp
   berryQtIconImageDescriptor.cpp
   berryQtImageTweaklet.cpp
   berryQtMainWindowControl.cpp
-  berryQtMessageDialogTweaklet.cpp
   berryQtMissingImageDescriptor.cpp
   berryQtOpenPerspectiveAction.cpp
   berryQtPerspectiveSwitcher.cpp
   berryQtSafeApplication.cpp
   berryQtSash.cpp
   berryQtShell.cpp
   berryQtShowViewAction.cpp
   berryQtShowViewDialog.cpp
   berryQtStyleManager.cpp
   berryQtStylePreferencePage.cpp
   berryQtTracker.cpp
   berryQtWidgetController.cpp
   berryQtWidgetsTweaklet.cpp
   berryQtWidgetsTweakletImpl.cpp
   berryQtWorkbenchPageTweaklet.cpp
   berryQtWorkbenchTweaklet.cpp
   berryRegistryPersistence.cpp
   berryRegistryReader.cpp
   berrySaveablesList.cpp
   berryShowViewMenu.cpp
   berryServiceLocator.cpp
   berryServiceLocatorCreator.cpp
   berryShellPool.cpp
   berrySlaveCommandService.cpp
   berrySlaveHandlerService.cpp
   berrySlaveMenuService.cpp
   berrySourceProviderService.cpp
   berrySourcePriorityNameMapping.cpp
   berryStatusUtil.cpp
   berryStickyViewDescriptor.cpp
   berryStickyViewManager.cpp
   berryTweaklets.cpp
   berryUtil.cpp
   berryViewDescriptor.cpp
   berryViewFactory.cpp
   berryViewLayout.cpp
   berryViewReference.cpp
   berryViewRegistry.cpp
   berryViewRegistryReader.cpp
   berryViewSashContainer.cpp
   berryViewSite.cpp
   berryWorkbenchPage.cpp
   berryWindowManager.cpp
   berryWindowPartSelectionTracker.cpp
   berryWindowSelectionService.cpp
   berryWorkbench.cpp
   berryWorkbenchConfigurer.cpp
   berryWorkbenchConstants.cpp
   berryWorkbenchLocationService.cpp
   berryWorkbenchMenuService.cpp
   berryWorkbenchPagePartList.cpp
   berryWorkbenchPartReference.cpp
   berryWorkbenchPlugin.cpp
   berryWorkbenchRegistryConstants.cpp
   berryWorkbenchServiceRegistry.cpp
   berryWorkbenchSourceProvider.cpp
   berryWorkbenchTestable.cpp
   berryWorkbenchWindow.cpp
   berryWorkbenchWindowConfigurer.cpp
   berryWorkbenchWindowExpression.cpp
   berryWWinActionBars.cpp
   berryWWinPartService.cpp
 
 )
 
 set(MOC_H_FILES
 
   src/berryAbstractUICTKPlugin.h
   src/berryEditorPart.h
   src/berryQtSelectionProvider.h
   src/berryViewPart.h
   src/berryWorkbenchPart.h
 
   src/actions/berryCommandContributionItem.h
 
   src/intro/berryIntroPart.h
 
   src/handlers/berryShowViewHandler.h
 
   src/internal/berryCommandServiceFactory.h
   src/internal/berryHandlerServiceFactory.h
   src/internal/berryMenuServiceFactory.h
   src/internal/berryMMMenuListener.h
   src/internal/berryQtDisplay.h
   src/internal/berryQtDnDTweaklet.h
   src/internal/berryQtGlobalEventFilter.h
   src/internal/berryQtImageTweaklet.h
   src/internal/berryQtMainWindowControl.h
-  src/internal/berryQtMessageDialogTweaklet.h
   src/internal/berryQtOpenPerspectiveAction.h
   src/internal/berryQtPerspectiveSwitcher.h
   src/internal/berryQtSash.h
   src/internal/berryQtShowViewAction.h
   src/internal/berryQtStyleManager.h
   src/internal/berryQtStylePreferencePage.h
   src/internal/berryQtTracker.h
   src/internal/berryQtWidgetsTweaklet.h
   src/internal/berryQtWidgetsTweakletImpl.h
   src/internal/berryQtWorkbenchTweaklet.h
   src/internal/berryQtWorkbenchPageTweaklet.h
   src/internal/berryWorkbenchPlugin.h
   src/internal/berryWorkbenchSourceProvider.h
 
   src/internal/defaultpresentation/berryNativeTabFolder.h
   src/internal/defaultpresentation/berryNativeTabItem.h
   src/internal/defaultpresentation/berryQCTabBar.h
   src/internal/defaultpresentation/berryQtWorkbenchPresentationFactory.h
 
   src/internal/intro/berryEditorIntroAdapterPart.h
 )
 
 set(UI_FILES
   src/internal/berryQtShowViewDialog.ui
   src/internal/berryQtStylePreferencePage.ui
   src/internal/berryQtStatusPart.ui
 )
 
 set(QRC_FILES
   resources/org_blueberry_ui_qt.qrc
 )
 
 set(CACHED_RESOURCE_FILES
   plugin.xml
 )
 
 set(CPP_FILES )
 
 foreach(file ${SRC_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 foreach(file ${INTERNAL_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/berryIWorkbench.h b/BlueBerry/Bundles/org.blueberry.ui.qt/src/berryIWorkbench.h
index 08257c56ef..0919f8449c 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/berryIWorkbench.h
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/berryIWorkbench.h
@@ -1,400 +1,399 @@
 /*===================================================================
 
 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 BERRYIWORKBENCH_H_
 #define BERRYIWORKBENCH_H_
 
 #include <berryMacros.h>
 
 #include "services/berryIServiceLocator.h"
-#include "dialogs/berryIDialog.h"
 #include "berryIViewRegistry.h"
 #include "berryIEditorRegistry.h"
 #include "intro/berryIIntroManager.h"
 #include "berryIPerspectiveRegistry.h"
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchListener.h"
 #include "berryIWindowListener.h"
 #include "berryDisplay.h"
 
 namespace berry {
 
 struct IWorkbenchPage;
 
 /**
  * \ingroup org_blueberry_ui_qt
  *
  * A workbench is the root object for the BlueBerry Platform user interface.
  * <p>
  * A <b>workbench</b> has one or more main windows which present to the end
  * user information based on some underlying model, typically on resources in an
  * underlying workspace. A workbench usually starts with a single open window,
  * and automatically closes when its last window closes.
  * </p>
  * <p>
  * Each <b>workbench window</b> has a collection of <b>pages</b>; 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>
  * Each workbench page has a collection of <b>workbench parts</b>, of which
  * there are two kinds: views and editors. A page's parts are arranged (tiled or
  * stacked) for presentation on the screen. The arrangement is not fixed; the
  * user can arrange the parts as they see fit. A <b>perspective</b> is a
  * template for a page, capturing a collection of parts and their arrangement.
  * </p>
  * <p>
  * The platform creates a workbench when the workbench plug-in is activated;
  * since this happens at most once during the life of the running platform,
  * there is only one workbench instance. Due to its singular nature, it is
  * commonly referred to as <it>the</it> workbench.
  * </p>
  * <p>
  * The workbench 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 shuts down. The supported services
  * are:
  * </p>
  * <ul>
  * <li>{@link IBindingService}</li>
  * <li>{@link ICommandService}</li>
  * <li>{@link IContextService}</li>
  * <li>{@link IHandlerService}</li>
  * </ul>
  * <p>
  * This interface is not intended to be implemented by clients.
  * </p>
  *
  * @see PlatformUI#getWorkbench
  * @noimplement This interface is not intended to be implemented by clients.
  */
 struct BERRY_UI_QT IWorkbench : public IServiceLocator {
 
   berryObjectMacro(berry::IWorkbench)
 
   virtual ~IWorkbench();
 
   /**
    * Returns the display for this workbench.
    * <p>
    * Code should always ask the workbench for the display rather than rely on
    * {@link Display#getDefault Display.getDefault()}.
    * </p>
    *
    * @return the display to be used for all UI interactions with this
    *         workbench
    */
   virtual Display* GetDisplay() = 0;
 
   /**
    * Adds a workbench listener.
    *
    * @param listener
    *            the workbench listener to add
    * @since 3.2
    */
   virtual void AddWorkbenchListener(IWorkbenchListener* listener) = 0;
 
   /**
    * Removes a workbench listener.
    *
    * @param listener
    *            the workbench listener to remove
    * @since 3.2
    */
   virtual void RemoveWorkbenchListener(IWorkbenchListener* listener) = 0;
 
   /**
    * Returns the workbench events object
    */
   virtual IWorkbenchListener::Events& GetWorkbenchEvents() = 0;
 
   /**
    * Adds a window listener.
    *
    * @param listener
    *            the window listener to add
    * @since 2.0
    */
   virtual void AddWindowListener(IWindowListener* listener) = 0;
 
   /**
    * Removes a window listener.
    *
    * @param listener
    *            the window listener to remove
    * @since 2.0
    */
   virtual void RemoveWindowListener(IWindowListener* listener) = 0;
 
   /**
    * Returns the window events object
    *
    */
   virtual IWindowListener::Events& GetWindowEvents() = 0;
 
   /**
    * Closes this workbench and all its open windows.
    * <p>
    * If the workbench has an open editor with unsaved content, the user will
    * be given the opportunity to save it.
    * </p>
    *
    * @return <code>true</code> if the workbench was successfully closed, and
    *         <code>false</code> if it is still open
    */
   virtual bool Close() = 0;
 
   /**
    * Returns the currently active window for this workbench (if any). Returns
    * <code>null</code> if there is no active workbench window. Returns
    * <code>null</code> if called from a non-UI thread.
    *
    * @return the active workbench window, or <code>null</code> if there is
    *         no active workbench window or if called from a non-UI thread
    */
   virtual IWorkbenchWindow::Pointer GetActiveWorkbenchWindow() const = 0;
 
   /**
    * Returns the perspective registry for the workbench.
    *
    * @return the workbench perspective registry
    */
   virtual IPerspectiveRegistry* GetPerspectiveRegistry() = 0;
 
   /**
    * Returns the view registry for the workbench.
    *
    * @return the workbench view registry
    * @since 3.1
    */
   virtual IViewRegistry* GetViewRegistry() = 0;
 
   /**
    * Returns the editor registry for the workbench.
    *
    * @return the workbench editor registry
    */
   virtual IEditorRegistry* GetEditorRegistry() = 0;
 
   /**
    * Returns the number of open main windows associated with this workbench.
    * Note that wizards and dialogs are not included in this list since they
    * are not considered main windows.
    *
    * @return the number of open windows
    * @since 3.0
    */
   virtual std::size_t GetWorkbenchWindowCount() = 0;
 
   /**
    * Returns a list of the open main windows associated with this workbench.
    * Note that wizards and dialogs are not included in this list since they
    * are not considered main windows.
    *
    * @return a list of open windows
    */
   virtual QList<IWorkbenchWindow::Pointer> GetWorkbenchWindows() = 0;
 
   /**
    * Creates and opens a new workbench window with one page. The perspective
    * of the new page is defined by the specified perspective ID. The new
    * window and new page become active.
    * <p>
    * <b>Note:</b> The caller is responsible to ensure the action using this
    * method will explicitly inform the user a new window will be opened.
    * Otherwise, callers are strongly recommended to use the
    * <code>openPerspective</code> APIs to programmatically show a
    * perspective to avoid confusing the user.
    * </p>
    * <p>
    * In most cases where this method is used the caller is tightly coupled to
    * a particular perspective. They define it in the registry and contribute
    * some user interface action to open or activate it. In situations like
    * this a static variable is often used to identify the perspective ID.
    * </p>
    *
    * @param perspectiveId
    *            the perspective id for the window's initial page, or
    *            <code>null</code> for no 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 window
    * @exception WorkbenchException
    *                if a new window and page could not be opened
    *
    * @see IWorkbench#showPerspective(String, IWorkbenchWindow, IAdaptable)
    */
   virtual IWorkbenchWindow::Pointer OpenWorkbenchWindow(const QString& perspectiveId,
       IAdaptable* input) = 0;
 
   /**
    * Creates and opens a new workbench window with one page. The perspective
    * of the new page is defined by the default perspective ID. The new window
    * and new page become active.
    * <p>
    * <b>Note:</b> The caller is responsible to ensure the action using this
    * method will explicitly inform the user a new window will be opened.
    * Otherwise, callers are strongly recommended to use the
    * <code>openPerspective</code> APIs to programmatically show a
    * perspective to avoid confusing the user.
    * </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 new window and page could not be opened
    *
    * @see IWorkbench#showPerspective(String, IWorkbenchWindow, IAdaptable)
    */
   virtual IWorkbenchWindow::Pointer OpenWorkbenchWindow(IAdaptable* input) = 0;
 
   /**
    * Shows the specified perspective to the user. The caller should use this
    * method when the perspective to be shown is not dependent on the page's
    * input. That is, the perspective can open in any page depending on user
    * preferences.
    * <p>
    * The perspective may be shown in the specified window, in another existing
    * window, or in a new window depending on user preferences. The exact
    * policy is controlled by the workbench to ensure consistency to the user.
    * The policy is subject to change. The current policy is as follows:
    * <ul>
    * <li>If the specified window has the requested perspective open, then the
    * window is given focus and the perspective is shown. The page's input is
    * ignored.</li>
    * <li>If another window that has the workspace root as input and the
    * requested perspective open and active, then the window is given focus.
    * </li>
    * <li>Otherwise the requested perspective is opened and shown in the
    * specified window or in a new window depending on the current user
    * preference for opening perspectives, and that window is given focus.
    * </li>
    * </ul>
    * </p>
    * <p>
    * The workbench also defines a number of menu items to activate or open
    * each registered perspective. A complete list of these perspectives is
    * available from the perspective registry found on <code>IWorkbench</code>.
    * </p>
    *
    * @param perspectiveId
    *            the perspective ID to show
    * @param window
    *            the workbench window of the action calling this method.
    * @return the workbench page that the perspective was shown
    * @exception WorkbenchException
    *                if the perspective could not be shown
    *
    * @since 2.0
    */
   virtual SmartPointer<IWorkbenchPage> ShowPerspective(const QString& perspectiveId,
       IWorkbenchWindow::Pointer window) = 0;
 
   /**
    * Shows the specified perspective to the user. The caller should use this
    * method when the perspective to be shown is dependent on the page's input.
    * That is, the perspective can only open in any page with the specified
    * input.
    * <p>
    * The perspective may be shown in the specified window, in another existing
    * window, or in a new window depending on user preferences. The exact
    * policy is controlled by the workbench to ensure consistency to the user.
    * The policy is subject to change. The current policy is as follows:
    * <ul>
    * <li>If the specified window has the requested perspective open and the
    * same requested input, then the window is given focus and the perspective
    * is shown.</li>
    * <li>If another window has the requested input and the requested
    * perspective open and active, then that window is given focus.</li>
    * <li>If the specified window has the same requested input but not the
    * requested perspective, then the window is given focus and the perspective
    * is opened and shown on condition that the user preference is not to open
    * perspectives in a new window.</li>
    * <li>Otherwise the requested perspective is opened and shown in a new
    * window, and the window is given focus.</li>
    * </ul>
    * </p>
    * <p>
    * The workbench also defines a number of menu items to activate or open
    * each registered perspective. A complete list of these perspectives is
    * available from the perspective registry found on <code>IWorkbench</code>.
    * </p>
    *
    * @param perspectiveId
    *            the perspective ID to show
    * @param window
    *            the workbench window of the action calling this method.
    * @param input
    *            the page input, or <code>null</code> if there is no current
    *            input. This is used to seed the input for the page's views
    * @return the workbench page that the perspective was shown
    * @exception WorkbenchException
    *                if the perspective could not be shown
    *
    * @since 2.0
    */
   virtual SmartPointer<IWorkbenchPage> ShowPerspective(const QString& perspectiveId,
       IWorkbenchWindow::Pointer window, IAdaptable* input) = 0;
 
   /**
    * Save all dirty editors in the workbench. Opens a dialog to prompt the
    * user if <code>confirm</code> is true. Return true if successful. Return
    * false if the user has canceled the command.
    *
    * @param confirm <code>true</code> to ask the user before saving unsaved
    *            changes (recommended), and <code>false</code> to save
    *            unsaved changes without asking
    * @return <code>true</code> if the command succeeded, and
    *         <code>false</code> if the operation was canceled by the user or
    *         an error occurred while saving
    */
   virtual bool SaveAllEditors(bool confirm) = 0;
 
   /**
    * Return the intro manager for this workbench.
    *
    * @return the intro manager for this workbench. Guaranteed not to be
    *         <code>null</code>.
    */
   virtual IIntroManager* GetIntroManager() = 0;
 
   /**
    * Returns a boolean indicating whether the workbench is in the process of
    * closing.
    *
    * @return <code>true</code> if the workbench is in the process of
    *         closing, <code>false</code> otherwise
    * @since 3.1
    */
   virtual bool IsClosing() = 0;
 
   /**
    * Applies changes of the current theme to the user interface.
    */
   virtual void UpdateTheme() = 0;
 
 };
 
 }
 
 #endif /*BERRYIWORKBENCH_H_*/
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryIDialog.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryIDialog.cpp
deleted file mode 100755
index 38008936dd..0000000000
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryIDialog.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-/*===================================================================
-
-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 "berryIDialog.h"
-
-namespace berry {
-
-const int IDialog::NONE = 0;
-const int IDialog::ERR = 1;
-const int IDialog::INFORMATION = 2;
-const int IDialog::QUESTION = 3;
-const int IDialog::WARNING = 4;
-
-IDialog::~IDialog()
-{
-
-}
-
-}
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryIDialog.h b/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryIDialog.h
deleted file mode 100644
index 19d9e856d2..0000000000
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryIDialog.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*===================================================================
-
-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 BERRYIDIALOG_H_
-#define BERRYIDIALOG_H_
-
-#include <berryMacros.h>
-#include <berryObject.h>
-
-#include <org_blueberry_ui_qt_Export.h>
-
-namespace berry {
-
-/**
- * \ingroup org_blueberry_ui_qt
- *
- */
-struct BERRY_UI_QT IDialog : public virtual Object
-{
-  berryObjectMacro(berry::IDialog)
-
-  /**
-   * Constant for a dialog with no image (value 0).
-   */
-  const static int NONE; // = 0;
-
-  /**
-   * Constant for a dialog with an error image (value 1).
-   */
-  const static int ERR; // = 1;
-
-  /**
-   * Constant for a dialog with an info image (value 2).
-   */
-  const static int INFORMATION; // = 2;
-
-  /**
-   * Constant for a dialog with a question image (value 3).
-   */
-  const static int QUESTION; // = 3;
-
-  /**
-   * Constant for a dialog with a warning image (value 4).
-   */
-  const static int WARNING; // = 4;
-
-  enum ReturnCode { OK, CANCEL };
-
-  ~IDialog();
-
-  virtual int Open() = 0;
-
-};
-
-}
-
-#endif /*BERRYIDIALOG_H_*/
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryIShowViewDialog.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryIShowViewDialog.cpp
deleted file mode 100644
index 22fa2444a1..0000000000
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryIShowViewDialog.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-/*===================================================================
-
-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 "berryIShowViewDialog.h"
-
-
-namespace berry {
-
-IShowViewDialog::~IShowViewDialog ()
-{
-}
-
-}
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryIShowViewDialog.h b/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryIShowViewDialog.h
deleted file mode 100644
index 5b09345395..0000000000
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryIShowViewDialog.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*===================================================================
-
-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 BERRYISHOWVIEWDIALOG_H_
-#define BERRYISHOWVIEWDIALOG_H_
-
-#include "berryIDialog.h"
-
-#include <vector>
-#include "berryIViewDescriptor.h"
-
-namespace berry {
-
-/**
- * \ingroup org_blueberry_ui_qt
- *
- */
-struct BERRY_UI_QT IShowViewDialog : public IDialog
-{
-  berryObjectMacro(berry::IShowViewDialog);
-
-  ~IShowViewDialog();
-
-
-  virtual QList<IViewDescriptor::Pointer> GetSelection() = 0;
-
-};
-
-}
-
-#endif /*BERRYISHOWVIEWDIALOG_H_*/
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryMessageDialog.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryMessageDialog.cpp
deleted file mode 100755
index e9064fc470..0000000000
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryMessageDialog.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*===================================================================
-
-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 "tweaklets/berryMessageDialogTweaklet.h"
-
-#include "berryMessageDialog.h"
-
-namespace berry
-{
-
-bool MessageDialog::OpenConfirm(Shell::Pointer parent,
-    const QString& title, const QString& message)
-{
-  return Tweaklets::Get(MessageDialogTweaklet::KEY)->OpenConfirm(parent, title,
-      message);
-}
-
-void MessageDialog::OpenError(Shell::Pointer parent, const QString& title,
-    const QString& message)
-{
-  Tweaklets::Get(MessageDialogTweaklet::KEY)->OpenError(parent, title, message);
-}
-
-void MessageDialog::OpenInformation(Shell::Pointer parent,
-    const QString& title, const QString& message)
-{
-  Tweaklets::Get(MessageDialogTweaklet::KEY)->OpenInformation(parent, title,
-      message);
-}
-
-bool MessageDialog::OpenQuestion(Shell::Pointer parent,
-    const QString& title, const QString& message)
-{
-  return Tweaklets::Get(MessageDialogTweaklet::KEY)->OpenQuestion(parent, title,
-      message);
-}
-
-void MessageDialog::OpenWarning(Shell::Pointer parent,
-    const QString& title, const QString& message)
-{
-  Tweaklets::Get(MessageDialogTweaklet::KEY)->OpenWarning(parent, title,
-      message);
-}
-
-IDialog::Pointer MessageDialog::CreateMessageDialog(Shell::Pointer parentShell, const QString& dialogTitle,
-         void* dialogTitleImage, const QString& dialogMessage, int dialogImageType,
-         const QList<QString>& dialogButtonLabels, int defaultIndex)
-{
-  return Tweaklets::Get(MessageDialogTweaklet::KEY)->MessageDialog(parentShell, dialogTitle,
-      dialogTitleImage, dialogMessage, dialogImageType,
-      dialogButtonLabels, defaultIndex);
-}
-
-}
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryMessageDialog.h b/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryMessageDialog.h
deleted file mode 100755
index d229535688..0000000000
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/dialogs/berryMessageDialog.h
+++ /dev/null
@@ -1,147 +0,0 @@
-/*===================================================================
-
-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 BERRYMESSAGEDIALOG_H_
-#define BERRYMESSAGEDIALOG_H_
-
-#include "berryIDialog.h"
-
-#include "berryShell.h"
-
-#include <string>
-#include <vector>
-
-namespace berry {
-
-struct MessageDialog
-{
-
- /**
-  * Convenience method to open a simple confirm (OK/Cancel) dialog.
-  *
-  * @param parent
-  *            the parent shell of the dialog, or <code>null</code> if none
-  * @param title
-  *            the dialog's title, or <code>null</code> if none
-  * @param message
-  *            the message
-  * @return <code>true</code> if the user presses the OK button,
-  *         <code>false</code> otherwise
-  */
- static bool OpenConfirm(Shell::Pointer parent, const QString& title, const QString& message);
-
- /**
-  * Convenience method to open a standard error dialog.
-  *
-  * @param parent
-  *            the parent shell of the dialog, or <code>null</code> if none
-  * @param title
-  *            the dialog's title, or <code>null</code> if none
-  * @param message
-  *            the message
-  */
- static void OpenError(Shell::Pointer parent, const QString& title, const QString& message);
-
- /**
-  * Convenience method to open a standard information dialog.
-  *
-  * @param parent
-  *            the parent shell of the dialog, or <code>null</code> if none
-  * @param title
-  *            the dialog's title, or <code>null</code> if none
-  * @param message
-  *            the message
-  */
- static void OpenInformation(Shell::Pointer parent, const QString& title,
-         const QString& message);
-
- /**
-  * Convenience method to open a simple Yes/No question dialog.
-  *
-  * @param parent
-  *            the parent shell of the dialog, or <code>null</code> if none
-  * @param title
-  *            the dialog's title, or <code>null</code> if none
-  * @param message
-  *            the message
-  * @return <code>true</code> if the user presses the OK button,
-  *         <code>false</code> otherwise
-  */
- static bool OpenQuestion(Shell::Pointer parent, const QString& title,
-         const QString& message);
-
- /**
-  * Convenience method to open a standard warning dialog.
-  *
-  * @param parent
-  *            the parent shell of the dialog, or <code>null</code> if none
-  * @param title
-  *            the dialog's title, or <code>null</code> if none
-  * @param message
-  *            the message
-  */
- static void OpenWarning(Shell::Pointer parent, const QString& title, const QString& message);
-
- /**
-  * Create a message dialog. Note that the dialog will have no visual
-  * representation (no widgets) until it is told to open.
-  * <p>
-  * The labels of the buttons to appear in the button bar are supplied in
-  * this constructor as an array. The <code>open</code> method will return
-  * the index of the label in this array corresponding to the button that was
-  * pressed to close the dialog. If the dialog was dismissed without pressing
-  * a button (ESC, etc.) then -1 is returned. Note that the <code>open</code>
-  * method blocks.
-  * </p>
-  *
-  * @param parentShell
-  *            the parent shell
-  * @param dialogTitle
-  *            the dialog title, or <code>null</code> if none
-  * @param dialogTitleImage
-  *            the dialog title image, or <code>null</code> if none
-  * @param dialogMessage
-  *            the dialog message
-  * @param dialogImageType
-  *            one of the following values:
-  *            <ul>
-  *            <li><code>IDialog::NONE</code> for a dialog with no
-  *            image</li>
-  *            <li><code>IDialog::ERR</code> for a dialog with an
-  *            error image</li>
-  *            <li><code>IDialog::INFORMATION</code> for a dialog
-  *            with an information image</li>
-  *            <li><code>IDialog::QUESTION </code> for a dialog with a
-  *            question image</li>
-  *            <li><code>IDialog::WARNING</code> for a dialog with a
-  *            warning image</li>
-  *            </ul>
-  * @param dialogButtonLabels
-  *            an array of labels for the buttons in the button bar
-  * @param defaultIndex
-  *            the index in the button label array of the default button
-  */
- static IDialog::Pointer CreateMessageDialog(Shell::Pointer parentShell, const QString& dialogTitle,
-         void* dialogTitleImage, const QString& dialogMessage, int dialogImageType,
-         const QList<QString>& dialogButtonLabels, int defaultIndex);
-
-};
-
-}
-
-
-#endif /* BERRYMESSAGEDIALOG_H_ */
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/handlers/berryShowViewHandler.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/handlers/berryShowViewHandler.cpp
index 53e133686f..d0655120d9 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/handlers/berryShowViewHandler.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/handlers/berryShowViewHandler.cpp
@@ -1,117 +1,117 @@
 /*===================================================================
 
 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 "tweaklets/berryWorkbenchTweaklet.h"
 
+#include "berryIWorkbenchCommandConstants.h"
 #include "berryShowViewHandler.h"
 #include "berryHandlerUtil.h"
 
-#include "dialogs/berryIShowViewDialog.h"
-
 #include "berryUIException.h"
 #include "berryIWorkbenchPage.h"
 #include "berryIViewDescriptor.h"
 #include "berryPlatformUI.h"
 
+#include "internal/berryWorkbenchPlugin.h"
+#include "internal/berryQtShowViewDialog.h"
+
 #include <berryCommandExceptions.h>
 
 #include <vector>
 
 namespace berry
 {
 
-const QString ShowViewHandler::PARAMETER_NAME_VIEW_ID = "org.blueberry.ui.views.showView.viewId";
-
 ShowViewHandler::ShowViewHandler()
 {
 }
 
 Object::Pointer ShowViewHandler::Execute(const ExecutionEvent::ConstPointer& event)
 {
   IWorkbenchWindow::ConstPointer window = HandlerUtil::GetActiveWorkbenchWindowChecked(event);
   // Get the view identifier, if any.
   const ExecutionEvent::ParameterMap& parameters = event->GetParameters();
-  ExecutionEvent::ParameterMap::const_iterator result = parameters.find(PARAMETER_NAME_VIEW_ID);
-  QString value;
-  if (result != parameters.end()) value = result.value();
+  ExecutionEvent::ParameterMap::const_iterator result = parameters.find(IWorkbenchCommandConstants::VIEWS_SHOW_VIEW_PARM_ID);
+  QString viewId = result != parameters.end() ? result.value() : QString::null;
+  result = parameters.find(IWorkbenchCommandConstants::VIEWS_SHOW_VIEW_SECONDARY_ID);
+  QString secondary = result != parameters.end() ? result.value() : QString::null;
 
-  if (value.isEmpty())
+  if (viewId.isEmpty())
   {
     this->OpenOther(window);
   }
   else
   {
     try
     {
-      this->OpenView(value, window);
+      this->OpenView(viewId, secondary, window);
     }
     catch (const PartInitException& e)
     {
       throw ExecutionException("Part could not be initialized", e);
     }
   }
 
   return Object::Pointer(0);
 }
 
 void ShowViewHandler::OpenOther(IWorkbenchWindow::ConstPointer window)
 {
   const IWorkbenchPage::Pointer page = window->GetActivePage();
   if (page.IsNull())
   {
     return;
   }
 
-  IShowViewDialog::Pointer dialog = Tweaklets::Get(WorkbenchTweaklet::KEY)->CreateStandardDialog(WorkbenchTweaklet::DIALOG_ID_SHOW_VIEW).Cast<IShowViewDialog>();
-  if (dialog.IsNull()) return;
+  QtShowViewDialog dialog(window.GetPointer(), WorkbenchPlugin::GetDefault()->GetViewRegistry());
 
-  int returnCode = dialog->Open();
+  int returnCode = dialog.exec();
 
-  if (returnCode == IDialog::CANCEL)
+  if (returnCode == QDialog::Rejected)
   {
     return;
   }
 
-  const QList<IViewDescriptor::Pointer> descriptors =
-      dialog->GetSelection();
+  const QList<IViewDescriptor::Pointer> descriptors = dialog.GetSelection();
   for (int i = 0; i < descriptors.size(); ++i)
   {
     try
     {
-      this->OpenView(descriptors[i]->GetId(), window);
+      this->OpenView(descriptors[i]->GetId(), QString(), window);
     }
-    catch (PartInitException e)
+    catch (const PartInitException& e)
     {
+      BERRY_WARN << e.what();
 //      StatusUtil.handleStatus(e.getStatus(),
 //          WorkbenchMessages.ShowView_errorTitle
 //          + ": " + e.getMessage(), //$NON-NLS-1$
 //          StatusManager.SHOW);
     }
   }
 }
 
-void ShowViewHandler::OpenView(const QString& viewId, IWorkbenchWindow::ConstPointer activeWorkbenchWindow)
+void ShowViewHandler::OpenView(const QString& viewId, const QString& secondaryId, IWorkbenchWindow::ConstPointer activeWorkbenchWindow)
 {
   const IWorkbenchPage::Pointer activePage = activeWorkbenchWindow->GetActivePage();
   if (activePage.IsNull())
   {
     return;
   }
 
-  activePage->ShowView(viewId);
+  activePage->ShowView(viewId, secondaryId, IWorkbenchPage::VIEW_ACTIVATE);
 }
 
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/handlers/berryShowViewHandler.h b/BlueBerry/Bundles/org.blueberry.ui.qt/src/handlers/berryShowViewHandler.h
index 0c002d75a4..a1ef9d0af3 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/handlers/berryShowViewHandler.h
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/handlers/berryShowViewHandler.h
@@ -1,80 +1,75 @@
 /*===================================================================
 
 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 BERRYSHOWVIEWHANDLER_H_
 #define BERRYSHOWVIEWHANDLER_H_
 
 #include <berryAbstractHandler.h>
 #include <berryExecutionEvent.h>
 
 #include "berryIWorkbenchWindow.h"
 #include <org_blueberry_ui_qt_Export.h>
 
 namespace berry
 {
 
 /**
  * \ingroup org_blueberry_ui_qt
  *
  * Shows the given view. If no view is specified in the parameters, then this
  * opens the view selection dialog.
  *
  * @since 3.1
  */
 class BERRY_UI_QT ShowViewHandler : public AbstractHandler
 {
   Q_OBJECT
 
 public:
-  berryObjectMacro(ShowViewHandler);
-
-private:
-
-  /**
-   * The name of the parameter providing the view identifier.
-   */
-  static const QString PARAMETER_NAME_VIEW_ID;
+  berryObjectMacro(ShowViewHandler)
 
 public:
 
   /**
    * Creates a new ShowViewHandler that will open the view in its default location.
    */
   ShowViewHandler();
 
   Object::Pointer Execute(const ExecutionEvent::ConstPointer& event);
 
 private:
 
   /**
    * Opens a view selection dialog, allowing the user to chose a view.
    */
   void OpenOther(IWorkbenchWindow::ConstPointer window);
 
   /**
    * Opens the view with the given identifier.
    *
    * @param viewId
    *            The view to open; must not be <code>null</code>
+   * @param secondaryId
+   *            An optional secondary id; may be <code>null</code>
    * @throws PartInitException
    *             If the part could not be initialized.
    */
-  void OpenView(const QString& viewId, IWorkbenchWindow::ConstPointer activeWorkbenchWindow);
+  void OpenView(const QString& viewId, const QString& secondaryId, IWorkbenchWindow::ConstPointer activeWorkbenchWindow);
 };
 
 }
 
 #endif /*BERRYSHOWVIEWHANDLER_H_*/
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryPerspective.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryPerspective.cpp
index 7ec7694dd2..99b5125b50 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryPerspective.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryPerspective.cpp
@@ -1,1811 +1,1812 @@
 /*===================================================================
 
 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 "tweaklets/berryGuiWidgetsTweaklet.h"
 
 #include "berryPerspective.h"
 
 #include "berryPerspectiveHelper.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryWorkbenchConstants.h"
 #include "berryPerspectiveExtensionReader.h"
 #include "berryEditorSashContainer.h"
 #include "berryPartSite.h"
 #include "berryViewSite.h"
 #include "berryEditorAreaHelper.h"
 #include "intro/berryIntroConstants.h"
-#include "dialogs/berryMessageDialog.h"
 #include "berryWorkbenchWindow.h"
 #include "berryStatusUtil.h"
 
 #include "presentations/berryIStackPresentationSite.h"
 
+#include <QMessageBox>
+
 namespace berry
 {
 
 const QString Perspective::VERSION_STRING = "0.016";
 
 Perspective::Perspective(PerspectiveDescriptor::Pointer desc,
     WorkbenchPage::Pointer page)
  : descriptor(desc)
  {
   this->Init(page);
   if (desc.IsNotNull())
   {
     this->CreatePresentation(desc);
   }
 }
 
 Perspective::Perspective(WorkbenchPage::Pointer page)
 {
   this->Init(page);
 }
 
 void Perspective::Init(WorkbenchPage::Pointer page)
 {
   editorHidden = false;
   editorAreaState = IStackPresentationSite::STATE_RESTORED;
   fixed = false;
   presentation = 0;
   shouldHideEditorsOnActivate = false;
   this->page = page.GetPointer();
   this->editorArea = page->GetEditorPresentation()->GetLayoutPart();
   this->viewFactory = page->GetViewFactory();
 }
 
 bool Perspective::BringToTop(IViewReference::Pointer ref)
 {
   return presentation->BringPartToTop(this->GetPane(ref));
 }
 
 bool Perspective::ContainsView(IViewPart::Pointer view)
 {
   IViewSite::Pointer site = view->GetViewSite();
   IViewReference::Pointer ref = this->FindView(site->GetId(), site->GetSecondaryId());
   if (ref.IsNull())
   {
     return false;
   }
   return (view.Cast<IWorkbenchPart>() == ref->GetPart(false));
 }
 
 bool Perspective::ContainsView(const QString& viewId) const
 {
   return mapIDtoViewLayoutRec.contains(viewId);
 }
 
 void Perspective::CreatePresentation(PerspectiveDescriptor::Pointer persp)
 {
   if (persp->HasCustomDefinition())
   {
     this->LoadCustomPersp(persp);
   }
   else
   {
     this->LoadPredefinedPersp(persp);
   }
 }
 
 Perspective::~Perspective()
 {
   // Get rid of presentation.
   if (presentation == 0)
   {
     DisposeViewRefs();
     return;
   }
 
   presentation->Deactivate();
 
   // Release each view.
   QList<IViewReference::Pointer> refs(this->GetViewReferences());
   for (QList<IViewReference::Pointer>::size_type i = 0, length = refs.size(); i < length; i++)
   {
     this->GetViewFactory()->ReleaseView(refs[i]);
   }
 
   mapIDtoViewLayoutRec.clear();
   delete presentation;
 }
 
 void Perspective::DisposeViewRefs()
 {
   if (!memento)
   {
     return;
   }
   QList<IMemento::Pointer> views(memento->GetChildren(WorkbenchConstants::TAG_VIEW));
   for (int x = 0; x < views.size(); x++)
   {
     // Get the view details.
     IMemento::Pointer childMem = views[x];
     QString id; childMem->GetString(WorkbenchConstants::TAG_ID, id);
     // skip creation of the intro reference - it's handled elsewhere.
     if (id == IntroConstants::INTRO_VIEW_ID)
     {
       continue;
     }
 
     QString secondaryId = ViewFactory::ExtractSecondaryId(id);
     if (!secondaryId.isEmpty())
     {
       id = ViewFactory::ExtractPrimaryId(id);
     }
 
     QString removed;
     childMem->GetString(WorkbenchConstants::TAG_REMOVED, removed);
     if (removed != "true")
     {
       IViewReference::Pointer ref = viewFactory->GetView(id, secondaryId);
       if (ref)
       {
         viewFactory->ReleaseView(ref);
       }
     }
   }
 }
 
 IViewReference::Pointer Perspective::FindView(const QString& viewId)
 {
   return this->FindView(viewId, "");
 }
 
 IViewReference::Pointer Perspective::FindView(const QString& id, const QString& secondaryId)
 {
   QList<IViewReference::Pointer> refs(this->GetViewReferences());
   for (int i = 0; i < refs.size(); i++)
   {
     IViewReference::Pointer ref = refs[i];
     if (id == ref->GetId()
         && (secondaryId  == ref->GetSecondaryId()))
     {
       return ref;
     }
   }
   return IViewReference::Pointer(0);
 }
 
 void* Perspective::GetClientComposite()
 {
   return page->GetClientComposite();
 }
 
 IPerspectiveDescriptor::Pointer Perspective::GetDesc()
 {
   return descriptor;
 }
 
 PartPane::Pointer Perspective::GetPane(IViewReference::Pointer ref)
 {
   return ref.Cast<WorkbenchPartReference>()->GetPane();
 }
 
 QList<QString> Perspective::GetPerspectiveShortcuts()
 {
   return perspectiveShortcuts;
 }
 
 PerspectiveHelper* Perspective::GetPresentation() const
 {
   return presentation;
 }
 
 QList<QString> Perspective::GetShowViewShortcuts()
 {
   return showViewShortcuts;
 }
 
 ViewFactory* Perspective::GetViewFactory()
 {
   return viewFactory;
 }
 
 QList<IViewReference::Pointer> Perspective::GetViewReferences()
 {
   // Get normal views.
   if (presentation == 0)
   {
     return QList<IViewReference::Pointer>();
   }
 
   QList<PartPane::Pointer> panes;
   presentation->CollectViewPanes(panes);
 
   QList<IViewReference::Pointer> result;
 //  List fastViews = (fastViewManager != 0) ?
 //  fastViewManager.getFastViews(0)
 //  : new ArrayList();
 //  IViewReference[] resultArray = new IViewReference[panes.size()
 //  + fastViews.size()];
 //
 //  // Copy fast views.
 //  int nView = 0;
 //  for (int i = 0; i < fastViews.size(); i++)
 //  {
 //    resultArray[nView] = (IViewReference) fastViews.get(i);
 //    ++nView;
 //  }
 
   // Copy normal views.
   for (QList<PartPane::Pointer>::iterator iter = panes.begin();
        iter != panes.end(); ++iter)
   {
     PartPane::Pointer pane = *iter;
     result.push_back(pane->GetPartReference().Cast<IViewReference>());
   }
 
   return result;
 }
 
 void Perspective::HideEditorArea()
 {
   if (!this->IsEditorAreaVisible())
   {
     return;
   }
 
   // Show the editor in the appropriate location
   if (this->UseNewMinMax(Perspective::Pointer(this)))
   {
     // If it's the currently maximized part we have to restore first
 //    if (this->GetPresentation().getMaximizedStack().Cast<EditorStack>() != 0)
 //    {
 //      getPresentation().getMaximizedStack().setState(IStackPresentationSite.STATE_RESTORED);
 //    }
 
     bool isMinimized = editorAreaState == IStackPresentationSite::STATE_MINIMIZED;
     if (!isMinimized)
       this->HideEditorAreaLocal();
     //else
     //  this->SetEditorAreaTrimVisibility(false);
   }
   else
   {
     this->HideEditorAreaLocal();
   }
 
   editorHidden = true;
 }
 
 void Perspective::HideEditorAreaLocal()
 {
   if (editorHolder != 0)
   {
     return;
   }
 
   // Replace the editor area with a placeholder so we
   // know where to put it back on show editor area request.
   editorHolder = new PartPlaceholder(editorArea->GetID());
   presentation->GetLayout()->Replace(editorArea, editorHolder);
 }
 
 bool Perspective::HideView(IViewReference::Pointer ref)
 {
   // If the view is locked just return.
   PartPane::Pointer pane = this->GetPane(ref);
 
   presentation->RemovePart(pane);
 
   // Dispose view if ref count == 0.
   this->GetViewFactory()->ReleaseView(ref);
   return true;
 }
 
 bool Perspective::IsEditorAreaVisible()
 {
   return !editorHidden;
 }
 
 ViewLayoutRec::Pointer Perspective::GetViewLayoutRec(IViewReference::Pointer ref, bool create)
 {
   ViewLayoutRec::Pointer result = this->GetViewLayoutRec(ViewFactory::GetKey(ref), create);
   if (result.IsNull() && create==false)
   {
     result = this->GetViewLayoutRec(ref->GetId(), false);
   }
   return result;
 }
 
 ViewLayoutRec::Pointer Perspective::GetViewLayoutRec(const QString& viewId, bool create)
 {
   ViewLayoutRec::Pointer rec = mapIDtoViewLayoutRec[viewId];
   if (rec.IsNull() && create)
   {
     rec = new ViewLayoutRec();
     mapIDtoViewLayoutRec[viewId] = rec;
   }
   return rec;
 }
 
 bool Perspective::IsFixedLayout()
 {
   //@issue is there a difference between a fixed
   //layout and a fixed perspective?? If not the API
   //may need some polish, WorkbenchPage, PageLayout
   //and Perspective all have isFixed methods.
   //PageLayout and Perspective have their own fixed
   //attribute, we are assuming they are always in sync.
   //WorkbenchPage delegates to the perspective.
   return fixed;
 }
 
 bool Perspective::IsStandaloneView(IViewReference::Pointer ref)
 {
   ViewLayoutRec::Pointer rec = this->GetViewLayoutRec(ref, false);
   return rec.IsNotNull() && rec->isStandalone;
 }
 
 bool Perspective::GetShowTitleView(IViewReference::Pointer ref)
 {
   ViewLayoutRec::Pointer rec = this->GetViewLayoutRec(ref, false);
   return rec.IsNotNull() && rec->showTitle;
 }
 
 void Perspective::LoadCustomPersp(PerspectiveDescriptor::Pointer persp)
 {
   //get the layout from the registry
   PerspectiveRegistry* perspRegistry = dynamic_cast<PerspectiveRegistry*>(WorkbenchPlugin::GetDefault()->GetPerspectiveRegistry());
   try
   {
     IMemento::Pointer memento = perspRegistry->GetCustomPersp(persp->GetId());
     // Restore the layout state.
 //    MultiStatus status = new MultiStatus(
 //        PlatformUI.PLUGIN_ID,
 //        IStatus.OK,
 //        NLS.bind(WorkbenchMessages.Perspective_unableToRestorePerspective, persp.getLabel()),
 //        0);
 //    status.merge(restoreState(memento));
 //    status.merge(restoreState());
     bool okay = true;
     okay &= this->RestoreState(memento);
     okay &= this->RestoreState();
     if (!okay)
     {
       this->UnableToOpenPerspective(persp, "Unable to open perspective: " + persp->GetLabel());
     }
   }
   //catch (IOException e)
   //{
   //  unableToOpenPerspective(persp, 0);
   //}
   catch (const WorkbenchException& e)
   {
     this->UnableToOpenPerspective(persp, e.what());
   }
 }
 
 void Perspective::UnableToOpenPerspective(PerspectiveDescriptor::Pointer persp,
     const QString& status)
 {
   PerspectiveRegistry* perspRegistry = dynamic_cast<PerspectiveRegistry*>(WorkbenchPlugin
   ::GetDefault()->GetPerspectiveRegistry());
   perspRegistry->DeletePerspective(persp);
   // If this is a predefined perspective, we will not be able to delete
   // the perspective (we wouldn't want to).  But make sure to delete the
   // customized portion.
   persp->DeleteCustomDefinition();
   QString title = "Restoring problems";
   QString msg = "Unable to read workbench state.";
   if (status == "")
   {
-    MessageDialog::OpenError(Shell::Pointer(0), title, msg);
+    QMessageBox::critical(NULL, title, msg);
   }
   else
   {
     //TODO error dialog
     //ErrorDialog.openError((Shell) 0, title, msg, status);
-    MessageDialog::OpenError(Shell::Pointer(0), title, msg + "\n" + status);
+    QMessageBox::critical(NULL, title, msg + "\n" + status);
   }
 }
 
 void Perspective::LoadPredefinedPersp(PerspectiveDescriptor::Pointer persp)
 {
   // Create layout engine.
   IPerspectiveFactory::Pointer factory;
   try
   {
     factory = persp->CreateFactory();
   }
   catch (CoreException& /*e*/)
   {
     throw WorkbenchException("Unable to load perspective: " + persp->GetId());
   }
 
   /*
    * IPerspectiveFactory#createFactory() can return 0
    */
   if (factory == 0)
   {
     throw WorkbenchException("Unable to load perspective: " + persp->GetId());
   }
 
   // Create layout factory.
   ViewSashContainer::Pointer container(new ViewSashContainer(page, this->GetClientComposite()));
   layout = new PageLayout(container, this->GetViewFactory(),
       editorArea, descriptor);
   layout->SetFixed(descriptor->GetFixed());
 
 //  // add the placeholders for the sticky folders and their contents
   IPlaceholderFolderLayout::Pointer stickyFolderRight, stickyFolderLeft, stickyFolderTop, stickyFolderBottom;
 
   QList<IStickyViewDescriptor::Pointer> descs(WorkbenchPlugin::GetDefault()
   ->GetViewRegistry()->GetStickyViews());
   for (int i = 0; i < descs.size(); i++)
   {
     IStickyViewDescriptor::Pointer stickyViewDescriptor = descs[i];
     QString id = stickyViewDescriptor->GetId();
     int location = stickyViewDescriptor->GetLocation();
     if (location == IPageLayout::RIGHT)
     {
       if (stickyFolderRight == 0)
       {
         stickyFolderRight = layout
         ->CreatePlaceholderFolder(
             StickyViewDescriptor::STICKY_FOLDER_RIGHT,
             IPageLayout::RIGHT, .75f,
             IPageLayout::ID_EDITOR_AREA);
       }
       stickyFolderRight->AddPlaceholder(id);
     }
     else if (location == IPageLayout::LEFT)
     {
       if (stickyFolderLeft == 0)
       {
         stickyFolderLeft = layout->CreatePlaceholderFolder(
             StickyViewDescriptor::STICKY_FOLDER_LEFT,
             IPageLayout::LEFT, .25f, IPageLayout::ID_EDITOR_AREA);
       }
       stickyFolderLeft->AddPlaceholder(id);
     }
     else if (location == IPageLayout::TOP)
     {
       if (stickyFolderTop == 0)
       {
         stickyFolderTop = layout->CreatePlaceholderFolder(
             StickyViewDescriptor::STICKY_FOLDER_TOP,
             IPageLayout::TOP, .25f, IPageLayout::ID_EDITOR_AREA);
       }
       stickyFolderTop->AddPlaceholder(id);
     }
     else if (location == IPageLayout::BOTTOM)
     {
       if (stickyFolderBottom == 0)
       {
         stickyFolderBottom = layout->CreatePlaceholderFolder(
             StickyViewDescriptor::STICKY_FOLDER_BOTTOM,
             IPageLayout::BOTTOM, .75f,
             IPageLayout::ID_EDITOR_AREA);
       }
       stickyFolderBottom->AddPlaceholder(id);
     }
 
     //should never be 0 as we've just added the view above
     IViewLayout::Pointer viewLayout = layout->GetViewLayout(id);
     viewLayout->SetCloseable(stickyViewDescriptor->IsCloseable());
     viewLayout->SetMoveable(stickyViewDescriptor->IsMoveable());
   }
 
   // Run layout engine.
   factory->CreateInitialLayout(layout);
   PerspectiveExtensionReader extender;
   extender.ExtendLayout(descriptor->GetId(), layout);
 
   // Retrieve view layout info stored in the page layout.
   QHash<QString, ViewLayoutRec::Pointer> layoutInfo = layout->GetIDtoViewLayoutRecMap();
   mapIDtoViewLayoutRec.unite(layoutInfo);
 
   //TODO Perspective action sets
   // Create action sets.
   //List temp = new ArrayList();
   //this->CreateInitialActionSets(temp, layout.getActionSets());
 
 //  IContextService service = 0;
 //  if (page != 0)
 //  {
 //    service = (IContextService) page.getWorkbenchWindow().getService(
 //        IContextService.class);
 //  }
 //  try
 //  {
 //    if (service!=0)
 //    {
 //      service.activateContext(ContextAuthority.DEFER_EVENTS);
 //    }
 //    for (Iterator iter = temp.iterator(); iter.hasNext();)
 //    {
 //      IActionSetDescriptor descriptor = (IActionSetDescriptor) iter
 //      .next();
 //      addAlwaysOn(descriptor);
 //    }
 //  }finally
 //  {
 //    if (service!=0)
 //    {
 //      service.activateContext(ContextAuthority.SEND_EVENTS);
 //    }
 //  }
 
 //  newWizardShortcuts = layout.getNewWizardShortcuts();
     showViewShortcuts = layout->GetShowViewShortcuts();
 //  perspectiveShortcuts = layout.getPerspectiveShortcuts();
 //  showInPartIds = layout.getShowInPartIds();
 //
 //  // Retrieve fast views
 //  if (fastViewManager != 0)
 //  {
 //    ArrayList fastViews = layout.getFastViews();
 //    for (Iterator fvIter = fastViews.iterator(); fvIter.hasNext();)
 //    {
 //      IViewReference ref = (IViewReference) fvIter.next();
 //      fastViewManager.addViewReference(FastViewBar.FASTVIEWBAR_ID, -1, ref,
 //          !fvIter.hasNext());
 //    }
 //  }
 
   // Is the layout fixed
   fixed = layout->IsFixed();
   showViewShortcuts = layout->GetShowViewShortcuts();
 
   // Create presentation.
   presentation = new PerspectiveHelper(page, container, this);
 
   // Hide editor area if requested by factory
   if (!layout->IsEditorAreaVisible())
   {
     this->HideEditorArea();
   }
 
 }
 
 void Perspective::OnActivate()
 {
   // Update editor area state.
   if (editorArea->GetControl() != 0)
   {
     bool visible = this->IsEditorAreaVisible();
     bool inTrim = editorAreaState == IStackPresentationSite::STATE_MINIMIZED;
 
     editorArea->SetVisible(visible && !inTrim);
   }
 
 //  // Update fast views.
 //  // Make sure the control for the fastviews are created so they can
 //  // be activated.
 //  if (fastViewManager != 0)
 //  {
 //    List fastViews = fastViewManager.getFastViews(0);
 //    for (int i = 0; i < fastViews.size(); i++)
 //    {
 //      ViewPane pane = getPane((IViewReference) fastViews.get(i));
 //      if (pane != 0)
 //      {
 //        Control ctrl = pane.getControl();
 //        if (ctrl == 0)
 //        {
 //          pane.createControl(getClientComposite());
 //          ctrl = pane.getControl();
 //        }
 //        ctrl.setEnabled(false); // Remove focus support.
 //      }
 //    }
 //  }
 
 //  // Set the visibility of all fast view pins
 //  setAllPinsVisible(true);
 
   // Trim Stack Support
   bool useNewMinMax = Perspective::UseNewMinMax(Perspective::Pointer(this));
   bool hideEditorArea = shouldHideEditorsOnActivate || (editorHidden && editorHolder == 0);
 
   // We have to set the editor area's stack state -before-
   // activating the presentation since it's used there to determine
   // size of the resulting stack
   if (useNewMinMax && !hideEditorArea)
   {
     this->RefreshEditorAreaVisibility();
   }
 
   // Show the layout
   presentation->Activate(this->GetClientComposite());
 
 //  if (useNewMinMax)
 //  {
 //    fastViewManager.activate();
 //
 //    // Move any minimized extension stacks to the trim
 //    if (layout != 0)
 //    {
 //      // Turn aimations off
 //      IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
 //      bool useAnimations = preferenceStore
 //      .getbool(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS);
 //      preferenceStore.setValue(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS, false);
 //
 //      List minStacks = layout.getMinimizedStacks();
 //      for (Iterator msIter = minStacks.iterator(); msIter.hasNext();)
 //      {
 //        ViewStack vs = (ViewStack) msIter.next();
 //        vs.setMinimized(true);
 //      }
 //
 //      // Restore the animation pref
 //      preferenceStore.setValue(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS, useAnimations);
 //
 //      // this is a one-off deal...set during the extension reading
 //      minStacks.clear();
 //      layout = 0;
 //    }
 //  }
 //  else
 //  {
 //    // Update the FVB only if not using the new min/max
 //
 //    //    WorkbenchWindow wbw = (WorkbenchWindow) page.getWorkbenchWindow();
 ////    if (wbw != 0)
 ////    {
 ////      ITrimManager tbm = wbw.getTrimManager();
 ////      if (tbm != 0)
 ////      {
 ////        IWindowTrim fvb = tbm.getTrim(FastViewBar.FASTVIEWBAR_ID);
 ////        if (fvb instanceof FastViewBar)
 ////        {
 ////          ((FastViewBar)fvb).update(true);
 ////        }
 ////      }
 ////    }
 //  }
 
 //  // If we are -not- using the new min/max then ensure that there
 //  // are no stacks in the trim. This can happen when a user switches
 //  // back to the 3.0 presentation...
 //  if (!Perspective.useNewMinMax(this) && fastViewManager != 0)
 //  {
 //    bool stacksWereRestored = fastViewManager.restoreAllTrimStacks();
 //    setEditorAreaTrimVisibility(false);
 //
 //    // Restore any 'maximized' view stack since we've restored
 //    // the minimized stacks
 //    if (stacksWereRestored && presentation.getMaximizedStack().Cast<ViewStack>() != 0)
 //    {
 //      ViewStack vs = (ViewStack) presentation.getMaximizedStack();
 //      vs.setPresentationState(IStackPresentationSite.STATE_RESTORED);
 //      presentation.setMaximizedStack(0);
 //    }
 //  }
 
   // We hide the editor area -after- the presentation activates
   if (hideEditorArea)
   {
     // We do this here to ensure that createPartControl is called on the
     // top editor
     // before it is hidden. See bug 20166.
     this->HideEditorArea();
     shouldHideEditorsOnActivate = false;
 
 //    // this is an override so it should handle both states
 //    if (useNewMinMax)
 //    setEditorAreaTrimVisibility(editorAreaState == IStackPresentationSite.STATE_MINIMIZED);
   }
 
   FixOrphan();
 }
 
 void Perspective::FixOrphan()
 {
   PerspectiveRegistry* reg = static_cast<PerspectiveRegistry*>(PlatformUI::GetWorkbench()->GetPerspectiveRegistry());
   IPerspectiveDescriptor::Pointer regDesc = reg->FindPerspectiveWithId(descriptor->GetId());
   if (regDesc.IsNull())
   {
     QString msg = "Perspective " + descriptor->GetLabel() + " has been made into a local copy";
     IStatus::Pointer status = StatusUtil::NewStatus(IStatus::WARNING_TYPE, msg, BERRY_STATUS_LOC);
     //StatusManager.getManager().handle(status, StatusManager.LOG);
     WorkbenchPlugin::Log(status);
 
     QString localCopyLabel("<%1>");
     QString newDescId = localCopyLabel.arg(descriptor->GetLabel());
     while (reg->FindPerspectiveWithId(newDescId).IsNotNull())
     {
       newDescId = localCopyLabel.arg(newDescId);
     }
     IPerspectiveDescriptor::Pointer newDesc = reg->CreatePerspective(newDescId, descriptor);
     page->SavePerspectiveAs(newDesc);
   }
 }
 
 void Perspective::OnDeactivate()
 {
   presentation->Deactivate();
   //setActiveFastView(0);
   //setAllPinsVisible(false);
 
 //  // Update fast views.
 //  if (fastViewManager != 0)
 //  {
 //    List fastViews = fastViewManager.getFastViews(0);
 //    for (int i = 0; i < fastViews.size(); i++)
 //    {
 //      ViewPane pane = getPane((IViewReference) fastViews.get(i));
 //      if (pane != 0)
 //      {
 //        Control ctrl = pane.getControl();
 //        if (ctrl != 0)
 //        {
 //          ctrl.setEnabled(true); // Add focus support.
 //        }
 //      }
 //    }
 //
 //    fastViewManager.deActivate();
 //  }
 //
 //  // Ensure that the editor area trim is hidden as well
 //  setEditorAreaTrimVisibility(false);
 }
 
 void Perspective::PartActivated(IWorkbenchPart::Pointer  /*activePart*/)
 {
 //  // If a fastview is open close it.
 //  if (activeFastView != 0
 //      && activeFastView.getPart(false) != activePart)
 //  {
 //    setActiveFastView(0);
 //  }
 }
 
 void Perspective::PerformedShowIn(const QString&  /*partId*/)
 {
   //showInTimes.insert(std::make_pair(partId, new Long(System.currentTimeMillis())));
 }
 
 bool Perspective::RestoreState(IMemento::Pointer memento)
 {
 
 //  MultiStatus result = new MultiStatus(
 //      PlatformUI.PLUGIN_ID,
 //      IStatus.OK,
 //      WorkbenchMessages.Perspective_problemsRestoringPerspective, 0);
   bool result = true;
 
   // Create persp descriptor.
   descriptor = new PerspectiveDescriptor("", "", PerspectiveDescriptor::Pointer(0));
   //result.add(descriptor.restoreState(memento));
   result &= descriptor->RestoreState(memento);
   PerspectiveDescriptor::Pointer desc = WorkbenchPlugin::GetDefault()->
       GetPerspectiveRegistry()->FindPerspectiveWithId(descriptor->GetId()).Cast<PerspectiveDescriptor>();
   if (desc)
   {
     descriptor = desc;
   }
   else
   {
     try
     {
       WorkbenchPlugin::GetDefault()->GetPerspectiveRegistry()->CreatePerspective(descriptor->GetLabel(), descriptor.Cast<berry::IPerspectiveDescriptor>());
     }
     catch (...)
     {
       std::cout << "Perspective could not be loaded" << std::endl;
     }
   }
 
   this->memento = memento;
   // Add the visible views.
   QList<IMemento::Pointer> views(memento->GetChildren(WorkbenchConstants::TAG_VIEW));
   //result.merge(createReferences(views));
   result &= this->CreateReferences(views);
 
   memento = memento->GetChild(WorkbenchConstants::TAG_FAST_VIEWS);
   if (memento)
   {
     views = memento->GetChildren(WorkbenchConstants::TAG_VIEW);
     //result.merge(createReferences(views));
     result &= this->CreateReferences(views);
   }
   return result;
 }
 
 bool Perspective::CreateReferences(const QList<IMemento::Pointer>& views)
 {
 //  MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK,
 //      WorkbenchMessages.Perspective_problemsRestoringViews, 0);
   bool result = true;
 
   for (int x = 0; x < views.size(); x++)
   {
     // Get the view details.
     IMemento::Pointer childMem = views[x];
     QString id; childMem->GetString(WorkbenchConstants::TAG_ID, id);
     // skip creation of the intro reference -  it's handled elsewhere.
     if (id == IntroConstants::INTRO_VIEW_ID)
     {
       continue;
     }
 
     QString secondaryId(ViewFactory::ExtractSecondaryId(id));
     if (!secondaryId.isEmpty())
     {
       id = ViewFactory::ExtractPrimaryId(id);
     }
     // Create and open the view.
     try
     {
       QString rm; childMem->GetString(WorkbenchConstants::TAG_REMOVED, rm);
       if (rm != "true")
       {
         viewFactory->CreateView(id, secondaryId);
       }
     }
     catch (const PartInitException& e)
     {
       childMem->PutString(WorkbenchConstants::TAG_REMOVED, "true");
 //      result.add(StatusUtil.newStatus(IStatus.ERR,
 //              e.getMessage() == 0 ? "" : e.getMessage(), //$NON-NLS-1$
 //              e));
       WorkbenchPlugin::Log(e.what(), e);
       result &= true;
     }
   }
   return result;
 }
 
 bool Perspective::RestoreState()
 {
   if (this->memento == 0)
   {
     //return new Status(IStatus.OK, PlatformUI.PLUGIN_ID, 0, "", 0); //$NON-NLS-1$
     return true;
   }
 
 //  MultiStatus result = new MultiStatus(
 //      PlatformUI.PLUGIN_ID,
 //      IStatus.OK,
 //      WorkbenchMessages.Perspective_problemsRestoringPerspective, 0);
   bool result = true;
 
   IMemento::Pointer memento = this->memento;
   this->memento = 0;
 
   const IMemento::Pointer boundsMem(memento->GetChild(WorkbenchConstants::TAG_WINDOW));
   if (boundsMem)
   {
     Rectangle r(0, 0, 0, 0);
     boundsMem->GetInteger(WorkbenchConstants::TAG_X, r.x);
     boundsMem->GetInteger(WorkbenchConstants::TAG_Y, r.y);
     boundsMem->GetInteger(WorkbenchConstants::TAG_HEIGHT, r.height);
     boundsMem->GetInteger(WorkbenchConstants::TAG_WIDTH, r.width);
     //StartupThreading.runWithoutExceptions(new StartupRunnable()
     //    {
 
     //      void runWithException() throws Throwable
     //      {
             if (page->GetWorkbenchWindow()->GetActivePage() == 0)
             {
               page->GetWorkbenchWindow()->GetShell()->SetBounds(r);
             }
     //      }
     //    });
 
   }
 
   // Create an empty presentation..
   PerspectiveHelper* pres;
   //StartupThreading.runWithoutExceptions(new StartupRunnable()
   //    {
 
   //      void runWithException() throws Throwable
   //      {
           ViewSashContainer::Pointer mainLayout(new ViewSashContainer(page, this->GetClientComposite()));
           pres = new PerspectiveHelper(page, mainLayout, this);
   //      }});
 
 
   // Read the layout.
 //  result.merge(pres.restoreState(memento
 //          .getChild(IWorkbenchConstants.TAG_LAYOUT)));
   result &= pres->RestoreState(memento->GetChild(WorkbenchConstants::TAG_LAYOUT));
 
   //StartupThreading.runWithoutExceptions(new StartupRunnable()
   //    {
 
   //      void runWithException() throws Throwable
   //      {
           // Add the editor workbook. Do not hide it now.
           pres->ReplacePlaceholderWithPart(editorArea);
   //      }});
 
   // Add the visible views.
   QList<IMemento::Pointer> views(memento->GetChildren(WorkbenchConstants::TAG_VIEW));
 
   for (int x = 0; x < views.size(); x++)
   {
     // Get the view details.
     IMemento::Pointer childMem = views[x];
     QString id; childMem->GetString(WorkbenchConstants::TAG_ID, id);
     QString secondaryId(ViewFactory::ExtractSecondaryId(id));
     if (!secondaryId.isEmpty())
     {
       id = ViewFactory::ExtractPrimaryId(id);
     }
 
     // skip the intro as it is restored higher up in workbench.
     if (id == IntroConstants::INTRO_VIEW_ID)
     {
       continue;
     }
 
     // Create and open the view.
     IViewReference::Pointer viewRef = viewFactory->GetView(id, secondaryId);
     WorkbenchPartReference::Pointer ref = viewRef.Cast<WorkbenchPartReference>();
 
     // report error
     if (ref == 0)
     {
       QString key = ViewFactory::GetKey(id, secondaryId);
 //      result.add(new Status(IStatus.ERR, PlatformUI.PLUGIN_ID, 0,
 //              NLS.bind(WorkbenchMessages.Perspective_couldNotFind, key ), 0));
       WorkbenchPlugin::Log("Could not find view: " + key);
       continue;
     }
     bool willPartBeVisible = pres->WillPartBeVisible(ref->GetId(), secondaryId);
     if (willPartBeVisible)
     {
       IViewPart::Pointer view = ref->GetPart(true).Cast<IViewPart>();
       if (view)
       {
         ViewSite::Pointer site = view->GetSite().Cast<ViewSite>();
         pres->ReplacePlaceholderWithPart(site->GetPane().Cast<LayoutPart>());
       }
     }
     else
     {
       pres->ReplacePlaceholderWithPart(ref->GetPane());
     }
   }
 
 //  // Load the fast views
 //  if (fastViewManager != 0)
 //  fastViewManager.restoreState(memento, result);
 
   // Load the view layout recs
   QList<IMemento::Pointer> recMementos(memento
   ->GetChildren(WorkbenchConstants::TAG_VIEW_LAYOUT_REC));
   for (int i = 0; i < recMementos.size(); i++)
   {
     IMemento::Pointer recMemento = recMementos[i];
     QString compoundId;
     if (recMemento->GetString(WorkbenchConstants::TAG_ID, compoundId))
     {
       ViewLayoutRec::Pointer rec = GetViewLayoutRec(compoundId, true);
       QString closeablestr; recMemento->GetString(WorkbenchConstants::TAG_CLOSEABLE, closeablestr);
       if (WorkbenchConstants::FALSE_VAL == closeablestr)
       {
         rec->isCloseable = false;
       }
       QString moveablestr; recMemento->GetString(WorkbenchConstants::TAG_MOVEABLE, moveablestr);
       if (WorkbenchConstants::FALSE_VAL == moveablestr)
       {
         rec->isMoveable = false;
       }
       QString standalonestr; recMemento->GetString(WorkbenchConstants::TAG_STANDALONE, standalonestr);
       if (WorkbenchConstants::TRUE_VAL == standalonestr)
       {
         rec->isStandalone = true;
         QString showstr; recMemento->GetString(WorkbenchConstants::TAG_SHOW_TITLE, showstr);
         rec->showTitle = WorkbenchConstants::FALSE_VAL != showstr;
       }
     }
   }
 
   //final IContextService service = (IContextService)page.getWorkbenchWindow().getService(IContextService.class);
   try
   { // one big try block, don't kill me here
 //    // defer context events
 //    if (service != 0)
 //    {
 //      service.activateContext(ContextAuthority.DEFER_EVENTS);
 //    }
 //
 //    HashSet knownActionSetIds = new HashSet();
 //
 //    // Load the always on action sets.
     QList<IMemento::Pointer> actions; // = memento
 //    .getChildren(IWorkbenchConstants.TAG_ALWAYS_ON_ACTION_SET);
 //    for (int x = 0; x < actions.length; x++)
 //    {
 //      String actionSetID = actions[x]
 //      .getString(IWorkbenchConstants.TAG_ID);
 //      final IActionSetDescriptor d = WorkbenchPlugin.getDefault()
 //      .getActionSetRegistry().findActionSet(actionSetID);
 //      if (d != 0)
 //      {
 //        StartupThreading
 //        .runWithoutExceptions(new StartupRunnable()
 //            {
 //              void runWithException() throws Throwable
 //              {
 //                addAlwaysOn(d);
 //              }
 //            });
 //
 //        knownActionSetIds.add(actionSetID);
 //      }
 //    }
 //
 //    // Load the always off action sets.
 //    actions = memento
 //    .getChildren(IWorkbenchConstants.TAG_ALWAYS_OFF_ACTION_SET);
 //    for (int x = 0; x < actions.length; x++)
 //    {
 //      String actionSetID = actions[x]
 //      .getString(IWorkbenchConstants.TAG_ID);
 //      final IActionSetDescriptor d = WorkbenchPlugin.getDefault()
 //      .getActionSetRegistry().findActionSet(actionSetID);
 //      if (d != 0)
 //      {
 //        StartupThreading
 //        .runWithoutExceptions(new StartupRunnable()
 //            {
 //              void runWithException() throws Throwable
 //              {
 //                addAlwaysOff(d);
 //              }
 //            });
 //        knownActionSetIds.add(actionSetID);
 //      }
 //    }
 
     // Load "show view actions".
     actions = memento->GetChildren(WorkbenchConstants::TAG_SHOW_VIEW_ACTION);
     for (int x = 0; x < actions.size(); x++)
     {
       QString id; actions[x]->GetString(WorkbenchConstants::TAG_ID, id);
       showViewShortcuts.push_back(id);
     }
 
 //    // Load "show in times".
 //    actions = memento.getChildren(IWorkbenchConstants.TAG_SHOW_IN_TIME);
 //    for (int x = 0; x < actions.length; x++)
 //    {
 //      String id = actions[x].getString(IWorkbenchConstants.TAG_ID);
 //      String timeStr = actions[x]
 //      .getString(IWorkbenchConstants.TAG_TIME);
 //      if (id != 0 && timeStr != 0)
 //      {
 //        try
 //        {
 //          long time = Long.parseLong(timeStr);
 //          showInTimes.put(id, new Long(time));
 //        }
 //        catch (NumberFormatException e)
 //        {
 //          // skip this one
 //        }
 //      }
 //    }
 
     // Load "show in parts" from registry, not memento
     showInPartIds = this->GetShowInIdsFromRegistry();
 
 //    // Load "new wizard actions".
 //    actions = memento
 //    .getChildren(IWorkbenchConstants.TAG_NEW_WIZARD_ACTION);
 //    newWizardShortcuts = new ArrayList(actions.length);
 //    for (int x = 0; x < actions.length; x++)
 //    {
 //      String id = actions[x].getString(IWorkbenchConstants.TAG_ID);
 //      newWizardShortcuts.add(id);
 //    }
 
     // Load "perspective actions".
     actions = memento->GetChildren(WorkbenchConstants::TAG_PERSPECTIVE_ACTION);
     for (int x = 0; x < actions.size(); x++)
     {
       QString id; actions[x]->GetString(WorkbenchConstants::TAG_ID, id);
       perspectiveShortcuts.push_back(id);
     }
 
 //    ArrayList extActionSets = getPerspectiveExtensionActionSets();
 //    for (int i = 0; i < extActionSets.size(); i++)
 //    {
 //      String actionSetID = (String) extActionSets.get(i);
 //      if (knownActionSetIds.contains(actionSetID))
 //      {
 //        continue;
 //      }
 //      final IActionSetDescriptor d = WorkbenchPlugin.getDefault()
 //      .getActionSetRegistry().findActionSet(actionSetID);
 //      if (d != 0)
 //      {
 //        StartupThreading
 //        .runWithoutExceptions(new StartupRunnable()
 //            {
 //              void runWithException() throws Throwable
 //              {
 //                addAlwaysOn(d);
 //              }
 //            });
 //        knownActionSetIds.add(d.getId());
 //      }
 //    }
 
 //    // Add the visible set of action sets to our knownActionSetIds
 //    // Now go through the registry to ensure we pick up any new action
 //    // sets
 //    // that have been added but not yet considered by this perspective.
 //    ActionSetRegistry reg = WorkbenchPlugin.getDefault()
 //    .getActionSetRegistry();
 //    IActionSetDescriptor[] array = reg.getActionSets();
 //    int count = array.length;
 //    for (int i = 0; i < count; i++)
 //    {
 //      IActionSetDescriptor desc = array[i];
 //      if ((!knownActionSetIds.contains(desc.getId()))
 //          && (desc.isInitiallyVisible()))
 //      {
 //        addActionSet(desc);
 //      }
 //    }
   }
   catch (...)
   {
 //    // restart context changes
 //    if (service != 0)
 //    {
 //      StartupThreading.runWithoutExceptions(new StartupRunnable()
 //          {
 //            void runWithException() throws Throwable
 //            {
 //              service.activateContext(ContextAuthority.SEND_EVENTS);
 //            }
 //          });
 //    }
   }
 
   // Save presentation.
   presentation = pres;
 
   // Hide the editor area if needed. Need to wait for the
   // presentation to be fully setup first.
   int areaVisible = 0;
   bool areaVisibleExists = memento->GetInteger(WorkbenchConstants::TAG_AREA_VISIBLE, areaVisible);
   // Rather than hiding the editors now we must wait until after their
   // controls
   // are created. This ensures that if an editor is instantiated,
   // createPartControl
   // is also called. See bug 20166.
   shouldHideEditorsOnActivate = (areaVisibleExists && areaVisible == 0);
 
 //  // Restore the trim state of the editor area
 //  IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
 //  bool useNewMinMax = preferenceStore.getbool(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX);
 //  if (useNewMinMax)
 //  {
 //    Integer trimStateInt = memento.getInteger(IWorkbenchConstants.TAG_AREA_TRIM_STATE);
 //    if (trimStateInt != 0)
 //    {
 //      editorAreaState = trimStateInt.intValue() & 0x3; // low order two bits contain the state
 //      editorAreaRestoreOnUnzoom = (trimStateInt.intValue() & 4) != 0;
 //    }
 //  }
 
   // restore the fixed state
   int isFixed = 0;
   fixed = (memento->GetInteger(WorkbenchConstants::TAG_FIXED, isFixed) && isFixed == 1);
 
   return true;
 }
 
 QList<QString> Perspective::GetShowInIdsFromRegistry()
 {
   PerspectiveExtensionReader reader;
   QList<QString> tags;
   tags.push_back(WorkbenchRegistryConstants::TAG_SHOW_IN_PART);
   reader.SetIncludeOnlyTags(tags);
   PageLayout::Pointer layout(new PageLayout());
   reader.ExtendLayout(descriptor->GetOriginalId(), layout);
   return layout->GetShowInPartIds();
 }
 
 void Perspective::SaveDesc()
 {
   this->SaveDescAs(descriptor);
 }
 
 void Perspective::SaveDescAs(IPerspectiveDescriptor::Pointer  /*desc*/)
 {
   //TODO Perspective SaveDescAs
 //  PerspectiveDescriptor::Pointer realDesc = desc.Cast<PerspectiveDescriptor>();
 //  //get the layout from the registry
 //  PerspectiveRegistry* perspRegistry = dynamic_cast<PerspectiveRegistry*>(WorkbenchPlugin
 //  ::GetDefault()->GetPerspectiveRegistry());
 //  // Capture the layout state.
 //  XMLMemento memento = XMLMemento.createWriteRoot("perspective");//$NON-NLS-1$
 //  IStatus status = saveState(memento, realDesc, false);
 //  if (status.getSeverity() == IStatus.ERR)
 //  {
 //    ErrorDialog.openError((Shell) 0, WorkbenchMessages.Perspective_problemSavingTitle,
 //        WorkbenchMessages.Perspective_problemSavingMessage,
 //        status);
 //    return;
 //  }
 //  //save it to the preference store
 //  try
 //  {
 //    perspRegistry.saveCustomPersp(realDesc, memento);
 //    descriptor = realDesc;
 //  }
 //  catch (IOException e)
 //  {
 //    perspRegistry.deletePerspective(realDesc);
 //    MessageDialog.openError((Shell) 0, WorkbenchMessages.Perspective_problemSavingTitle,
 //        WorkbenchMessages.Perspective_problemSavingMessage);
 //  }
 }
 
 bool Perspective::SaveState(IMemento::Pointer memento)
 {
 //  MultiStatus result = new MultiStatus(
 //      PlatformUI.PLUGIN_ID,
 //      IStatus.OK,
 //      WorkbenchMessages.Perspective_problemsSavingPerspective, 0);
 //
 //  result.merge(saveState(memento, descriptor, true));
 
   bool result = true;
   result &= this->SaveState(memento, descriptor, true);
 
   return result;
 }
 
 bool Perspective::SaveState(IMemento::Pointer memento, PerspectiveDescriptor::Pointer p,
     bool saveInnerViewState)
 {
 
 //  MultiStatus result = new MultiStatus(
 //      PlatformUI.PLUGIN_ID,
 //      IStatus.OK,
 //      WorkbenchMessages.Perspective_problemsSavingPerspective, 0);
   bool result = true;
 
   if (this->memento)
   {
     memento->PutMemento(this->memento);
     return result;
   }
 
   // Save the version number.
   memento->PutString(WorkbenchConstants::TAG_VERSION, VERSION_STRING);
   //result.add(p.saveState(memento));
   result &= p->SaveState(memento);
   if (!saveInnerViewState)
   {
     Rectangle bounds(page->GetWorkbenchWindow()->GetShell()->GetBounds());
     IMemento::Pointer boundsMem = memento
     ->CreateChild(WorkbenchConstants::TAG_WINDOW);
     boundsMem->PutInteger(WorkbenchConstants::TAG_X, bounds.x);
     boundsMem->PutInteger(WorkbenchConstants::TAG_Y, bounds.y);
     boundsMem->PutInteger(WorkbenchConstants::TAG_HEIGHT, bounds.height);
     boundsMem->PutInteger(WorkbenchConstants::TAG_WIDTH, bounds.width);
   }
 
 //  // Save the "always on" action sets.
 //  Iterator itr = alwaysOnActionSets.iterator();
 //  while (itr.hasNext())
 //  {
 //    IActionSetDescriptor desc = (IActionSetDescriptor) itr.next();
 //    IMemento child = memento
 //    .createChild(IWorkbenchConstants.TAG_ALWAYS_ON_ACTION_SET);
 //    child.putString(IWorkbenchConstants.TAG_ID, desc.getId());
 //  }
 
 //  // Save the "always off" action sets.
 //  itr = alwaysOffActionSets.iterator();
 //  while (itr.hasNext())
 //  {
 //    IActionSetDescriptor desc = (IActionSetDescriptor) itr.next();
 //    IMemento child = memento
 //    .createChild(IWorkbenchConstants.TAG_ALWAYS_OFF_ACTION_SET);
 //    child.putString(IWorkbenchConstants.TAG_ID, desc.getId());
 //  }
 
   // Save "show view actions"
   for (QList<QString>::iterator itr = showViewShortcuts.begin();
       itr != showViewShortcuts.end(); ++itr)
   {
     IMemento::Pointer child = memento
     ->CreateChild(WorkbenchConstants::TAG_SHOW_VIEW_ACTION);
     child->PutString(WorkbenchConstants::TAG_ID, *itr);
   }
 
 //  // Save "show in times"
 //  itr = showInTimes.keySet().iterator();
 //  while (itr.hasNext())
 //  {
 //    String id = (String) itr.next();
 //    Long time = (Long) showInTimes.get(id);
 //    IMemento child = memento
 //    .createChild(IWorkbenchConstants.TAG_SHOW_IN_TIME);
 //    child.putString(IWorkbenchConstants.TAG_ID, id);
 //    child.putString(IWorkbenchConstants.TAG_TIME, time.toString());
 //  }
 
 //  // Save "new wizard actions".
 //  itr = newWizardShortcuts.iterator();
 //  while (itr.hasNext())
 //  {
 //    String str = (String) itr.next();
 //    IMemento child = memento
 //    .createChild(IWorkbenchConstants.TAG_NEW_WIZARD_ACTION);
 //    child.putString(IWorkbenchConstants.TAG_ID, str);
 //  }
 
   // Save "perspective actions".
   for (QList<QString>::iterator itr = perspectiveShortcuts.begin();
       itr != perspectiveShortcuts.end(); ++itr)
   {
     IMemento::Pointer child = memento
     ->CreateChild(WorkbenchConstants::TAG_PERSPECTIVE_ACTION);
     child->PutString(WorkbenchConstants::TAG_ID, *itr);
   }
 
   // Get visible views.
   QList<PartPane::Pointer> viewPanes;
   presentation->CollectViewPanes(viewPanes);
 
   // Save the views.
   for (QList<PartPane::Pointer>::iterator itr = viewPanes.begin();
       itr != viewPanes.end(); ++itr)
   {
     IWorkbenchPartReference::Pointer ref((*itr)->GetPartReference());
     IViewDescriptor::Pointer desc = page->GetViewFactory()->GetViewRegistry()
           ->Find(ref->GetId());
     if(desc && desc->IsRestorable())
     {
       IMemento::Pointer viewMemento = memento
       ->CreateChild(WorkbenchConstants::TAG_VIEW);
       viewMemento->PutString(WorkbenchConstants::TAG_ID, ViewFactory::GetKey(ref.Cast<IViewReference>()));
     }
   }
 
 //  // save all fastview state
 //  if (fastViewManager != 0)
 //  fastViewManager.saveState(memento);
 
   // Save the view layout recs.
   for (QHash<QString, ViewLayoutRec::Pointer>::iterator i = mapIDtoViewLayoutRec.begin();
       i != mapIDtoViewLayoutRec.end(); ++i)
   {
     QString compoundId(i.key());
     ViewLayoutRec::Pointer rec(i.value());
     if (rec && (!rec->isCloseable || !rec->isMoveable || rec->isStandalone))
     {
       IMemento::Pointer layoutMemento(memento
       ->CreateChild(WorkbenchConstants::TAG_VIEW_LAYOUT_REC));
       layoutMemento->PutString(WorkbenchConstants::TAG_ID, compoundId);
       if (!rec->isCloseable)
       {
         layoutMemento->PutString(WorkbenchConstants::TAG_CLOSEABLE,
             WorkbenchConstants::FALSE_VAL);
       }
       if (!rec->isMoveable)
       {
         layoutMemento->PutString(WorkbenchConstants::TAG_MOVEABLE,
             WorkbenchConstants::FALSE_VAL);
       }
       if (rec->isStandalone)
       {
         layoutMemento->PutString(WorkbenchConstants::TAG_STANDALONE,
             WorkbenchConstants::TRUE_VAL);
         layoutMemento->PutString(WorkbenchConstants::TAG_SHOW_TITLE,
             rec->showTitle ? WorkbenchConstants::TRUE_VAL : WorkbenchConstants::FALSE_VAL);
       }
     }
   }
 
   // Save the layout.
   IMemento::Pointer childMem(memento->CreateChild(WorkbenchConstants::TAG_LAYOUT));
   //result.add(presentation.saveState(childMem));
   result &= presentation->SaveState(childMem);
 
   // Save the editor visibility state
   if (this->IsEditorAreaVisible())
   {
     memento->PutInteger(WorkbenchConstants::TAG_AREA_VISIBLE, 1);
   }
   else
   {
     memento->PutInteger(WorkbenchConstants::TAG_AREA_VISIBLE, 0);
   }
 
 //  // Save the trim state of the editor area if using the new min/max
 //  IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
 //  bool useNewMinMax = preferenceStore.getbool(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX);
 //  if (useNewMinMax)
 //  {
 //    int trimState = editorAreaState;
 //    trimState |= editorAreaRestoreOnUnzoom ? 4 : 0;
 //    memento.putInteger(IWorkbenchConstants.TAG_AREA_TRIM_STATE, trimState);
 //  }
 
   // Save the fixed state
   if (fixed)
   {
     memento->PutInteger(WorkbenchConstants::TAG_FIXED, 1);
   }
   else
   {
     memento->PutInteger(WorkbenchConstants::TAG_FIXED, 0);
   }
 
   return result;
 }
 
 void Perspective::SetPerspectiveActionIds(const QList<QString>& list)
 {
   perspectiveShortcuts = list;
 }
 
 void Perspective::SetShowInPartIds(const QList<QString>& list)
 {
   showInPartIds = list;
 }
 
 void Perspective::SetShowViewActionIds(const QList<QString>& list)
 {
   showViewShortcuts = list;
 }
 
 void Perspective::ShowEditorArea()
 {
   if (this->IsEditorAreaVisible())
   {
     return;
   }
 
   editorHidden = false;
 
   // Show the editor in the appropriate location
   if (this->UseNewMinMax(Perspective::Pointer(this)))
   {
     bool isMinimized = editorAreaState == IStackPresentationSite::STATE_MINIMIZED;
     if (!isMinimized)
     {
       // If the editor area is going to show then we have to restore
 //      if (getPresentation().getMaximizedStack() != 0)
 //      getPresentation().getMaximizedStack().setState(IStackPresentationSite.STATE_RESTORED);
 
       this->ShowEditorAreaLocal();
     }
 //    else
 //    setEditorAreaTrimVisibility(true);
   }
   else
   {
     this->ShowEditorAreaLocal();
   }
 }
 
 void Perspective::ShowEditorAreaLocal()
 {
   if (editorHolder == 0 || editorHidden)
   {
     return;
   }
 
   // Replace the part holder with the editor area.
   presentation->GetLayout()->Replace(editorHolder, editorArea);
   editorHolder = 0;
 }
 
 void Perspective::SetEditorAreaState(int newState)
 {
   if (newState == editorAreaState)
   return;
 
   editorAreaState = newState;
 
 //  // reset the restore flag if we're not minimized
 //  if (newState != IStackPresentationSite::STATE_MINIMIZED)
 //  editorAreaRestoreOnUnzoom = false;
 
   this->RefreshEditorAreaVisibility();
 }
 
 int Perspective::GetEditorAreaState()
 {
   return editorAreaState;
 }
 
 void Perspective::RefreshEditorAreaVisibility()
 {
   // Nothing shows up if the editor area isn't visible at all
   if (editorHidden)
   {
     this->HideEditorAreaLocal();
     //setEditorAreaTrimVisibility(false);
     return;
   }
 
   PartStack::Pointer editorStack = editorArea.Cast<EditorSashContainer>()->GetUpperRightEditorStack();
   if (editorStack == 0)
   return;
 
   // Whatever we're doing, make the current editor stack match it
   //editorStack->SetStateLocal(editorAreaState);
 
   // If it's minimized then it's in the trim
   if (editorAreaState == IStackPresentationSite::STATE_MINIMIZED)
   {
     // Hide the editor area and show its trim
     this->HideEditorAreaLocal();
     //setEditorAreaTrimVisibility(true);
   }
   else
   {
     // Show the editor area and hide its trim
     //setEditorAreaTrimVisibility(false);
     this->ShowEditorAreaLocal();
 
 //    if (editorAreaState == IStackPresentationSite::STATE_MAXIMIZED)
 //    getPresentation().setMaximizedStack(editorStack);
   }
 }
 
 IViewReference::Pointer Perspective::GetViewReference(const QString& viewId, const QString& secondaryId)
 {
   IViewReference::Pointer ref = page->FindViewReference(viewId, secondaryId);
   if (ref == 0)
   {
     ViewFactory* factory = this->GetViewFactory();
     try
     {
       ref = factory->CreateView(viewId, secondaryId);
     }
     catch (PartInitException& /*e*/)
     {
 //      IStatus status = StatusUtil.newStatus(IStatus.ERR,
 //          e.getMessage() == 0 ? "" : e.getMessage(), //$NON-NLS-1$
 //          e);
 //      StatusUtil.handleStatus(status, "Failed to create view: id=" + viewId, //$NON-NLS-1$
 //          StatusManager.LOG);
       //TODO Perspective status message
       WorkbenchPlugin::Log("Failed to create view: id=" + viewId);
     }
   }
   return ref;
 }
 
 IViewPart::Pointer Perspective::ShowView(const QString& viewId, const QString& secondaryId)
 {
   ViewFactory* factory = this->GetViewFactory();
   IViewReference::Pointer ref = factory->CreateView(viewId, secondaryId);
   IViewPart::Pointer part = ref->GetPart(true).Cast<IViewPart>();
   if (part == 0)
   {
     throw PartInitException("Could not create view: " + ref->GetId());
   }
   PartSite::Pointer site = part->GetSite().Cast<PartSite>();
   PartPane::Pointer pane = site->GetPane();
 
   //TODO Perspective preference store
 //  IPreferenceStore store = WorkbenchPlugin.getDefault()
 //  .getPreferenceStore();
 //  int openViewMode = store.getInt(IPreferenceConstants.OPEN_VIEW_MODE);
 //
 //  if (openViewMode == IPreferenceConstants.OVM_FAST &&
 //      fastViewManager != 0)
 //  {
 //    fastViewManager.addViewReference(FastViewBar.FASTVIEWBAR_ID, -1, ref, true);
 //    setActiveFastView(ref);
 //  }
 //  else if (openViewMode == IPreferenceConstants.OVM_FLOAT
 //      && presentation.canDetach())
 //  {
 //    presentation.addDetachedPart(pane);
 //  }
 //  else
 //  {
     if (this->UseNewMinMax(Perspective::Pointer(this)))
     {
       // Is this view going to show in the trim?
  //     LayoutPart vPart = presentation.findPart(viewId, secondaryId);
 
       // Determine if there is a trim stack that should get the view
       QString trimId;
 
 //      // If we can locate the correct trim stack then do so
 //      if (vPart != 0)
 //      {
 //        String id = 0;
 //        ILayoutContainer container = vPart.getContainer();
 //        if (container.Cast<ContainerPlaceholder>() != 0)
 //        id = ((ContainerPlaceholder)container).getID();
 //        else if (container.Cast<ViewStack>() != 0)
 //        id = ((ViewStack)container).getID();
 //
 //        // Is this place-holder in the trim?
 //        if (id != 0 && fastViewManager.getFastViews(id).size()> 0)
 //        {
 //          trimId = id;
 //        }
 //      }
 //
 //      // No explicit trim found; If we're maximized then we either have to find an
 //      // arbitrary stack...
 //      if (trimId == 0 && presentation.getMaximizedStack() != 0)
 //      {
 //        if (vPart == 0)
 //        {
 //          ViewStackTrimToolBar blTrimStack = fastViewManager.getBottomRightTrimStack();
 //          if (blTrimStack != 0)
 //          {
 //            // OK, we've found a trim stack to add it to...
 //            trimId = blTrimStack.getId();
 //
 //            // Since there was no placeholder we have to add one
 //            LayoutPart blPart = presentation.findPart(trimId, 0);
 //            if (blPart.Cast<ContainerPlaceholder>() != 0)
 //            {
 //              ContainerPlaceholder cph = (ContainerPlaceholder) blPart;
 //              if (cph.getRealContainer().Cast<ViewStack>() != 0)
 //              {
 //                ViewStack vs = (ViewStack) cph.getRealContainer();
 //
 //                // Create a 'compound' id if this is a multi-instance part
 //                String compoundId = ref.getId();
 //                if (ref.getSecondaryId() != 0)
 //                compoundId = compoundId + ':' + ref.getSecondaryId();
 //
 //                // Add the new placeholder
 //                vs.add(new PartPlaceholder(compoundId));
 //              }
 //            }
 //          }
 //        }
 //      }
 //
 //      // If we have a trim stack located then add the view to it
 //      if (trimId != "")
 //      {
 //        fastViewManager.addViewReference(trimId, -1, ref, true);
 //      }
 //      else
 //      {
 //        bool inMaximizedStack = vPart != 0 && vPart.getContainer() == presentation.getMaximizedStack();
 
         // Do the default behavior
         presentation->AddPart(pane);
 
 //        // Now, if we're maximized then we have to minimize the new stack
 //        if (presentation.getMaximizedStack() != 0 && !inMaximizedStack)
 //        {
 //          vPart = presentation.findPart(viewId, secondaryId);
 //          if (vPart != 0 && vPart.getContainer().Cast<ViewStack>() != 0)
 //          {
 //            ViewStack vs = (ViewStack)vPart.getContainer();
 //            vs.setState(IStackPresentationSite.STATE_MINIMIZED);
 //
 //            // setting the state to minimized will create the trim toolbar
 //            // so we don't need a 0 pointer check here...
 //            fastViewManager.getViewStackTrimToolbar(vs.getID()).setRestoreOnUnzoom(true);
 //          }
 //        }
   //    }
     }
     else
     {
       presentation->AddPart(pane);
     }
   //}
 
   // Ensure that the newly showing part is enabled
   if (pane != 0 && pane->GetControl() != 0)
   Tweaklets::Get(GuiWidgetsTweaklet::KEY)->SetEnabled(pane->GetControl(), true);
 
   return part;
 }
 
 IWorkbenchPartReference::Pointer Perspective::GetOldPartRef()
 {
   return oldPartRef;
 }
 
 void Perspective::SetOldPartRef(IWorkbenchPartReference::Pointer oldPartRef)
 {
   this->oldPartRef = oldPartRef;
 }
 
 bool Perspective::IsCloseable(IViewReference::Pointer reference)
 {
   ViewLayoutRec::Pointer rec = this->GetViewLayoutRec(reference, false);
   if (rec != 0)
   {
     return rec->isCloseable;
   }
   return true;
 }
 
 bool Perspective::IsMoveable(IViewReference::Pointer reference)
 {
   ViewLayoutRec::Pointer rec = this->GetViewLayoutRec(reference, false);
   if (rec != 0)
   {
     return rec->isMoveable;
   }
   return true;
 }
 
 void Perspective::DescribeLayout(QString& buf) const
 {
 //  QList<IViewReference::Pointer> fastViews = getFastViews();
 //
 //  if (fastViews.length != 0)
 //  {
 //    buf.append("fastviews ("); //$NON-NLS-1$
 //    for (int idx = 0; idx < fastViews.length; idx++)
 //    {
 //      IViewReference ref = fastViews[idx];
 //
 //      if (idx> 0)
 //      {
 //        buf.append(", "); //$NON-NLS-1$
 //      }
 //
 //      buf.append(ref.getPartName());
 //    }
 //    buf.append("), "); //$NON-NLS-1$
 //  }
 
   this->GetPresentation()->DescribeLayout(buf);
 }
 
 void Perspective::TestInvariants()
 {
   this->GetPresentation()->GetLayout()->TestInvariants();
 }
 
 bool Perspective::UseNewMinMax(Perspective::Pointer activePerspective)
 {
   // We need to have an active perspective
   if (activePerspective == 0)
   return false;
 
   // We need to have a trim manager (if we don't then we
   // don't create a FastViewManager because it'd be useless)
  // if (activePerspective->GetFastViewManager() == 0)
  // return false;
 
   // Make sure we don't NPE anyplace
   WorkbenchWindow::Pointer wbw = activePerspective->page->GetWorkbenchWindow().Cast<WorkbenchWindow>();
   if (wbw == 0)
   return false;
 
 //  WorkbenchWindowConfigurer* configurer = wbw->GetWindowConfigurer();
 //  if (configurer == 0)
 //  return false;
 
   IPresentationFactory* factory = WorkbenchPlugin::GetDefault()->GetPresentationFactory();
   if (factory == 0)
   return false;
 
   // Ok, we should be good to go, return the pref
   //IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
   //bool useNewMinMax = preferenceStore.getbool(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX);
   return true;
 }
 
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtMessageDialogTweaklet.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtMessageDialogTweaklet.cpp
deleted file mode 100644
index c08e13a275..0000000000
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtMessageDialogTweaklet.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-/*===================================================================
-
-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 "berryQtMessageDialogTweaklet.h"
-
-#include <QMessageBox>
-#include <map>
-
-namespace berry
-{
-
-class QtDialog: public IDialog
-{
-private:
-  QMessageBox msgBox;
-  QHash<QAbstractButton*, std::size_t> mapButtonToIndex;
-
-public:
-
-  QtDialog(Shell::Pointer, const QString& dialogTitle,
-      void* /*dialogTitleImage*/, const QString& dialogMessage,
-      int dialogImageType, const QList<QString>& dialogButtonLabels,
-      int defaultIndex)
-  {
-    msgBox.setWindowTitle(dialogTitle);
-    msgBox.setText(dialogMessage);
-
-    if (dialogImageType == IDialog::ERR)
-      msgBox.setIcon(QMessageBox::Critical);
-    else if (dialogImageType == IDialog::INFORMATION)
-      msgBox.setIcon(QMessageBox::Information);
-    else if (dialogImageType == IDialog::QUESTION)
-      msgBox.setIcon(QMessageBox::Question);
-    else if (dialogImageType == IDialog::WARNING)
-      msgBox.setIcon(QMessageBox::Warning);
-
-
-    QPushButton* defaultButton(NULL);
-    for (int i = 0; i < dialogButtonLabels.size(); ++i)
-    {
-      QPushButton* button = msgBox.addButton(dialogButtonLabels[i],
-                                             QMessageBox::ActionRole);
-      mapButtonToIndex[(QAbstractButton*)button] = i;
-      if (i == (std::size_t)defaultIndex)
-        defaultButton = button;
-    }
-
-    msgBox.setDefaultButton(defaultButton);
-  }
-
-  int Open()
-  {
-    msgBox.exec();
-    return static_cast<int>(mapButtonToIndex[msgBox.clickedButton()]);
-  }
-};
-
-QtMessageDialogTweaklet::QtMessageDialogTweaklet()
-{
-
-}
-
-bool QtMessageDialogTweaklet::OpenConfirm(Shell::Pointer,
-    const QString& title, const QString& message)
-{
-  QMessageBox msgBox;
-  msgBox.setWindowTitle(title);
-  msgBox.setText(message);
-  msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
-  msgBox.setDefaultButton(QMessageBox::Cancel);
-  msgBox.setEscapeButton(QMessageBox::Cancel);
-  return msgBox.exec() == QMessageBox::Ok;
-}
-
-void QtMessageDialogTweaklet::OpenError(Shell::Pointer,
-    const QString& title, const QString& message)
-{
-  QMessageBox msgBox;
-  msgBox.setWindowTitle(title);
-  msgBox.setText(message);
-  msgBox.setStandardButtons(QMessageBox::Ok);
-  msgBox.setDefaultButton(QMessageBox::Ok);
-  msgBox.setEscapeButton(QMessageBox::Ok);
-  msgBox.setIcon(QMessageBox::Critical);
-  msgBox.exec();
-}
-
-void QtMessageDialogTweaklet::OpenInformation(Shell::Pointer,
-    const QString& title, const QString& message)
-{
-  QMessageBox msgBox;
-  msgBox.setWindowTitle(title);
-  msgBox.setText(message);
-  msgBox.setStandardButtons(QMessageBox::Ok);
-  msgBox.setDefaultButton(QMessageBox::Ok);
-  msgBox.setEscapeButton(QMessageBox::Ok);
-  msgBox.setIcon(QMessageBox::Information);
-  msgBox.exec();
-}
-
-bool QtMessageDialogTweaklet::OpenQuestion(Shell::Pointer,
-    const QString& title, const QString& message)
-{
-  QMessageBox msgBox;
-  msgBox.setWindowTitle(title);
-  msgBox.setText(message);
-  msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
-  msgBox.setDefaultButton(QMessageBox::No);
-  msgBox.setEscapeButton(QMessageBox::No);
-  msgBox.setIcon(QMessageBox::Question);
-  return msgBox.exec() == QMessageBox::Yes;
-}
-
-void QtMessageDialogTweaklet::OpenWarning(Shell::Pointer,
-    const QString& title, const QString& message)
-{
-  QMessageBox msgBox;
-  msgBox.setWindowTitle(title);
-  msgBox.setText(message);
-  msgBox.setStandardButtons(QMessageBox::Ok);
-  msgBox.setDefaultButton(QMessageBox::Ok);
-  msgBox.setEscapeButton(QMessageBox::Ok);
-  msgBox.setIcon(QMessageBox::Warning);
-  msgBox.exec();
-}
-
-IDialog::Pointer QtMessageDialogTweaklet::MessageDialog(
-    Shell::Pointer parentShell, const QString& dialogTitle,
-    void* dialogTitleImage, const QString& dialogMessage,
-    int dialogImageType, const QList<QString>& dialogButtonLabels,
-    int defaultIndex)
-{
-  IDialog::Pointer dialog(new QtDialog(parentShell, dialogTitle,
-      dialogTitleImage, dialogMessage, dialogImageType, dialogButtonLabels,
-      defaultIndex));
-  return dialog;
-}
-
-}
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtMessageDialogTweaklet.h b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtMessageDialogTweaklet.h
deleted file mode 100644
index dc063a2b5c..0000000000
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtMessageDialogTweaklet.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*===================================================================
-
-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 BERRYQTMESSAGEDIALOGTWEAKLET_H_
-#define BERRYQTMESSAGEDIALOGTWEAKLET_H_
-
-#include <berryMessageDialogTweaklet.h>
-
-namespace berry
-{
-
-class QtMessageDialogTweaklet: public QObject, public MessageDialogTweaklet
-{
-  Q_OBJECT
-  Q_INTERFACES(berry::MessageDialogTweaklet)
-
-public:
-
-  QtMessageDialogTweaklet();
-
-  bool OpenConfirm(Shell::Pointer, const QString& title,
-      const QString& message);
-  void OpenError(Shell::Pointer, const QString& title,
-      const QString& message);
-  void OpenInformation(Shell::Pointer, const QString& title,
-      const QString& message);
-  bool OpenQuestion(Shell::Pointer, const QString& title,
-      const QString& message);
-  void OpenWarning(Shell::Pointer, const QString& title,
-      const QString& message);
-
-  IDialog::Pointer MessageDialog(Shell::Pointer parentShell,
-      const QString& dialogTitle, void* dialogTitleImage,
-      const QString& dialogMessage, int dialogImageType, const QList<
-          QString>& dialogButtonLabels, int defaultIndex);
-
-};
-
-}
-
-#endif /* BERRYQTMESSAGEDIALOGTWEAKLET_H_ */
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp
index 1b6f7e163a..946c9980d2 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.cpp
@@ -1,43 +1,39 @@
 /*===================================================================
 
 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 "berryQtShowViewDialog.h"
 
 namespace berry {
 
-QtShowViewDialog::QtShowViewDialog(IViewRegistry*  /*registry*/, QWidget* parent, Qt::WindowFlags f)
-: QDialog(parent, f)
+QtShowViewDialog::QtShowViewDialog(const IWorkbenchWindow* window, IViewRegistry* registry,
+                                   QWidget* parent, Qt::WindowFlags f)
+  : QDialog(parent, f)
+  , m_Window(window)
+  , m_ViewReg(registry)
 {
   m_UserInterface.setupUi(this);
 }
 
-int QtShowViewDialog::Open()
-{
-  int returnCode = this->exec();
-  if (returnCode == QDialog::Accepted)
-    return IShowViewDialog::OK;
-  else return IShowViewDialog::CANCEL;
-}
 
 QList<IViewDescriptor::Pointer>
-QtShowViewDialog::GetSelection()
+QtShowViewDialog::GetSelection() const
 {
   QList<IViewDescriptor::Pointer> selected;
 
   return selected;
 }
 
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.h b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.h
index a3d339487a..57f3c763f7 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.h
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtShowViewDialog.h
@@ -1,53 +1,54 @@
 /*===================================================================
 
 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 BERRYQTSHOWVIEWDIALOG_H_
 #define BERRYQTSHOWVIEWDIALOG_H_
 
 #ifdef __MINGW32__
 // We need to inlclude winbase.h here in order to declare
 // atomic intrinsics like InterlockedIncrement correctly.
 // Otherwhise, they would be declared wrong within qatomic_windows.h .
 #include <windows.h>
 #endif
 
 #include <QDialog>
 
 #include <berryIViewRegistry.h>
-#include <berryIShowViewDialog.h>
 
 #include "ui_berryQtShowViewDialog.h"
 
 namespace berry {
 
-class QtShowViewDialog : public QDialog, public IShowViewDialog
+class QtShowViewDialog : public QDialog
 {
+
 public:
-  berryObjectMacro(QtShowViewDialog);
 
-  QtShowViewDialog(IViewRegistry* registry, QWidget* parent = 0, Qt::WindowFlags f = 0);
+  QtShowViewDialog(const IWorkbenchWindow* window, IViewRegistry* registry,
+                   QWidget* parent = 0, Qt::WindowFlags f = 0);
 
-  QList<IViewDescriptor::Pointer> GetSelection();
-  int Open();
+  QList<IViewDescriptor::Pointer> GetSelection() const;
 
-protected:
+private:
 
+  const IWorkbenchWindow* m_Window;
+  IViewRegistry* m_ViewReg;
   Ui::QtShowViewDialog_ m_UserInterface;
 };
 
 }
 
 #endif /*BERRYQTSHOWVIEWDIALOG_H_*/
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtWorkbenchTweaklet.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtWorkbenchTweaklet.cpp
index f9b929f42a..f2c09d228c 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtWorkbenchTweaklet.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtWorkbenchTweaklet.cpp
@@ -1,59 +1,41 @@
 
 /*===================================================================
 
 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 "berryQtWorkbenchTweaklet.h"
-#include <internal/berryQtControlWidget.h>
 
 #include <QApplication>
-#include <QMainWindow>
 
-#include "berryQtShowViewDialog.h"
 #include "berryQtDisplay.h"
 
-#include <berryPlatform.h>
-#include <berryPlatformUI.h>
-
-#include <internal/berryWorkbenchWindow.h>
-
 namespace berry {
 
 QtWorkbenchTweaklet::QtWorkbenchTweaklet()
 {
 
 }
 
 Display* QtWorkbenchTweaklet::CreateDisplay()
 {
   return new QtDisplay();
 }
 
 bool QtWorkbenchTweaklet::IsRunning()
 {
   return QApplication::instance() != 0;
 }
 
-IDialog::Pointer
-QtWorkbenchTweaklet::CreateStandardDialog(const QString& dialogid)
-{
-  if (dialogid == DIALOG_ID_SHOW_VIEW)
-    return IDialog::Pointer(new QtShowViewDialog(PlatformUI::GetWorkbench()->GetViewRegistry()));
-  else
-    return IDialog::Pointer(0);
-}
-
-
 }  // namespace berry
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtWorkbenchTweaklet.h b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtWorkbenchTweaklet.h
index cf063650ee..90365ba2c1 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtWorkbenchTweaklet.h
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtWorkbenchTweaklet.h
@@ -1,47 +1,45 @@
 /*===================================================================
 
 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 BERRYQTWORKBENCHTWEAKLET_H_
 #define BERRYQTWORKBENCHTWEAKLET_H_
 
 #include <berryWorkbenchTweaklet.h>
 
 #include <org_blueberry_ui_qt_Export.h>
 
 namespace berry {
 
 class BERRY_UI_QT QtWorkbenchTweaklet : public QObject, public WorkbenchTweaklet
 {
   Q_OBJECT
   Q_INTERFACES(berry::WorkbenchTweaklet)
 
 public:
 
   berryObjectMacro(QtWorkbenchTweaklet)
 
   QtWorkbenchTweaklet();
 
   Display* CreateDisplay();
 
   bool IsRunning();
 
-  IDialog::Pointer CreateStandardDialog(const QString& id);
-
 };
 
 } // namespace berry
 
 #endif /*BERRYQTWORKBENCHTWEAKLET_H_*/
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryShowViewMenu.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryShowViewMenu.cpp
index 37dc46bd3d..b8a370c728 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryShowViewMenu.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryShowViewMenu.cpp
@@ -1,285 +1,268 @@
 /*===================================================================
 
 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 "berryShowViewMenu.h"
 
 #include <berryMenuManager.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
 #include <berryCommandContributionItem.h>
 #include <berrySeparator.h>
 #include <berryIPluginContribution.h>
 #include <berryIViewRegistry.h>
 #include <berryIWorkbenchCommandConstants.h>
 #include <berryObjectString.h>
 
 #include "berryCommandContributionItemParameter.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryViewDescriptor.h"
 #include "intro/berryIntroConstants.h"
 
 #include <QMenu>
 #include <QSet>
 #include <QPair>
 
 namespace berry {
 
 struct ActionComparator {
   bool operator()(const CommandContributionItemParameter::Pointer& p1,
                   const CommandContributionItemParameter::Pointer& p2) const
   {
     return p1->label < p2->label;
   }
 };
 
 ShowViewMenu::ShowViewMenu(IWorkbenchWindow *window, const QString& id)
   : ContributionItem(id), dirty(true), window(window)
 {
-//  final IHandlerService handlerService = (IHandlerService) window
-//      .getService(IHandlerService.class);
-//  final ICommandService commandService = (ICommandService) window
-//      .getService(ICommandService.class);
-//  final ParameterizedCommand cmd = getCommand(commandService, makeFast);
-
-//  showDlgAction = new Action(WorkbenchMessages.ShowView_title) {
-//    public void run() {
-//      try {
-//        handlerService.executeCommand(cmd, null);
-//      } catch (final ExecutionException e) {
-//        // Do nothing.
-//      } catch (NotDefinedException e) {
-//        // Do nothing.
-//      } catch (NotEnabledException e) {
-//        // Do nothing.
-//      } catch (NotHandledException e) {
-//        // Do nothing.
-//      }
-//    }
-//  };
+  CommandContributionItemParameter::Pointer showDlgItemParms(
+        new CommandContributionItemParameter(
+          window, QString::null, IWorkbenchCommandConstants::VIEWS_SHOW_VIEW,
+          CommandContributionItem::STYLE_PUSH));
+  showDlgItemParms->label = "&Other...";
+  showDlgItem = new CommandContributionItem(showDlgItemParms);
 
 //  window.getWorkbench().getHelpSystem().setHelp(showDlgAction,
 //      IWorkbenchHelpContextIds.SHOW_VIEW_OTHER_ACTION);
 //  // indicate that a show views submenu has been created
 //  if (window instanceof WorkbenchWindow) {
 //    ((WorkbenchWindow) window)
 //        .addSubmenu(WorkbenchWindow.SHOW_VIEW_SUBMENU);
 //  }
 
-//  showDlgAction.setActionDefinitionId(IWorkbenchCommandConstants.VIEWS_SHOW_VIEW);
-
 }
 
 bool ShowViewMenu::IsDirty() const
 {
   return dirty;
 }
 
 /**
  * Overridden to always return true and force dynamic menu building.
  */
 bool ShowViewMenu::IsDynamic() const
 {
   return true;
 }
 
 QAction* ShowViewMenu::Fill(QMenu* menu, QAction* before)
 {
 //  if (MenuManager::Pointer mm = GetParent().Cast<MenuManager>())
 //  {
 //    mm->AddMenuListener(menuListener);
 //  }
 
   if (!dirty)
   {
     return 0;
   }
 
   MenuManager::Pointer manager(new MenuManager());
   FillMenu(manager.GetPointer());
 
   QList<IContributionItem::Pointer> items = manager->GetItems();
   if (items.size() == 0)
   {
     QAction* action = new QAction("No Views registered", menu);
     action->setEnabled(false);
     menu->insertAction(before, action);
   }
   else
   {
     foreach (IContributionItem::Pointer item, items)
     {
       before = item->Fill(menu, before);
     }
   }
 
   dirty = false;
   return before;
 }
 
 void ShowViewMenu::FillMenu(IMenuManager* innerMgr)
 {
   // Remove all.
   innerMgr->RemoveAll();
 
   // If no page disable all.
   IWorkbenchPage::Pointer page = window->GetActivePage();
   if (page.IsNull())
   {
     return;
   }
 
   // If no active perspective disable all
   if (page->GetPerspective().IsNull())
   {
     return;
   }
 
   typedef QPair<QString,QString> ViewIdPair;
 
   // Get visible actions.
   QSet<ViewIdPair> viewIds = GetShortcuts(page.GetPointer());
 
   // add all open views
   viewIds = AddOpenedViews(page.GetPointer(), viewIds);
 
   QList<CommandContributionItemParameter::Pointer> actions;
 
   foreach (ViewIdPair id, viewIds)
   {
     if (id.first == IntroConstants::INTRO_VIEW_ID)
     {
       continue;
     }
     CommandContributionItemParameter::Pointer item = GetItem(id.first, id.second);
     if (item)
     {
       actions.append(item);
     }
   }
   qSort(actions.begin(), actions.end(), ActionComparator());
   foreach (CommandContributionItemParameter::Pointer ccip, actions)
   {
 //    if (WorkbenchActivityHelper.filterItem(ccip)) {
 //      continue;
 //    }
     CommandContributionItem::Pointer item(new CommandContributionItem(ccip));
     innerMgr->Add(item);
   }
 
   // We only want to add the separator if there are show view shortcuts,
   // otherwise, there will be a separator and then the 'Other...' entry
   // and that looks weird as the separator is separating nothing
   if (!innerMgr->IsEmpty())
   {
     IContributionItem::Pointer separator(new Separator());
     innerMgr->Add(separator);
   }
 
   // Add Other...
-  //innerMgr->Add(showDlgAction);
+  innerMgr->Add(showDlgItem);
 }
 
 QSet<QPair<QString,QString> > ShowViewMenu::GetShortcuts(IWorkbenchPage* page) const
 {
   QSet<QPair<QString,QString> > list;
   QList<QString> shortcuts(page->GetShowViewShortcuts());
   for (int i = 0; i < shortcuts.size(); ++i)
   {
     list.insert(qMakePair(shortcuts[i], QString()));
   }
   return list;
 }
 
 CommandContributionItemParameter::Pointer ShowViewMenu::GetItem(const QString& viewId, const QString& secondaryId) const
 {
   IViewRegistry* reg = WorkbenchPlugin::GetDefault()->GetViewRegistry();
   IViewDescriptor::Pointer desc = reg->Find(viewId);
   if (desc.IsNull())
   {
     return CommandContributionItemParameter::Pointer(0);
   }
   QString label = desc->GetLabel();
 
   class PluginCCIP : public CommandContributionItemParameter, public IPluginContribution
   {
     QString localId;
     QString pluginId;
 
   public:
     PluginCCIP(const IViewDescriptor::Pointer& v, IServiceLocator* serviceLocator,
                const QString& id, const QString& commandId, CommandContributionItem::Style style)
       : CommandContributionItemParameter(serviceLocator, id, commandId, style)
     {
       ViewDescriptor::Pointer vd = v.Cast<ViewDescriptor>();
       localId = vd->GetLocalId();
       pluginId = vd->GetPluginId();
     }
 
     QString GetLocalId() const
     {
       return localId;
     }
 
     QString GetPluginId() const
     {
       return pluginId;
     }
   };
 
   CommandContributionItemParameter::Pointer parms(new PluginCCIP(desc,
       window, viewId, IWorkbenchCommandConstants::VIEWS_SHOW_VIEW,
       CommandContributionItem::STYLE_PUSH));
   parms->label = label;
   QIcon icon(*(reinterpret_cast<QIcon*>(desc->GetImageDescriptor()->CreateImage())));
   parms->icon = icon;
 
   Object::Pointer strViewId(new ObjectString(viewId));
   parms->parameters.insert(IWorkbenchCommandConstants::VIEWS_SHOW_VIEW_PARM_ID, strViewId);
 //  if (makeFast)
 //  {
 //    parms.parameters.put(
 //        IWorkbenchCommandConstants.VIEWS_SHOW_VIEW_PARM_FASTVIEW,
 //        "true"); //$NON-NLS-1$
 //  }
   if (!secondaryId.isEmpty())
   {
     Object::Pointer strSecondaryId(new ObjectString(secondaryId));
     parms->parameters.insert(IWorkbenchCommandConstants::VIEWS_SHOW_VIEW_SECONDARY_ID,
                             strSecondaryId);
   }
   return parms;
 }
 
 QSet<QPair<QString,QString> > ShowViewMenu::AddOpenedViews(IWorkbenchPage* page,
                                                            QSet<QPair<QString,QString> >& actions) const
 {
   QSet<QPair<QString,QString> > views = GetParts(page);
   return views.unite(actions);
 }
 
 QSet<QPair<QString,QString> > ShowViewMenu::GetParts(IWorkbenchPage* page) const
 {
   QSet<QPair<QString,QString> > parts;
   QList<IViewReference::Pointer> refs = page->GetViewReferences();
   for (int i = 0; i < refs.size(); ++i)
   {
     parts.insert(qMakePair(refs[i]->GetId(), refs[i]->GetSecondaryId()));
   }
   return parts;
 }
 
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryShowViewMenu.h b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryShowViewMenu.h
index 5c7b6d1c6a..400633eeb9 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryShowViewMenu.h
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryShowViewMenu.h
@@ -1,124 +1,124 @@
 /*===================================================================
 
 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 BERRYSHOWVIEWMENU_H
 #define BERRYSHOWVIEWMENU_H
 
 #include <berryContributionItem.h>
 
 #include <QPair>
 
 namespace berry {
 
 struct IWorkbenchPage;
 struct IWorkbenchWindow;
 struct IMenuManager;
 
 class CommandContributionItemParameter;
 
 /**
  * A <code>ShowViewMenu</code> is used to populate a menu manager with Show
  * View actions. The visible views are determined by user preference from the
  * Perspective Customize dialog.
  */
 class ShowViewMenu : public ContributionItem
 {
 
 public:
 
   /**
    * Creates a Show View menu.
    *
    * @param window
    *            the window containing the menu
    * @param id
    *            the id
    */
   ShowViewMenu(IWorkbenchWindow* window, const QString& id);
 
   bool IsDirty() const;
 
   /**
    * Overridden to always return true and force dynamic menu building.
    */
   bool IsDynamic() const;
 
   using ContributionItem::Fill;
 
   QAction* Fill(QMenu* menu, QAction *before);
 
 private:
 
   bool dirty;
 
   IWorkbenchWindow* window;
 
   //static const QString NO_TARGETS_MSG = WorkbenchMessages.Workbench_showInNoTargets;
 
   /**
    * Fills the menu with Show View actions.
    */
   void FillMenu(IMenuManager* innerMgr);
 
   QSet<QPair<QString, QString> > GetShortcuts(IWorkbenchPage* page) const;
 
-//  Action showDlgAction;
+  IContributionItem::Pointer showDlgItem;
 
 //  IMenuListener menuListener = new IMenuListener() {
 //    public void menuAboutToShow(IMenuManager manager) {
 //      manager.markDirty();
 //      dirty = true;
 //    }
 //  };
 
 //  bool makeFast;
 
 
   SmartPointer<CommandContributionItemParameter> GetItem(const QString& viewId, const QString& secondaryId) const;
 
   QSet<QPair<QString,QString> > AddOpenedViews(IWorkbenchPage* page, QSet<QPair<QString,QString> >& actions) const;
 
   QSet<QPair<QString,QString> > GetParts(IWorkbenchPage* page) const;
 
 
   /**
    * @param commandService
    * @param makeFast
    */
 //  ParameterizedCommand GetCommand(ICommandService* commandService,
 //                                  bool makeFast)
 //  {
 //    Command c = commandService.getCommand(IWorkbenchCommandConstants.VIEWS_SHOW_VIEW);
 //    Parameterization[] parms = null;
 //    if (makeFast) {
 //      try {
 //        IParameter parmDef = c
 //            .getParameter(IWorkbenchCommandConstants.VIEWS_SHOW_VIEW_PARM_FASTVIEW);
 //        parms = new Parameterization[] { new Parameterization(parmDef,
 //            "true") //$NON-NLS-1$
 //        };
 //      } catch (NotDefinedException e) {
 //        // this should never happen
 //      }
 //    }
 //    return new ParameterizedCommand(c, parms);
 //  }
 };
 
 }
 
 #endif // BERRYSHOWVIEWMENU_H
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryWorkbench.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryWorkbench.cpp
index 917ac1395a..12128a8d10 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryWorkbench.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryWorkbench.cpp
@@ -1,1869 +1,1869 @@
 /*===================================================================
 
 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 "berryLog.h"
 
 #include "tweaklets/berryWorkbenchTweaklet.h"
 
 #include "berryWorkbench.h"
 
 #include <berrySafeRunner.h>
 
 #include "berrySaveablesList.h"
 #include "berryViewRegistry.h"
 #include "berryEditorRegistry.h"
 #include "berryServiceLocatorCreator.h"
 #include "berryWorkbenchPage.h"
 #include "berryPerspective.h"
 #include "berryPreferenceConstants.h"
-#include "dialogs/berryMessageDialog.h"
 #include "berryWorkbenchWindow.h"
 #include "berryImageDescriptor.h"
 #include "berryDisplay.h"
 #include "services/berryIServiceFactory.h"
 #include "util/berrySafeRunnable.h"
 
 #include "berryWorkbenchServiceRegistry.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryWorkbenchConstants.h"
 #include "berryWorkbenchMenuService.h"
 #include "berryEvaluationService.h"
 #include "berryCommandService.h"
 #include "berryCommandManager.h"
 #include "berryParameterType.h"
 #include "berrySourceProviderService.h"
 #include "berryWorkbenchLocationService.h"
 
 #include <berryCommandCategory.h>
 #include <berryIHandler.h>
 #include <berryIHandlerService.h>
 #include <berryIPreferencesService.h>
 #include <berryIPreferences.h>
 #include <berryISourceProvider.h>
 #include <berryIServiceScopes.h>
 
 #include <QDir>
 #include <QApplication>
+#include <QMessageBox>
 
 //#include <Poco/Thread.h>
 //#include <Poco/Bugcheck.h>
 #include <Poco/FileStream.h>
 
 namespace berry
 {
 
 Workbench* Workbench::instance = 0;
 WorkbenchTestable::Pointer Workbench::testableObject;
 
 const unsigned int Workbench::VERSION_STRING_COUNT = 1;
 const QString Workbench::VERSION_STRING[Workbench::VERSION_STRING_COUNT] =
 { "1.0" };
 
 const QString Workbench::DEFAULT_WORKBENCH_STATE_FILENAME = "workbench.xml";
 
 class RestoreStateRunnable: public SafeRunnable
 {
 
 private:
 
   Workbench* workbench;
   Poco::File stateFile;
   bool& result;
 
 public:
 
   RestoreStateRunnable(Workbench* workbench, const QString& stateFile,
       bool& result) :
     SafeRunnable(
         "Unable to read workbench state. Workbench UI layout will be reset."),
         workbench(workbench), stateFile(stateFile.toStdString()), result(result)
   {
 
   }
 
   void Run()
   {
     Poco::FileInputStream input(stateFile.path());
     IMemento::Pointer memento = XMLMemento::CreateReadRoot(input);
 
     // Validate known version format
     QString version;
     memento->GetString(WorkbenchConstants::TAG_VERSION, version);
     bool valid = false;
     for (std::size_t i = 0; i < Workbench::VERSION_STRING_COUNT; i++)
     {
       if (Workbench::VERSION_STRING[i] == version)
       {
         valid = true;
         break;
       }
     }
     if (!valid)
     {
       input.close();
       QString msg =
           "Invalid workbench state version. workbench.xml will be deleted";
-      MessageDialog::OpenError(Shell::Pointer(0), "Restoring Problems", msg);
+      QMessageBox::critical(NULL, "Restoring Problems", msg);
       stateFile.remove();
       //          result[0] = new Status(IStatus.ERROR,
       //              WorkbenchPlugin.PI_WORKBENCH,
       //              IWorkbenchConfigurer.RESTORE_CODE_RESET, msg, null);
       result = false;
       return;
     }
 
     //    // Validate compatible version format
     //    // We no longer support the release 1.0 format
     //    if (VERSION_STRING[0].equals(version))
     //    {
     //      reader.close();
     //      QString msg = "The saved user interface layout is in an "
     //          "obsolete format and cannot be preserved. Your projects and files "
     //          "will not be affected. Press OK to convert to the new format. Press "
     //          "Cancel to exit with no changes.";
     //      QList<QString> dlgLabels;
     //      dlgLabels.push_back("Ok");
     //      dlgLabels.push_back("Cancel");
     //      IDialog::Pointer dlg = MessageDialog::CreateDialog(Shell::Pointer(0),
     //          "Cannot Preserve Layout", 0, msg, IDialog::WARNING, dlgLabels, 0);
     //      IDialog::ReturnCode ignoreSavedState = dlg->Open();
     //      // OK is the default
     //      if (ignoreSavedState == IDialog::OK)
     //      {
     //        stateFile.remove();
     //        //            result[0] = new Status(IStatus.WARNING,
     //        //                WorkbenchPlugin.PI_WORKBENCH,
     //        //                IWorkbenchConfigurer.RESTORE_CODE_RESET, msg,
     //        //                null);
     //        result = false;
     //      }
     //      else
     //      {
     //        //            result[0] = new Status(IStatus.WARNING,
     //        //                WorkbenchPlugin.PI_WORKBENCH,
     //        //                IWorkbenchConfigurer.RESTORE_CODE_EXIT, msg,
     //        //                null);
     //        result = false;
     //      }
     //      return;
     //    }
 
     // Restore the saved state
     //final IStatus restoreResult = restoreState(memento);
     /*bool restoreResult =*/ workbench->RestoreState(memento);
     input.close();
     //        if (restoreResult.getSeverity() == IStatus.ERROR) {
     //          StartupThreading
     //              .runWithoutExceptions(new StartupRunnable() {
     //
     //                public void runWithException() throws Throwable {
     //                  StatusManager.getManager().handle(restoreResult, StatusManager.LOG);
     //                }
     //              });
     //
     //        }
   }
 
   void HandleException(const std::exception& e)
   {
     //StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
     //public void runWithException() {
     Handle(e);
     //            QString msg = e.getMessage() == null ? "" : e.getMessage(); //$NON-NLS-1$
     //            result[0] = new Status(IStatus.ERROR,
     //                WorkbenchPlugin.PI_WORKBENCH,
     //                IWorkbenchConfigurer.RESTORE_CODE_RESET, msg, e);
     result = false;
     stateFile.remove();
     //  }});
   }
 
 private:
 
   void Handle(const std::exception& e)
   {
     SafeRunnable::HandleException(e);
   }
 };
 
 int Workbench::CreateAndRunWorkbench(Display* display,
     WorkbenchAdvisor* advisor)
 {
   // create the workbench instance
   Workbench workbench(display, advisor);
   // run the workbench event loop
   int returnCode = workbench.RunUI();
 
   return returnCode;
 }
 
 Display* Workbench::CreateDisplay()
 {
 
   // create the display
   Display* newDisplay = Tweaklets::Get(WorkbenchTweaklet::KEY)->CreateDisplay();
 
   // workaround for 1GEZ9UR and 1GF07HN
   //newDisplay.setWarnings(false);
 
   // Set the priority higher than normal so as to be higher
   // than the JobManager.
   //Poco::Thread::current()->setPriority(Poco::Thread::PRIO_HIGH);
 
   //initializeImages();
 
   return newDisplay;
 }
 
 Workbench::ServiceLocatorOwner::ServiceLocatorOwner(Workbench* wb) :
   workbench(wb)
 {
 
 }
 
 void Workbench::ServiceLocatorOwner::Dispose()
 {
-  MessageDialog::OpenInformation(
-      Shell::Pointer(0),
-      "Restart needed",
-      "A required plug-in is no longer available and the Workbench needs to be restarted. You will be prompted to save if there is any unsaved work.");
+  QMessageBox::information(
+        NULL,
+        "Restart needed",
+        "A required plug-in is no longer available and the Workbench needs "
+        "to be restarted. You will be prompted to save if there is any unsaved work.");
   workbench->Close(PlatformUI::RETURN_RESTART, true);
 }
 
 Workbench::Workbench(Display* display, WorkbenchAdvisor* advisor)
   : commandManager(0), progressCount(-1)
   , serviceLocatorOwner(new ServiceLocatorOwner(this))
   , largeUpdates(0), introManager(0), isStarting(true), isClosing(false)
 {
   poco_check_ptr(display)
 ;  poco_check_ptr(advisor);
   // the reference count to the one and only workbench instance
   // is increased, so that temporary smart pointer to the workbench
   // do not delete it
   this->Register();
 
   this->display = display;
   this->advisor = advisor;
   Workbench::instance = this;
 
   serviceLocatorCreator.reset(new ServiceLocatorCreator());
   serviceLocatorCreator->Register();
   this->serviceLocator = serviceLocatorCreator->CreateServiceLocator(
         NULL,
         NULL,
         IDisposable::WeakPtr(serviceLocatorOwner)).Cast<ServiceLocator>();
   serviceLocator->RegisterService(serviceLocatorCreator.data());
 
   workbenchLocationService.reset(
         new WorkbenchLocationService(IServiceScopes::WORKBENCH_SCOPE, this, NULL, NULL, 0));
   workbenchLocationService->Register();
   serviceLocator->RegisterService(workbenchLocationService.data());
 
   returnCode = PlatformUI::RETURN_UNSTARTABLE;
 }
 
 Display* Workbench::GetDisplay()
 {
   return display;
 }
 
 Workbench* Workbench::GetInstance()
 {
   return instance;
 }
 
 WorkbenchTestable::Pointer Workbench::GetWorkbenchTestable()
 {
   if (!testableObject)
   {
     testableObject = new WorkbenchTestable();
   }
   return testableObject;
 }
 
 Workbench::~Workbench()
 {
   this->instance = 0;
   this->UnRegister(false);
 }
 
 Object* Workbench::GetService(const QString& key)
 {
   return serviceLocator->GetService(key);
 }
 
 bool Workbench::HasService(const QString& key) const
 {
   return serviceLocator->HasService(key);
 }
 
 bool Workbench::Init()
 {
 
 //  // setup debug mode if required.
 //  if (WorkbenchPlugin.getDefault().isDebugging()) {
 //    WorkbenchPlugin.DEBUG = true;
 //    ModalContext.setDebugMode(true);
 //  }
 
   bool bail = false;
 
   // create workbench window manager
   //windowManager = new WindowManager();
 
   IIntroRegistry* introRegistry = WorkbenchPlugin::GetDefault()
         ->GetIntroRegistry();
     if (introRegistry->GetIntroCount() > 0) {
       //TODO Product support
       //IProduct product = Platform.getProduct();
       //if (product != null) {
         introDescriptor = introRegistry
             ->GetIntroForProduct("").Cast<IntroDescriptor>(); //product.getId());
       //}
     }
 
   // TODO Correctly order service initialization
   // there needs to be some serious consideration given to
   // the services, and hooking them up in the correct order
   evaluationService.reset(new EvaluationService());
   evaluationService->Register();
 
   //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
   //
   //      public void runWithException() {
   serviceLocator->RegisterService(evaluationService.data());
   //      }
   //    });
 
   // Initialize the activity support.
   //workbenchActivitySupport = new WorkbenchActivitySupport();
   //activityHelper = ActivityPersistanceHelper.getInstance();
 
   this->InitializeDefaultServices();
   //    initializeFonts();
   //    initializeColors();
   //    initializeApplicationColors();
 
   // now that the workbench is sufficiently initialized, let the advisor
   // have a turn.
 
   advisor->InternalBasicInitialize(this->GetWorkbenchConfigurer());
 
 //  StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
 //        public void runWithException() {
   StartSourceProviders();
 //        }
 //      });
 
 //      StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
 //        public void runWithException() {
 
 //          activateWorkbenchContext();
 
 //        }
 //      });
 
 //      StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
 //        public void runWithException() {
 
 //          createApplicationMenu();
 //        }
 //      });
 
   // attempt to restore a previous workbench state
 
   advisor->PreStartup();
 
   if (!advisor->OpenWindows())
   {
     bail = true;
   }
 
   if (bail)
   return false;
 
   //forceOpenPerspective();
 
   return true;
 }
 
 bool Workbench::RestoreState()
 {
   //return false;
   if (!GetWorkbenchConfigurer()->GetSaveAndRestore())
   {
     //      QString msg = "This application does not save and restore previously saved state.";
     //      return new Status(IStatus.WARNING, WorkbenchPlugin.PI_WORKBENCH,
     //          IWorkbenchConfigurer.RESTORE_CODE_RESET, msg, null);
     return false;
   }
   // Read the workbench state file.
   QString stateFile = GetWorkbenchStateFile();
   // If there is no state file cause one to open.
   if (stateFile.isEmpty() || !QFile::exists(stateFile))
   {
     //      QString msg = "No previously saved state to restore.";
     //      return new Status(IStatus.WARNING, WorkbenchPlugin.PI_WORKBENCH,
     //          IWorkbenchConfigurer.RESTORE_CODE_RESET, msg, null);
     return false;
   }
 
   //    final IStatus result[] = { new Status(IStatus.OK,
   //        WorkbenchPlugin.PI_WORKBENCH, IStatus.OK, "", null) }; //$NON-NLS-1$
   bool result = true;
   ISafeRunnable::Pointer runnable(new RestoreStateRunnable(this, stateFile, result));
   SafeRunner::Run(runnable);
   // ensure at least one window was opened
   //if (result[0].isOK() && windowManager.getWindows().length == 0)
   if (result && windowManager.GetWindowCount() == 0)
   {
     QString msg = "No windows restored.";
     //    result[0] = new Status(IStatus.ERROR, WorkbenchPlugin.PI_WORKBENCH,
     //        IWorkbenchConfigurer.RESTORE_CODE_RESET, msg, null);
     result &= false;
   }
   return result;
 }
 
 bool Workbench::RestoreState(IMemento::Pointer memento)
 {
 
   //    final MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID,
   //        IStatus.OK, WorkbenchMessages.Workbench_problemsRestoring, null);
   bool result = true;
 
   const bool showProgress = false;
   //TODO restore state progress
   //    final boolean showProgress = PrefUtil.getAPIPreferenceStore()
   //        .getBoolean(
   //            IWorkbenchPreferenceConstants.SHOW_PROGRESS_ON_STARTUP);
 
   try
   {
     /*
      * Restored windows will be set in the createdWindows field to be
      * used by the openWindowsAfterRestore() method
      */
     if (!showProgress)
     {
       DoRestoreState(memento, result);
     }
     else
     {
       // Retrieve how many plug-ins were loaded while restoring the
       // workbench
       int lastProgressCount = -1;
       memento->GetInteger(WorkbenchConstants::TAG_PROGRESS_COUNT, lastProgressCount);
 
       // If we don't know how many plug-ins were loaded last time,
       // assume we are loading half of the installed plug-ins.
       /*const std::size_t expectedProgressCount =*/
       std::max<std::size_t>(1,
           lastProgressCount == -1 ? WorkbenchPlugin::GetDefault()->GetBundleCount() / 2
           : lastProgressCount);
 
       //TODO restore state progress
       //        RunStartupWithProgress(expectedProgressCount, new Runnable() {
       //          public void Run() {
       //            DoRestoreState(memento, result);
       //          }
       //        });
     }
   }
   catch (...)
   {
     OpenWindowsAfterRestore();
     throw;
   }
 
   OpenWindowsAfterRestore();
   return result;
 }
 
 void Workbench::DoRestoreState(IMemento::Pointer memento, bool& status) // final MultiStatus status)
 
 {
   IMemento::Pointer childMem;
   try
   {
     // UIStats.start(UIStats.RESTORE_WORKBENCH, "MRUList"); //$NON-NLS-1$
     IMemento::Pointer mruMemento = memento
     ->GetChild(WorkbenchConstants::TAG_MRU_LIST);
     if (mruMemento)
     {
       // TODO restore editor history
       //status.add(getEditorHistory().restoreState(mruMemento));
     }
 
     //UIStats.end(UIStats.RESTORE_WORKBENCH, this, "MRUList"); //$NON-NLS-1$
   }
   catch (...)
   {
     //UIStats.end(UIStats.RESTORE_WORKBENCH, this, "MRUList"); //$NON-NLS-1$
     throw;
   }
 
   // Restore advisor state.
   IMemento::Pointer advisorState = memento
   ->GetChild(WorkbenchConstants::TAG_WORKBENCH_ADVISOR);
   if (advisorState)
   {
     //status.add(getAdvisor().restoreState(advisorState));
     status &= GetAdvisor()->RestoreState(advisorState);
   }
 
   // Get the child windows.
   QList<IMemento::Pointer> children = memento
   ->GetChildren(WorkbenchConstants::TAG_WINDOW);
 
   createdWindows.clear();
 
   // Read the workbench windows.
   for (int i = 0; i < children.size(); i++)
   {
     childMem = children[i];
     WorkbenchWindow::Pointer newWindow;
 
     //StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
     //  public void runWithException() {
     newWindow = NewWorkbenchWindow();
     newWindow->Create();
     //  }});
     createdWindows.push_back(newWindow);
 
     // allow the application to specify an initial perspective to open
     // @issue temporary workaround for ignoring initial perspective
     // String initialPerspectiveId =
     // getAdvisor().getInitialWindowPerspectiveId();
     // if (initialPerspectiveId != null) {
     // IPerspectiveDescriptor desc =
     // getPerspectiveRegistry().findPerspectiveWithId(initialPerspectiveId);
     // result.merge(newWindow.restoreState(childMem, desc));
     // }
     // add the window so that any work done in newWindow.restoreState
     // that relies on Workbench methods has windows to work with
     windowManager.Add(newWindow);
 
     // now that we've added it to the window manager we need to listen
     // for any exception that might hose us before we get a chance to
     // open it. If one occurs, remove the new window from the manager.
     // Assume that the new window is a phantom for now
     try
     {
       //status.merge(newWindow[0].restoreState(childMem, null));
       status &= newWindow->RestoreState(childMem, IPerspectiveDescriptor::Pointer(0));
       try
       {
         newWindow->FireWindowRestored();
       }
       catch (const WorkbenchException& /*e*/)
       {
         //status.add(e.getStatus());
         status &= false;
       }
       // everything worked so far, don't close now
     }
     catch (...)
     {
       // null the window in newWindowHolder so that it won't be
       // opened later on
       createdWindows[i] = 0;
       //StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
       //  public void runWithException() throws Throwable {
       newWindow->Close();
       //  }});
 
     }
   }
 }
 
 void Workbench::OpenWindowsAfterRestore()
 {
   if (createdWindows.empty())
   {
     return;
   }
   // now open the windows (except the ones that were nulled because we
   // closed them above)
   for (int i = 0; i < createdWindows.size(); i++)
   {
     if (createdWindows[i])
     {
       WorkbenchWindow::Pointer myWindow = createdWindows[i];
       //StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
       //  public void runWithException() throws Throwable {
       try
       {
         myWindow->Open();
       }
       catch (...)
       {
         myWindow->Close();
         throw;
       }
       //  }});
     }
   }
   createdWindows.clear();
 }
 
 void Workbench::InitializeDefaultServices()
 {
 
   //    final IContributionService contributionService = new ContributionService(
   //        getAdvisor());
   //    serviceLocator.registerService(IContributionService.class,
   //        contributionService);
   //
   //    // TODO Correctly order service initialization
   //    // there needs to be some serious consideration given to
   //    // the services, and hooking them up in the correct order
   //
   //
   //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
   //
   //      public void runWithException() {
   saveablesList.reset(new SaveablesList());
   saveablesList->Register();
   serviceLocator->RegisterService(saveablesList.data());
   //      }});
   //
 
   /*
    * Phase 1 of the initialization of commands. When this phase completes,
    * all the services and managers will exist, and be accessible via the
    * getService(Object) method.
    */
   //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
   //
   //      public void runWithException() {
   //        Command.DEBUG_COMMAND_EXECUTION = Policy.DEBUG_COMMANDS;
   commandManager.reset(new CommandManager());
   //      }});
   //
   //    final CommandService [] commandService = new CommandService[1];
   //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
   //
   //      public void runWithException() {
   commandService.reset(new CommandService(commandManager.data()));
   commandService->Register();
   commandService->ReadRegistry();
   serviceLocator->RegisterService(commandService.data());
   //      }});
   //
   //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
   //
   //      public void runWithException() {
   //        ContextManager.DEBUG = Policy.DEBUG_CONTEXTS;
   //        contextManager = new ContextManager();
   //        }});
   //
   //    final IContextService contextService = new ContextService(
   //        contextManager);
   //
   //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
   //
   //      public void runWithException() {
   //        contextService.readRegistry();
   //        }});
   //
   //    serviceLocator.registerService(IContextService.class, contextService);
   //
   //
   //    final IBindingService [] bindingService = new BindingService[1];
   //
   //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
   //
   //      public void runWithException() {
   //        BindingManager.DEBUG = Policy.DEBUG_KEY_BINDINGS;
   //        bindingManager = new BindingManager(contextManager, commandManager);
   //        bindingService[0] = new BindingService(
   //            bindingManager, commandService[0], Workbench.this);
   //
   //      }});
   //
   //    bindingService[0].readRegistryAndPreferences(commandService[0]);
   //    serviceLocator.registerService(IBindingService.class, bindingService[0]);
   //
   //    final CommandImageManager commandImageManager = new CommandImageManager();
   //    final CommandImageService commandImageService = new CommandImageService(
   //        commandImageManager, commandService[0]);
   //    commandImageService.readRegistry();
   //    serviceLocator.registerService(ICommandImageService.class,
   //        commandImageService);
 
   WorkbenchMenuService* wms = new WorkbenchMenuService(serviceLocator.GetPointer());
   menuService.reset(wms);
   menuService->Register();
 
   serviceLocator->RegisterService(menuService.data());
   // the service must be registered before it is initialized - its
   // initialization uses the service locator to address a dependency on
   // the menu service
   //StartupThreading.runWithoutExceptions(new StartupRunnable() {
   //      public void runWithException() {
   wms->ReadRegistry();
   //      }});
 
   // the source providers are now initialized in phase 3, but source
   // priorities have to be set before handler initialization
   // StartupThreading.runWithoutExceptions(new StartupRunnable() {
   // public void runWithException() {
   InitializeSourcePriorities();
   // }
   // });
 
   /*
    * Phase 2 of the initialization of commands. This handles the creation
    * of wrappers for legacy APIs. By the time this phase completes, any
    * code trying to access commands through legacy APIs should work.
    */
   //IHandlerService* handlerService = NULL;
 //      StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
 //        public void runWithException() {
   /*handlerService = */serviceLocator->GetService<IHandlerService>();
 //        }
 //      });
 //      workbenchContextSupport = new WorkbenchContextSupport(this,
 //          contextManager);
 //      workbenchCommandSupport = new WorkbenchCommandSupport(bindingManager,
 //          commandManager, contextManager, handlerService[0]);
 //      initializeCommandResolver();
 
 //      addWindowListener(windowListener);
 //      bindingManager.addBindingManagerListener(bindingManagerListener);
 
 //      serviceLocator.registerService(ISelectionConversionService.class,
 //          new SelectionConversionService());
 }
 
 int Workbench::RunUI()
 {
 
   // initialize workbench and restore or open one window
   bool initOK = this->Init();
 
   // let the advisor run its start up code
   if (initOK)
   {
     advisor->PostStartup(); // may trigger a close/restart
   }
 
   //TODO start eager plug-ins
   //startPlugins();
 
   //addStartupRegistryListener();
 
   isStarting = false;
 
   BERRY_INFO << "BlueBerry Workbench ready";
 
   this->GetWorkbenchTestable()->Init(Display::GetDefault(), this);
 
   // spin event loop
   return display->RunEventLoop();
 }
 
 QString Workbench::GetDefaultPerspectiveId()
 {
   return this->GetAdvisor()->GetInitialWindowPerspectiveId();
 }
 
 IAdaptable* Workbench::GetDefaultPageInput()
 {
   return this->GetAdvisor()->GetDefaultPageInput();
 }
 
 QString Workbench::GetPresentationId()
 {
   if (factoryID != "")
   {
     return factoryID;
   }
 
   //factoryID = PrefUtil.getAPIPreferenceStore().getString(
   //    IWorkbenchPreferenceConstants.PRESENTATION_FACTORY_ID);
 
   // Workaround for bug 58975 - New preference mechanism does not properly
   // initialize defaults
   // Ensure that the UI plugin has started too.
   factoryID = WorkbenchConstants::DEFAULT_PRESENTATION_ID;
 
   return factoryID;
 }
 
 void Workbench::UpdateTheme()
 {
   WorkbenchPlugin::GetDefault()->GetPresentationFactory()->UpdateTheme();
 }
 
 void Workbench::LargeUpdateStart()
 {
   if (largeUpdates++ == 0)
   {
     // TODO Consider whether these lines still need to be here.
     // workbenchCommandSupport.setProcessing(false);
     // workbenchContextSupport.setProcessing(false);
 
     QList<IWorkbenchWindow::Pointer> windows = this->GetWorkbenchWindows();
     for (int i = 0; i < windows.size(); i++)
     {
       IWorkbenchWindow::Pointer window = windows[i];
       if (window.Cast<WorkbenchWindow>() != 0)
       {
         window.Cast<WorkbenchWindow>()->LargeUpdateStart();
       }
     }
   }
 }
 
 void Workbench::LargeUpdateEnd()
 {
   if (--largeUpdates == 0)
   {
     // TODO Consider whether these lines still need to be here.
     // workbenchCommandSupport.setProcessing(true);
     // workbenchContextSupport.setProcessing(true);
 
     // Perform window-specific blocking.
     QList<IWorkbenchWindow::Pointer> windows = this->GetWorkbenchWindows();
     for (int i = 0; i < windows.size(); i++)
     {
       IWorkbenchWindow::Pointer window = windows[i];
       if (window.Cast<WorkbenchWindow>() != 0)
       {
         window.Cast<WorkbenchWindow>()->LargeUpdateEnd();
       }
     }
   }
 }
 
 void Workbench::OpenFirstTimeWindow()
 {
   try
   {
     IAdaptable* input;
     //StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
     //  public void runWithException() throws Throwable {
     input = this->GetDefaultPageInput();
     //  }});
 
     this->BusyOpenWorkbenchWindow(this->GetPerspectiveRegistry()->GetDefaultPerspective(), input);
   }
   catch (WorkbenchException& e)
   {
     // Don't use the window's shell as the dialog parent,
     // as the window is not open yet (bug 76724).
     //StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
     //  public void runWithException() throws Throwable {
     //    ErrorDialog.openError(null,
     //        WorkbenchMessages.Problems_Opening_Page, e.getMessage(), e
     //            .getStatus());
     //  }});
     BERRY_ERROR << "Error: Problems opening page. " << e.what() << std::endl;
   }
 }
 
 WorkbenchConfigurer::Pointer Workbench::GetWorkbenchConfigurer()
 {
   if (workbenchConfigurer.IsNull())
   {
     workbenchConfigurer = new WorkbenchConfigurer();
   }
   return workbenchConfigurer;
 }
 
 WorkbenchAdvisor* Workbench::GetAdvisor()
 {
   return advisor;
 }
 
 IViewRegistry* Workbench::GetViewRegistry()
 {
   return WorkbenchPlugin::GetDefault()->GetViewRegistry();
 }
 
 IEditorRegistry* Workbench::GetEditorRegistry()
 {
   return WorkbenchPlugin::GetDefault()->GetEditorRegistry();
 }
 
 IPerspectiveRegistry* Workbench::GetPerspectiveRegistry()
 {
   return WorkbenchPlugin::GetDefault()->GetPerspectiveRegistry();
 }
 
 bool Workbench::Close()
 {
   return this->Close(PlatformUI::RETURN_OK, false);
 }
 
 bool Workbench::Close(int returnCode, bool force)
 {
   BERRY_INFO << "Closing workbench...";
   this->returnCode = returnCode;
   bool ret;
   //BusyIndicator.showWhile(null, new Runnable() {
   //  public void run() {
   ret = this->BusyClose(force);
   //  }
   //});
   return ret;
 }
 
 /**
  * Closes the workbench. Assumes that the busy cursor is active.
  *
  * @param force
  *            true if the close is mandatory, and false if the close is
  *            allowed to fail
  * @return true if the close succeeded, and false otherwise
  */
 bool Workbench::BusyClose(bool force)
 {
 
   // notify the advisor of preShutdown and allow it to veto if not forced
   isClosing = advisor->PreShutdown();
   if (!force && !isClosing)
   {
     return false;
   }
 
   // notify regular workbench clients of preShutdown and allow them to
   // veto if not forced
   isClosing = this->FirePreShutdown(force);
   if (!force && !isClosing)
   {
     return false;
   }
 
   // save any open editors if they are dirty
   isClosing = this->SaveAllEditors(!force);
   if (!force && !isClosing)
   {
     return false;
   }
 
   bool closeEditors = !force && false; // false is the default for the not yet implemented preference below
   // && PrefUtil.getAPIPreferenceStore().getBoolean(
   //     IWorkbenchPreferenceConstants.CLOSE_EDITORS_ON_EXIT);
   if (closeEditors)
   {
     // SafeRunner.run(new SafeRunnable() {
     //  public void run() {
     QList<IWorkbenchWindow::Pointer> windows = this->GetWorkbenchWindows();
     for (int i = 0; i < windows.size(); i++)
     {
       IWorkbenchPage::Pointer page = windows[i]->GetActivePage();
       if (page)
       isClosing = isClosing && page->CloseAllEditors(false);
     }
     // }
     //});
     if (!force && !isClosing)
     {
       return false;
     }
   }
 
   if (this->GetWorkbenchConfigurer()->GetSaveAndRestore())
   {
     try
     {
       //    SafeRunner.run(new SafeRunnable() {
       //      public void run() {
       XMLMemento::Pointer mem = RecordWorkbenchState();
       // Save the IMemento to a file.
       SaveMementoToFile(mem);
       //      }
     }
     catch(const ctkException& e)
     {
       //      public void handleException(Throwable e) {
       QString message;
       if (e.what() == 0)
       {
         message = "An error has occurred. See error log for more details. Do you want to exit?";
       }
       else
       {
         message = QString("An error has occurred: ") + e.what() + ". See error log for more details. Do you want to exit?";
       }
-
-      if (!MessageDialog::OpenQuestion(Shell::Pointer(0), "Error", message))
+      if (QMessageBox::question(NULL, "Error", message) != QMessageBox::Yes)
       {
         isClosing = false;
       }
     }
     //      }
     //    });
   }
   if (!force && !isClosing)
   {
     return false;
   }
 
   //SafeRunner.run(new SafeRunnable(WorkbenchMessages.ErrorClosing) {
   //  public void run() {
   if (isClosing || force)
   {
     isClosing = windowManager.Close();
   }
   //  }
   //});
 
   if (!force && !isClosing)
   {
     return false;
   }
 
   this->Shutdown();
 
   display->ExitEventLoop(0);
   return true;
 }
 
 QString Workbench::GetWorkbenchStateFile() const
 {
   QString path = WorkbenchPlugin::GetDefault()->GetDataLocation();
   if (path.isNull())
   {
     return QString();
   }
   return QDir::cleanPath(path + "/" + DEFAULT_WORKBENCH_STATE_FILENAME);
 }
 
 /*
  * Save the workbench UI in a persistence file.
  */
 bool Workbench::SaveMementoToFile(XMLMemento::Pointer memento)
 {
   // Save it to a file.
   // XXX: nobody currently checks the return value of this method.
   QString stateFile = GetWorkbenchStateFile();
   if (stateFile.isNull())
   {
     return false;
   }
   //BERRY_INFO << "Saving state to: " << stateFile.path() << std::endl;
   try
   {
     Poco::FileOutputStream stream(stateFile.toStdString());
     memento->Save(stream);
   }
   catch (const Poco::IOException& /*e*/)
   {
     QFile::remove(stateFile);
-    MessageDialog::OpenError(Shell::Pointer(0),
-        "Saving Problems",
-        "Unable to store workbench state.");
+    QMessageBox::critical(NULL,
+                          "Saving Problems",
+                          "Unable to store workbench state.");
     return false;
   }
 
   // Success !
   return true;
 }
 
 IWorkbenchWindow::Pointer Workbench::GetActiveWorkbenchWindow() const
 {
   // Look for the window that was last known being
   // the active one
   WorkbenchWindow::Pointer win = this->GetActivatedWindow();
   return win;
 }
 
 std::size_t Workbench::GetWorkbenchWindowCount()
 {
   return windowManager.GetWindowCount();
 }
 
 QList<IWorkbenchWindow::Pointer> Workbench::GetWorkbenchWindows()
 {
   QList<Window::Pointer> windows = windowManager.GetWindows();
   QList<IWorkbenchWindow::Pointer> result;
   for (QList<Window::Pointer>::iterator iter = windows.begin();
       iter != windows.end(); ++iter)
   {
     result.push_back(iter->Cast<WorkbenchWindow>());
   }
 
   return result;
 }
 
 IWorkbenchWindow::Pointer Workbench::OpenWorkbenchWindow(
     const QString& perspID, IAdaptable* input)
 {
   // Run op in busy cursor.
   //final Object[] result = new Object[1];
   //BusyIndicator.showWhile(null, new Runnable() {
   //  public void run() {
   //    try {
   return this->BusyOpenWorkbenchWindow(perspID, input);
   //    } catch (WorkbenchException e) {
   //      result[0] = e;
   //    }
   //  }
   //});
 
 }
 
 IWorkbenchWindow::Pointer Workbench::OpenWorkbenchWindow(IAdaptable* input)
 {
   return this->OpenWorkbenchWindow(this->GetPerspectiveRegistry()
       ->GetDefaultPerspective(), input);
 }
 
 IWorkbenchPage::Pointer Workbench::ShowPerspective(
     const QString& perspectiveId, IWorkbenchWindow::Pointer window)
 {
   // If the specified window has the requested perspective open, then the
   // window
   // is given focus and the perspective is shown. The page's input is
   // ignored.
   WorkbenchWindow::Pointer win = window.Cast<WorkbenchWindow> ();
   if (win)
   {
     IWorkbenchPage::Pointer page = win->GetActivePage();
     if (page)
     {
       QList<IPerspectiveDescriptor::Pointer> perspectives(page
           ->GetOpenPerspectives());
       for (int i = 0; i < perspectives.size(); i++)
       {
         IPerspectiveDescriptor::Pointer persp = perspectives[i];
         if (perspectiveId == persp->GetId())
         {
           win->MakeVisible();
           page->SetPerspective(persp);
           return page;
         }
       }
     }
   }
 
   // If another window that has the workspace root as input and the
   // requested
   // perpective open and active, then the window is given focus.
   IAdaptable* input = GetDefaultPageInput();
   QList<IWorkbenchWindow::Pointer> windows(GetWorkbenchWindows());
   for (int i = 0; i < windows.size(); i++)
   {
     win = windows[i].Cast<WorkbenchWindow>();
     if (window != win)
     {
       WorkbenchPage::Pointer page = win->GetActivePage().Cast<WorkbenchPage>();
       if (page)
       {
         bool inputSame = false;
         if (input == 0)
         {
           inputSame = (page->GetInput() == 0);
         }
         else
         {
           inputSame = input == page->GetInput();
         }
         if (inputSame)
         {
           Perspective::Pointer persp = page->GetActivePerspective();
           if (persp)
           {
             IPerspectiveDescriptor::Pointer desc = persp->GetDesc();
             if (desc)
             {
               if (perspectiveId == desc->GetId())
               {
                 Shell::Pointer shell = win->GetShell();
                 shell->Open();
                 if (shell->GetMinimized())
                 {
                   shell->SetMinimized(false);
                 }
                 return page;
               }
             }
           }
         }
       }
     }
   }
 
   // Otherwise the requested perspective is opened and shown in the
   // specified
   // window or in a new window depending on the current user preference
   // for opening
   // perspectives, and that window is given focus.
   win = window.Cast<WorkbenchWindow>();
   if (win)
   {
     IPreferencesService* store = WorkbenchPlugin::GetDefault()->GetPreferencesService();
     int mode = store->GetSystemPreferences()->GetInt(PreferenceConstants::OPEN_PERSP_MODE,
                                                      PreferenceConstants::OPM_ACTIVE_PAGE);
     IWorkbenchPage::Pointer page = win->GetActivePage();
     IPerspectiveDescriptor::Pointer persp;
     if (page)
     {
       persp = page->GetPerspective();
     }
 
     // Only open a new window if user preference is set and the window
     // has an active perspective.
     if (PreferenceConstants::OPM_NEW_WINDOW == mode && persp)
     {
       IWorkbenchWindow::Pointer newWindow = OpenWorkbenchWindow(perspectiveId,
           input);
       return newWindow->GetActivePage();
     }
 
     IPerspectiveDescriptor::Pointer desc = GetPerspectiveRegistry()
     ->FindPerspectiveWithId(perspectiveId);
     if (desc == 0)
     {
       throw WorkbenchException(
           "Unable to create perspective \"" + perspectiveId + "\". There is no corresponding perspective extension.");
     }
     win->GetShell()->Open();
     if (page == 0)
     {
       page = win->OpenPage(perspectiveId, input);
     }
     else
     {
       page->SetPerspective(desc);
     }
     return page;
   }
 
   // Just throw an exception....
   throw WorkbenchException("Problems opening perspective \"" +
       perspectiveId + "\"");
 }
 
 IWorkbenchPage::Pointer Workbench::ShowPerspective(
     const QString& /*perspectiveId*/,
     IWorkbenchWindow::Pointer /*window*/,
     IAdaptable* /*input*/)
 {
   return IWorkbenchPage::Pointer(0);
   //    // If the specified window has the requested perspective open and the
   //    // same requested
   //    // input, then the window is given focus and the perspective is shown.
   //    bool inputSameAsWindow = false;
   //    WorkbenchWindow::Pointer win = window.Cast<WorkbenchWindow>();
   //    if (win.IsNotNull()) {
   //      WorkbenchPage::Pointer page = win->GetActiveWorkbenchPage();
   //      if (page.IsNotNull()) {
   //        bool inputSame = false;
   //        if (input == 0) {
   //          inputSame = (page->GetInput() == 0);
   //        } else {
   //          inputSame = input.equals(page.getInput());
   //        }
   //        if (inputSame) {
   //          inputSameAsWindow = true;
   //          IPerspectiveDescriptor perspectives[] = page
   //              .getOpenPerspectives();
   //          for (int i = 0; i < perspectives.length; i++) {
   //            IPerspectiveDescriptor persp = perspectives[i];
   //            if (perspectiveId.equals(persp.getId())) {
   //              win.makeVisible();
   //              page.setPerspective(persp);
   //              return page;
   //            }
   //          }
   //        }
   //      }
   //    }
   //
   //    // If another window has the requested input and the requested
   //    // perpective open and active, then that window is given focus.
   //    IWorkbenchWindow[] windows = getWorkbenchWindows();
   //    for (int i = 0; i < windows.length; i++) {
   //      win = (WorkbenchWindow) windows[i];
   //      if (window != win) {
   //        WorkbenchPage page = win.getActiveWorkbenchPage();
   //        if (page != null) {
   //          boolean inputSame = false;
   //          if (input == null) {
   //            inputSame = (page.getInput() == null);
   //          } else {
   //            inputSame = input.equals(page.getInput());
   //          }
   //          if (inputSame) {
   //            Perspective persp = page.getActivePerspective();
   //            if (persp != null) {
   //              IPerspectiveDescriptor desc = persp.getDesc();
   //              if (desc != null) {
   //                if (perspectiveId.equals(desc.getId())) {
   //                  win.getShell().open();
   //                  return page;
   //                }
   //              }
   //            }
   //          }
   //        }
   //      }
   //    }
   //
   //    // If the specified window has the same requested input but not the
   //    // requested
   //    // perspective, then the window is given focus and the perspective is
   //    // opened and shown
   //    // on condition that the user preference is not to open perspectives in
   //    // a new window.
   //    win = (WorkbenchWindow) window;
   //    if (inputSameAsWindow && win != null) {
   //      IPreferenceStore store = WorkbenchPlugin.getDefault()
   //          .getPreferenceStore();
   //      int mode = store.getInt(IPreferenceConstants.OPEN_PERSP_MODE);
   //
   //      if (IPreferenceConstants.OPM_NEW_WINDOW != mode) {
   //        IWorkbenchPage page = win.getActiveWorkbenchPage();
   //        IPerspectiveDescriptor desc = getPerspectiveRegistry()
   //            .findPerspectiveWithId(perspectiveId);
   //        if (desc == null) {
   //          throw new WorkbenchException(
   //              NLS
   //                  .bind(
   //                      WorkbenchMessages.WorkbenchPage_ErrorCreatingPerspective,
   //                      perspectiveId));
   //        }
   //        win.getShell().open();
   //        if (page == null) {
   //          page = win.openPage(perspectiveId, input);
   //        } else {
   //          page.setPerspective(desc);
   //        }
   //        return page;
   //      }
   //    }
   //
   //    // If the specified window has no active perspective, then open the
   //    // requested perspective and show the specified window.
   //    if (win != null) {
   //      IWorkbenchPage page = win.getActiveWorkbenchPage();
   //      IPerspectiveDescriptor persp = null;
   //      if (page != null) {
   //        persp = page.getPerspective();
   //      }
   //      if (persp == null) {
   //        IPerspectiveDescriptor desc = getPerspectiveRegistry()
   //            .findPerspectiveWithId(perspectiveId);
   //        if (desc == null) {
   //          throw new WorkbenchException(
   //              NLS
   //                  .bind(
   //                      WorkbenchMessages.WorkbenchPage_ErrorCreatingPerspective,
   //                      perspectiveId));
   //        }
   //        win.getShell().open();
   //        if (page == null) {
   //          page = win.openPage(perspectiveId, input);
   //        } else {
   //          page.setPerspective(desc);
   //        }
   //        return page;
   //      }
   //    }
   //
   //    // Otherwise the requested perspective is opened and shown in a new
   //    // window, and the
   //    // window is given focus.
   //    IWorkbenchWindow newWindow = openWorkbenchWindow(perspectiveId, input);
   //    return newWindow.getActivePage();
 }
 
 bool Workbench::SaveAllEditors(bool /*confirm*/)
 {
   return true;
 }
 
 IIntroManager* Workbench::GetIntroManager()
 {
   return GetWorkbenchIntroManager();
 }
 
 WorkbenchIntroManager* Workbench::GetWorkbenchIntroManager()
 {
   if (introManager.isNull())
   {
     introManager.reset(new WorkbenchIntroManager(this));
   }
   return introManager.data();
 }
 
 IntroDescriptor::Pointer Workbench::GetIntroDescriptor() const
 {
   return introDescriptor;
 }
 
 void Workbench::SetIntroDescriptor(IntroDescriptor::Pointer descriptor)
 {
   if (GetIntroManager()->GetIntro())
   {
     GetIntroManager()->CloseIntro(GetIntroManager()->GetIntro());
   }
   introDescriptor = descriptor;
 }
 
 bool Workbench::IsRunning()
 {
   return Tweaklets::Get(WorkbenchTweaklet::KEY)->IsRunning();
 }
 
 bool Workbench::IsStarting()
 {
   return isStarting;
 }
 
 bool Workbench::IsClosing()
 {
   return isClosing;
 }
 
 WorkbenchWindow::Pointer Workbench::GetActivatedWindow() const
 {
   return activatedWindow;
 }
 
 /*
  * Sets the workbench window which was last known being the active one, or
  * <code> null </code> .
  */
 void Workbench::SetActivatedWindow(WorkbenchWindow::Pointer window)
 {
   activatedWindow = window;
 }
 
 WorkbenchWindow::Pointer Workbench::NewWorkbenchWindow()
 {
   WorkbenchWindow::Pointer wbw(new WorkbenchWindow(this->GetNewWindowNumber()));
   return wbw;
 }
 
 int Workbench::GetNewWindowNumber()
 {
   // Get window list.
   QList<Window::Pointer> windows = windowManager.GetWindows();
   int count = static_cast<int>(windows.size());
 
   // Create an array of booleans (size = window count).
   // Cross off every number found in the window list.
   bool *checkArray = new bool[count];
   for (int nX = 0; nX < count; ++nX)
   {
     if (windows[nX].Cast<WorkbenchWindow> ().IsNotNull())
     {
       WorkbenchWindow::Pointer ww = windows[nX].Cast<WorkbenchWindow> ();
       int index = ww->GetNumber() - 1;
       if (index >= 0 && index < count)
       {
         checkArray[index] = true;
       }
     }
   }
 
   // Return first index which is not used.
   // If no empty index was found then every slot is full.
   // Return next index.
   for (int index = 0; index < count; index++)
   {
     if (!checkArray[index])
     {
       delete[] checkArray;
       return index + 1;
     }
   }
 
   delete[] checkArray;
   return static_cast<int>(count + 1);
 }
 
 IWorkbenchWindow::Pointer Workbench::BusyOpenWorkbenchWindow(
     const QString& perspID, IAdaptable* input)
 {
   // Create a workbench window (becomes active window)
   //final WorkbenchWindow newWindowArray[] = new WorkbenchWindow[1];
   //StartupThreading.runWithWorkbenchExceptions(new StartupRunnable() {
   //  public void runWithException() {
   //    newWindowArray[0] = newWorkbenchWindow();
   WorkbenchWindow::Pointer newWindow = this->NewWorkbenchWindow();
   //  }
   //});
 
   //final WorkbenchWindow newWindow = newWindowArray[0];
 
   //StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
   //  public void runWithException() {
   newWindow->Create(); // must be created before adding to window
   // manager
   //  }
   //});
   windowManager.Add(newWindow);
 
   //final WorkbenchException [] exceptions = new WorkbenchException[1];
   // Create the initial page.
   if (perspID != "")
   {
     //StartupThreading.runWithWorkbenchExceptions(new StartupRunnable() {
 
     try
     {
       newWindow->BusyOpenPage(perspID, input);
     }
     catch (WorkbenchException& e)
     {
       windowManager.Remove(newWindow);
       throw e;
     }
   }
 
   // Open window after opening page, to avoid flicker.
   //StartupThreading.runWithWorkbenchExceptions(new StartupRunnable() {
 
   //  public void runWithException() {
   newWindow->Open();
   //  }
   //});
 
   return newWindow;
 }
 
 bool Workbench::SaveState(IMemento::Pointer memento)
 {
   //  MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK,
   //      WorkbenchMessages.Workbench_problemsSaving, null);
   bool result = true;
 
   // Save the version number.
   memento->PutString(WorkbenchConstants::TAG_VERSION, VERSION_STRING[0]);
 
   // Save how many plug-ins were loaded while restoring the workbench
   if (progressCount != -1)
   {
     memento->PutInteger(WorkbenchConstants::TAG_PROGRESS_COUNT,
         progressCount);
   }
 
   // Save the advisor state.
   IMemento::Pointer advisorState = memento
   ->CreateChild(WorkbenchConstants::TAG_WORKBENCH_ADVISOR);
   //result.add(getAdvisor().saveState(advisorState));
   result &= GetAdvisor()->SaveState(advisorState);
 
   // Save the workbench windows.
   QList<IWorkbenchWindow::Pointer> windows(GetWorkbenchWindows());
   for (int nX = 0; nX < windows.size(); nX++)
   {
     WorkbenchWindow::Pointer window = windows[nX].Cast<WorkbenchWindow>();
     IMemento::Pointer childMem = memento->CreateChild(WorkbenchConstants::TAG_WINDOW);
     //result.merge(window.saveState(childMem));
     result &= window->SaveState(childMem);
   }
   //  result.add(getEditorHistory().saveState(
   //      memento.createChild(IWorkbenchConstants.TAG_MRU_LIST)));
 
   return result;
 }
 
 XMLMemento::Pointer Workbench::RecordWorkbenchState()
 {
   XMLMemento::Pointer memento = XMLMemento
   ::CreateWriteRoot(WorkbenchConstants::TAG_WORKBENCH);
   //final IStatus status = saveState(memento);
   bool status = SaveState(memento);
   //if (status.getSeverity() != IStatus.OK) {
   if (!status)
   {
     //    // don't use newWindow as parent because it has not yet been opened
     //    // (bug 76724)
     //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
     //
     //      public void runWithException() throws Throwable {
     //        ErrorDialog.openError(null,
     //            WorkbenchMessages.Workbench_problemsSaving,
     //            WorkbenchMessages.Workbench_problemsSavingMsg, status);
     //      }});
 
   }
   return memento;
 }
 
 void Workbench::AddWorkbenchListener(IWorkbenchListener* listener)
 {
   workbenchEvents.AddListener(listener);
 }
 
 void Workbench::RemoveWorkbenchListener(IWorkbenchListener* listener)
 {
   workbenchEvents.RemoveListener(listener);
 }
 
 IWorkbenchListener::Events& Workbench::GetWorkbenchEvents()
 {
   return workbenchEvents;
 }
 
 void Workbench::AddWindowListener(IWindowListener* l)
 {
   windowEvents.AddListener(l);
 }
 
 void Workbench::RemoveWindowListener(IWindowListener* l)
 {
   windowEvents.RemoveListener(l);
 }
 
 IWindowListener::Events& Workbench::GetWindowEvents()
 {
   return windowEvents;
 }
 
 bool Workbench::FirePreShutdown(bool forced)
 {
 
   //SafeRunnable.run(new SafeRunnable() {
   //  public void run() {
   typedef IWorkbenchListener::Events::PreShutdownEvent::ListenerList ListenerList;
   const ListenerList& listeners = workbenchEvents.preShutdown.GetListeners();
   for ( ListenerList::const_iterator iter = listeners.begin();
       iter != listeners.end(); ++iter )
   {
     // notify each listener
     if (! (*iter)->Execute(dynamic_cast<IWorkbench*>(this), forced))
     return false;
   }
   //  }
 
   return true;
 }
 
 /**
  * Fire workbench postShutdown event.
  *
  * @since 3.2
  */
 void Workbench::FirePostShutdown()
 {
 
   //  SafeRunnable.run(new SafeRunnable() {
   //    public void run() {
   workbenchEvents.postShutdown(this);
   //    }
 
 }
 
 void Workbench::FireWindowOpened(IWorkbenchWindow::Pointer window)
 {
 
   // SafeRunner.run(new SafeRunnable() {
   //   public void run() {
   windowEvents.windowOpened(window);
   //   }
 
 }
 
 void Workbench::FireWindowClosed(IWorkbenchWindow::Pointer window)
 {
   if (activatedWindow == window)
   {
     // Do not hang onto it so it can be GC'ed
     activatedWindow = 0;
   }
 
   //  SafeRunner.run(new SafeRunnable() {
   //    public void run() {
   windowEvents.windowClosed(window);
   //    }
 
 }
 
 void Workbench::FireWindowActivated(IWorkbenchWindow::Pointer window)
 {
 
   //  SafeRunner.run(new SafeRunnable() {
   //    public void run() {
   windowEvents.windowActivated(window);
   //    }
 
 }
 
 void Workbench::FireWindowDeactivated(IWorkbenchWindow::Pointer window)
 {
 
   //  SafeRunner.run(new SafeRunnable() {
   //    public void run() {
   windowEvents.windowDeactivated(window);
   //    }
 
 }
 
 IWorkbenchWindow::Pointer Workbench::RestoreWorkbenchWindow(IMemento::Pointer memento)
 {
   WorkbenchWindow::Pointer newWindow = this->NewWorkbenchWindow();
   //newWindow.create();
 
   windowManager.Add(newWindow);
 
   // whether the window was opened
   bool opened = false;
 
   try
   {
     newWindow->RestoreState(memento, IPerspectiveDescriptor::Pointer(0));
     newWindow->FireWindowRestored();
     newWindow->Open();
     opened = true;
   }
   catch (...)
   {
     if (!opened)
     {
       newWindow->Close();
     }
   }
 
   return newWindow;
 }
 
 void Workbench::Shutdown()
 {
   // shutdown application-specific portions first
   advisor->PostShutdown();
 
   // notify regular workbench clients of shutdown, and clear the list when
   // done
   this->FirePostShutdown();
   //workbenchListeners.clear();
 
   //cancelEarlyStartup();
 
   // for dynamic UI
   //  Platform.getExtensionRegistry().removeRegistryChangeListener(
   //      extensionEventHandler);
   //  Platform.getExtensionRegistry().removeRegistryChangeListener(
   //      startupRegistryListener);
 
   // ((GrabFocus) Tweaklets.get(GrabFocus.KEY)).dispose();
 
   // Bring down all of the services.
   serviceLocator->Dispose();
 
   // workbenchActivitySupport.dispose();
   // WorkbenchHelpSystem.disposeIfNecessary();
 
   // shutdown the rest of the workbench
   // WorkbenchColors.shutdown();
   // activityHelper.shutdown();
   // uninitializeImages();
   //  if (WorkbenchPlugin.getDefault() != null) {
   //    WorkbenchPlugin.getDefault().reset();
   //  }
   //  WorkbenchThemeManager.getInstance().dispose();
   //  PropertyPageContributorManager.getManager().dispose();
   //  ObjectActionContributorManager.getManager().dispose();
   //  if (tracker != null) {
   //    tracker.close();
   //  }
 
   Tweaklets::Clear();
 }
 
 void Workbench::InitializeSourcePriorities()
 {
   WorkbenchServiceRegistry::GetRegistry()->InitializeSourcePriorities();
 }
 
 void Workbench::StartSourceProviders()
 {
   /*
    * Phase 3 of the initialization of commands. The source providers that
    * the workbench provides are creating and registered with the above
    * services. These source providers notify the services when particular
    * pieces of workbench state change.
    */
   IEvaluationService* const evaluationService = serviceLocator->GetService<IEvaluationService>();
   //IContextService* const contextService = serviceLocator->GetService<IContextService>();
 
   SourceProviderService* sps = new SourceProviderService(serviceLocator.GetPointer());
   sourceProviderService.reset(sps);
   sourceProviderService->Register();
   serviceLocator->RegisterService<ISourceProviderService>(sourceProviderService.data());
   struct SafeSourceProviderRunnable : public ISafeRunnable {
 
     SafeSourceProviderRunnable(SourceProviderService* sps, IEvaluationService* es) : sps(sps), es(es)
     {}
 
     void Run() {
       // this currently instantiates all players ... sigh
       sps->ReadRegistry();
       QList<ISourceProvider::Pointer> sp = sps->GetSourceProviders();
       for (int i = 0; i < sp.size(); i++)
       {
         es->AddSourceProvider(sp[i]);
         //if (!(sp[i] instanceof ActiveContextSourceProvider))
         //{
         //  contextService.addSourceProvider(sp[i]);
         //}
       }
     }
 
     void HandleException(const std::exception& exception)
     {
       WorkbenchPlugin::Log("Failed to initialize a source provider", ctkException(QString(exception.what())));
     }
 
   private:
     SourceProviderService* sps;
     IEvaluationService* es;
   };
   ISafeRunnable::Pointer sourceProviderRunnable(
         new SafeSourceProviderRunnable(sps, evaluationService));
   SafeRunner::Run(sourceProviderRunnable);
 
 //    SafeRunner.run(new ISafeRunnable() {
 //      public void run() throws Exception {
 //        // these guys are need to provide the variables they say
 //        // they source
 //        actionSetSourceProvider = (ActionSetSourceProvider) sourceProviderService
 //            .getSourceProvider(ISources.ACTIVE_ACTION_SETS_NAME);
 
 //        FocusControlSourceProvider focusControl = (FocusControlSourceProvider) sourceProviderService
 //            .getSourceProvider(ISources.ACTIVE_FOCUS_CONTROL_ID_NAME);
 //        serviceLocator.registerService(IFocusService.class, focusControl);
 
 //        menuSourceProvider = (MenuSourceProvider) sourceProviderService
 //            .getSourceProvider(ISources.ACTIVE_MENU_NAME);
 //      }
 
 //      public void handleException(Throwable exception) {
 //        WorkbenchPlugin.log("Failed to initialize a source provider", exception); //$NON-NLS-1$
 //      }
 //    });
 }
 
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryWorkbenchPage.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryWorkbenchPage.cpp
index e68c290110..f546bede34 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryWorkbenchPage.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryWorkbenchPage.cpp
@@ -1,4113 +1,4105 @@
 /*===================================================================
 
 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 "berryLog.h"
 
 #include "tweaklets/berryGuiWidgetsTweaklet.h"
 #include "tweaklets/berryWorkbenchPageTweaklet.h"
 
 #include "berryWorkbenchPage.h"
 #include "berryPartSite.h"
 #include "berryWorkbenchRegistryConstants.h"
 #include "berryPerspective.h"
 #include "berryLayoutPartSash.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryEditorAreaHelper.h"
 #include "berrySaveablesList.h"
 #include "berryPerspectiveHelper.h"
 #include "berryLayoutTreeNode.h"
 #include "berryWorkbench.h"
 #include "berryWorkbenchConstants.h"
 #include "berryPartService.h"
 #include "berryStickyViewManager.h"
 #include "intro/berryIntroConstants.h"
 #include "intro/berryViewIntroAdapterPart.h"
 
-#include "dialogs/berryMessageDialog.h"
-
 #include "berryWorkbenchWindow.h"
 #include "berryUIException.h"
 #include "berryPlatformUI.h"
 #include "berryPartPane.h"
 #include "berryImageDescriptor.h"
 
 #include <berryPlatform.h>
 
+#include <QMessageBox>
+
 namespace berry
 {
 
 WorkbenchPage::ActivationOrderPred::ActivationOrderPred(
     WorkbenchPage::ActivationList* al) :
   activationList(al)
 {
 
 }
 
 bool WorkbenchPage::ActivationOrderPred::operator()(
     const IViewReference::Pointer o1, const IViewReference::Pointer o2) const
 {
   WorkbenchPage::ActivationList::PartListIter pos1 = activationList->IndexOf(
       o1.Cast<IWorkbenchPartReference> ());
   WorkbenchPage::ActivationList::PartListIter pos2 = activationList->IndexOf(
       o2.Cast<IWorkbenchPartReference> ());
   return pos1 < pos2;
 }
 
 void WorkbenchPage::PerspectiveList::UpdateActionSets(
     Perspective::Pointer /*oldPersp*/, Perspective::Pointer /*newPersp*/)
 {
   //TODO WorkbenchPage action sets
   //        // Update action sets
   //
   //        IContextService service = (IContextService) window
   //            .getService(IContextService.class);
   //        try {
   //          service.activateContext(ContextAuthority.DEFER_EVENTS);
   //          if (newPersp != 0) {
   //            IActionSetDescriptor[] newAlwaysOn = newPersp
   //                .getAlwaysOnActionSets();
   //            for (int i = 0; i < newAlwaysOn.length; i++) {
   //              IActionSetDescriptor descriptor = newAlwaysOn[i];
   //
   //              actionSets.showAction(descriptor);
   //            }
   //
   //            IActionSetDescriptor[] newAlwaysOff = newPersp
   //                .getAlwaysOffActionSets();
   //            for (int i = 0; i < newAlwaysOff.length; i++) {
   //              IActionSetDescriptor descriptor = newAlwaysOff[i];
   //
   //              actionSets.maskAction(descriptor);
   //            }
   //          }
   //
   //          if (oldPersp != 0) {
   //            IActionSetDescriptor[] newAlwaysOn = oldPersp
   //                .getAlwaysOnActionSets();
   //            for (int i = 0; i < newAlwaysOn.length; i++) {
   //              IActionSetDescriptor descriptor = newAlwaysOn[i];
   //
   //              actionSets.hideAction(descriptor);
   //            }
   //
   //            IActionSetDescriptor[] newAlwaysOff = oldPersp
   //                .getAlwaysOffActionSets();
   //            for (int i = 0; i < newAlwaysOff.length; i++) {
   //              IActionSetDescriptor descriptor = newAlwaysOff[i];
   //
   //              actionSets.unmaskAction(descriptor);
   //            }
   //          }
   //        } finally {
   //          service.activateContext(ContextAuthority.SEND_EVENTS);
   //        }
 }
 
 WorkbenchPage::PerspectiveList::PerspectiveList()
 {
 
 }
 
 void WorkbenchPage::PerspectiveList::Reorder(
     IPerspectiveDescriptor::Pointer perspective, int newLoc)
 {
   PerspectiveListType::iterator oldLocation = openedList.end();
   Perspective::Pointer movedPerspective;
   for (PerspectiveListType::iterator iterator = openedList.begin(); iterator
       != openedList.end(); ++iterator)
   {
     Perspective::Pointer openPerspective = *iterator;
     if (openPerspective->GetDesc() == perspective)
     {
       oldLocation = std::find(openedList.begin(), openedList.end(),
           openPerspective);
       movedPerspective = openPerspective;
     }
   }
 
   PerspectiveListType::iterator newLocation = openedList.begin();
   for (int i = 0; i < newLoc; ++i, ++newLocation)
     ;
   if (oldLocation == newLocation)
   {
     return;
   }
 
   openedList.erase(oldLocation);
   openedList.insert(newLocation, movedPerspective);
 
 }
 
 WorkbenchPage::PerspectiveList::PerspectiveListType WorkbenchPage::PerspectiveList::GetSortedPerspectives()
 {
   return usedList;
 }
 
 bool WorkbenchPage::PerspectiveList::Add(Perspective::Pointer perspective)
 {
   openedList.push_back(perspective);
   usedList.push_front(perspective);
   //It will be moved to top only when activated.
   return true;
 }
 
 WorkbenchPage::PerspectiveList::PerspectiveListType::iterator WorkbenchPage::PerspectiveList::Begin()
 {
   return openedList.begin();
 }
 
 WorkbenchPage::PerspectiveList::PerspectiveListType::iterator WorkbenchPage::PerspectiveList::End()
 {
   return openedList.end();
 }
 
 WorkbenchPage::PerspectiveList::PerspectiveListType WorkbenchPage::PerspectiveList::GetOpenedPerspectives()
 {
   return openedList;
 }
 
 bool WorkbenchPage::PerspectiveList::Remove(Perspective::Pointer perspective)
 {
   if (active == perspective)
   {
     this->UpdateActionSets(active, Perspective::Pointer(0));
     active = 0;
   }
   usedList.removeAll(perspective);
   PerspectiveListType::size_type origSize = openedList.size();
   openedList.removeAll(perspective);
   return openedList.size() != origSize;
 }
 
 void WorkbenchPage::PerspectiveList::Swap(Perspective::Pointer oldPerspective,
     Perspective::Pointer newPerspective)
 {
   PerspectiveListType::iterator oldIter = std::find(openedList.begin(),
       openedList.end(), oldPerspective);
   PerspectiveListType::iterator newIter = std::find(openedList.begin(),
       openedList.end(), newPerspective);
 
   if (oldIter == openedList.end() || newIter == openedList.end())
   {
     return;
   }
 
   std::iter_swap(oldIter, newIter);
 }
 
 bool WorkbenchPage::PerspectiveList::IsEmpty()
 {
   return openedList.empty();
 }
 
 Perspective::Pointer WorkbenchPage::PerspectiveList::GetActive()
 {
   return active;
 }
 
 Perspective::Pointer WorkbenchPage::PerspectiveList::GetNextActive()
 {
   if (active == 0)
   {
     if (usedList.empty())
     {
       return Perspective::Pointer(0);
     }
     else
     {
       return usedList.back();
     }
   }
   else
   {
     if (usedList.size() < 2)
     {
       return Perspective::Pointer(0);
     }
     else
     {
       return *(--usedList.end());
     }
   }
 }
 
 WorkbenchPage::PerspectiveList::PerspectiveListType::size_type WorkbenchPage::PerspectiveList::Size()
 {
   return openedList.size();
 }
 
 void WorkbenchPage::PerspectiveList::SetActive(Perspective::Pointer perspective)
 {
   if (perspective == active)
   {
     return;
   }
 
   this->UpdateActionSets(active, perspective);
   active = perspective;
 
   if (perspective != 0)
   {
     usedList.removeAll(perspective);
     usedList.push_back(perspective);
   }
 }
 
 WorkbenchPage::ActivationList::ActivationList(WorkbenchPage* page) :
   page(page)
 {
 
 }
 
 void WorkbenchPage::ActivationList::SetActive(SmartPointer<IWorkbenchPart> part)
 {
   if (parts.empty())
   {
     return;
   }
   IWorkbenchPartReference::Pointer ref(page->GetReference(part));
   if (ref)
   {
     if (ref == parts.back())
     {
       return;
     }
     parts.erase(std::find(parts.begin(), parts.end(), ref));
     parts.push_back(ref);
   }
 }
 
 void WorkbenchPage::ActivationList::BringToTop(SmartPointer<
     IWorkbenchPartReference> ref)
 {
   ILayoutContainer::Pointer targetContainer(page->GetContainer(ref));
 
   PartListIter newIndex = this->LastIndexOfContainer(targetContainer);
 
   if (newIndex != parts.end() && ref == *newIndex)
   {
     return;
   }
 
   if (newIndex == parts.end())
   {
     parts.push_back(ref);
   }
   else
   {
     PartListType::size_type index = newIndex - parts.begin();
     parts.erase(std::find(parts.begin(), parts.end(), ref));
     PartListIter insertIndex = parts.begin() + index;
     parts.insert(insertIndex, ref);
   }
 }
 
 WorkbenchPage::ActivationList::PartListIter WorkbenchPage::ActivationList::LastIndexOfContainer(
     SmartPointer<ILayoutContainer> container)
 {
   PartListReverseIter i = parts.rbegin();
   while (i != parts.rend())
   {
     IWorkbenchPartReference::Pointer ref(*i);
     ILayoutContainer::Pointer cnt(page->GetContainer(ref));
     if (cnt == container)
     {
       return --i.base();
     }
     ++i;
   }
 
   return parts.end();
 }
 
 void WorkbenchPage::ActivationList::SetActive(SmartPointer<
     IWorkbenchPartReference> ref)
 {
   this->SetActive(ref->GetPart(true));
 }
 
 void WorkbenchPage::ActivationList::Add(
     SmartPointer<IWorkbenchPartReference> ref)
 {
   if (std::find(parts.begin(), parts.end(), ref) != parts.end())
   {
     return;
   }
 
   ref->GetPart(false);
   parts.push_front(ref);
 }
 
 SmartPointer<IWorkbenchPart> WorkbenchPage::ActivationList::GetActive()
 {
   if (parts.empty())
   {
     return IWorkbenchPart::Pointer(0);
   }
   return this->GetActive(parts.end());
 }
 
 SmartPointer<IWorkbenchPart> WorkbenchPage::ActivationList::GetPreviouslyActive()
 {
   if (parts.size() < 2)
   {
     return IWorkbenchPart::Pointer(0);
   }
   return this->GetActive(--parts.end());
 }
 
 SmartPointer<IWorkbenchPartReference> WorkbenchPage::ActivationList::GetActiveReference(
     bool editorsOnly)
 {
   return this->GetActiveReference(parts.end(), editorsOnly);
 }
 
 WorkbenchPage::ActivationList::PartListIter WorkbenchPage::ActivationList::IndexOf(
     SmartPointer<IWorkbenchPart> part)
 {
   IWorkbenchPartReference::Pointer ref(page->GetReference(part));
   if (ref == 0)
   {
     return parts.end();
   }
   return std::find(parts.begin(), parts.end(), ref);
 }
 
 WorkbenchPage::ActivationList::PartListIter WorkbenchPage::ActivationList::IndexOf(
     SmartPointer<IWorkbenchPartReference> ref)
 {
   return std::find(parts.begin(), parts.end(), ref);
 }
 
 bool WorkbenchPage::ActivationList::Remove(
     SmartPointer<IWorkbenchPartReference> ref)
 {
   bool contains = std::find(parts.begin(), parts.end(), ref) != parts.end();
   parts.erase(std::find(parts.begin(), parts.end(), ref));
   return contains;
 }
 
 SmartPointer<IEditorPart> WorkbenchPage::ActivationList::GetTopEditor()
 {
   IEditorReference::Pointer editor =
       this->GetActiveReference(parts.end(), true).Cast<IEditorReference> ();
 
   if (editor == 0)
   {
     return IEditorPart::Pointer(0);
   }
 
   return editor->GetEditor(true);
 }
 
 SmartPointer<IWorkbenchPart> WorkbenchPage::ActivationList::GetActive(
     PartListIter start)
 {
   IWorkbenchPartReference::Pointer ref(this->GetActiveReference(start, false));
 
   if (!ref)
   {
     return IWorkbenchPart::Pointer(0);
   }
 
   return ref->GetPart(true);
 }
 
 SmartPointer<IWorkbenchPartReference> WorkbenchPage::ActivationList::GetActiveReference(
     PartListIter start, bool editorsOnly)
 {
   // First look for parts that aren't obscured by the current zoom state
   IWorkbenchPartReference::Pointer nonObscured = this->GetActiveReference(
       start, editorsOnly, true);
 
   if (nonObscured)
   {
     return nonObscured;
   }
 
   // Now try all the rest of the parts
   return this->GetActiveReference(start, editorsOnly, false);
 }
 
 SmartPointer<IWorkbenchPartReference> WorkbenchPage::ActivationList::GetActiveReference(
     PartListIter start, bool editorsOnly, bool /*skipPartsObscuredByZoom*/)
 {
   QList<IViewReference::Pointer> views = page->GetViewReferences();
   PartListReverseIter i(start);
   while (i != parts.rend())
   {
     WorkbenchPartReference::Pointer ref(i->Cast<WorkbenchPartReference> ());
 
     if (editorsOnly && (ref.Cast<IEditorReference> () == 0))
     {
       ++i;
       continue;
     }
 
     // Skip parts whose containers have disabled auto-focus
     PartPane::Pointer pane(ref->GetPane());
 
     if (pane)
     {
       if (!pane->AllowsAutoFocus())
       {
         ++i;
         continue;
       }
 
       //                    if (skipPartsObscuredByZoom) {
       //                        if (pane.isObscuredByZoom()) {
       //                            continue;
       //                        }
       //                    }
     }
 
     // Skip fastviews (unless overridden)
     if (IViewReference::Pointer viewRef = ref.Cast<IViewReference>())
     {
       //if (ref == getActiveFastView() || !((IViewReference) ref).isFastView()) {
       for (int j = 0; j < views.size(); j++)
       {
         if (views[j] == viewRef)
         {
           return viewRef.Cast<IWorkbenchPartReference> ();
         }
       }
       //}
     }
     else
     {
       return ref.Cast<IWorkbenchPartReference> ();
     }
     ++i;
   }
   return IWorkbenchPartReference::Pointer(0);
 }
 
 QList<SmartPointer<IEditorReference> > WorkbenchPage::ActivationList::GetEditors()
 {
   QList<IEditorReference::Pointer> editors;
   for (PartListIter i = parts.begin(); i != parts.end(); ++i)
   {
     if (IEditorReference::Pointer part = i->Cast<IEditorReference>())
     {
       editors.push_back(part);
     }
   }
   return editors;
 }
 
 QList<SmartPointer<IWorkbenchPartReference> > WorkbenchPage::ActivationList::GetParts()
 {
   QList<IViewReference::Pointer> views(page->GetViewReferences());
   QList<IWorkbenchPartReference::Pointer> resultList;
   for (PartListIter iterator = parts.begin(); iterator != parts.end(); ++iterator)
   {
 
     if (IViewReference::Pointer ref = iterator->Cast<IViewReference>())
     {
       //Filter views from other perspectives
       for (int i = 0; i < views.size(); i++)
       {
         if (ref == views[i])
         {
           resultList.push_back(ref);
           break;
         }
       }
     }
     else
     {
       resultList.push_back(*iterator);
     }
   }
   return resultList;
 }
 
 void WorkbenchPage::ActionSwitcher::UpdateActivePart(
     IWorkbenchPart::Pointer newPart)
 {
   IWorkbenchPart::Pointer _activePart = this->activePart.Lock();
   IEditorPart::Pointer _topEditor = this->topEditor.Lock();
 
   if (_activePart == newPart)
   {
     return;
   }
 
   bool isNewPartAnEditor = newPart.Cast<IEditorPart> ().IsNotNull();
   if (isNewPartAnEditor)
   {
     QString oldId;
     if (_topEditor)
     {
       oldId = _topEditor->GetSite()->GetId();
     }
     QString newId = newPart->GetSite()->GetId();
 
     // if the active part is an editor and the new editor
     // is the same kind of editor, then we don't have to do
     // anything
     if (activePart == topEditor && newId == oldId)
     {
       activePart = newPart;
       topEditor = newPart.Cast<IEditorPart> ();
       return;
     }
 
     // remove the contributions of the old editor
     // if it is a different kind of editor
     if (oldId != newId)
     {
       this->DeactivateContributions(_topEditor, true);
     }
 
     // if a view was the active part, disable its contributions
     if (_activePart && _activePart != _topEditor)
     {
       this->DeactivateContributions(_activePart, true);
     }
 
     // show (and enable) the contributions of the new editor
     // if it is a different kind of editor or if the
     // old active part was a view
     if (newId != oldId || _activePart != _topEditor)
     {
       this->ActivateContributions(newPart, true);
     }
 
   }
   else if (newPart.IsNull())
   {
     if (_activePart)
     {
       // remove all contributions
       this->DeactivateContributions(_activePart, true);
     }
   }
   else
   {
     // new part is a view
 
     // if old active part is a view, remove all contributions,
     // but if old part is an editor only disable
     if (_activePart)
     {
       this->DeactivateContributions(_activePart,
           _activePart.Cast<IViewPart> ().IsNotNull());
     }
 
     this->ActivateContributions(newPart, true);
   }
 
   //TODO WorkbenchPage action sets
   //  ArrayList newActionSets = 0;
   //  if (isNewPartAnEditor || (activePart == topEditor && newPart == 0))
   //  {
   //    newActionSets = calculateActionSets(newPart, 0);
   //  }
   //  else
   //  {
   //    newActionSets = calculateActionSets(newPart, topEditor);
   //  }
   //
   //  if (!updateActionSets(newActionSets))
   //  {
   //    updateActionBars();
   //  }
 
   if (isNewPartAnEditor)
   {
     topEditor = newPart.Cast<IEditorPart> ();
   }
   else if (activePart == topEditor && newPart.IsNull())
   {
     // since we removed all the contributions, we clear the top
     // editor
     topEditor.Reset();
   }
 
   activePart = newPart;
 }
 
 void WorkbenchPage::ActionSwitcher::UpdateTopEditor(
     IEditorPart::Pointer newEditor)
 {
   if (topEditor.Lock() == newEditor)
   {
     return;
   }
 
   if (activePart == topEditor)
   {
     this->UpdateActivePart(newEditor);
     return;
   }
 
   QString oldId;
   if (!topEditor.Expired())
   {
     oldId = topEditor.Lock()->GetSite()->GetId();
   }
   QString newId;
   if (newEditor.IsNotNull())
   {
     newId = newEditor->GetSite()->GetId();
   }
   if (oldId == newId)
   {
     // we don't have to change anything
     topEditor = newEditor;
     return;
   }
 
   // Remove the contributions of the old editor
   if (!topEditor.Expired())
   {
     this->DeactivateContributions(topEditor.Lock(), true);
   }
 
   // Show (disabled) the contributions of the new editor
   if (newEditor.IsNotNull())
   {
     this->ActivateContributions(newEditor, false);
   }
 
   //  ArrayList newActionSets = calculateActionSets(activePart, newEditor);
   //  if (!updateActionSets(newActionSets))
   //  {
   //    updateActionBars();
   //  }
 
   topEditor = newEditor;
 }
 
 void WorkbenchPage::ActionSwitcher::ActivateContributions(
     IWorkbenchPart::Pointer /*part*/, bool /*enable*/)
 {
   //PartSite::Pointer site = part->GetSite().Cast<PartSite> ();
   //site->ActivateActionBars(enable);
 }
 
 void WorkbenchPage::ActionSwitcher::DeactivateContributions(
     IWorkbenchPart::Pointer /*part*/, bool /*remove*/)
 {
   //PartSite::Pointer site = part->GetSite().Cast<PartSite> ();
   //site->DeactivateActionBars(remove);
 }
 
 IExtensionPoint::Pointer WorkbenchPage::GetPerspectiveExtensionPoint()
 {
   return Platform::GetExtensionRegistry()->GetExtensionPoint(
         PlatformUI::PLUGIN_ID(), WorkbenchRegistryConstants::PL_PERSPECTIVE_EXTENSIONS);
 }
 
 WorkbenchPage::WorkbenchPage(WorkbenchWindow* w, const QString& layoutID,
                              IAdaptable* input)
 {
   if (layoutID == "")
   {
     throw WorkbenchException("Perspective ID is undefined");
   }
 
   this->Register();
   this->Init(w, layoutID, input, true);
   this->UnRegister(false);
 }
 
 WorkbenchPage::WorkbenchPage(WorkbenchWindow* w, IAdaptable* input)
 {
   this->Register();
   this->Init(w, "", input, false);
   this->UnRegister(false);
 }
 
 void WorkbenchPage::Activate(IWorkbenchPart::Pointer part)
 {
   // Sanity check.
   if (!this->CertifyPart(part))
   {
     return;
   }
 
   if (window->IsClosing())
   {
     return;
   }
 
   //  if (composite!=0 && composite.isVisible() && !((GrabFocus)Tweaklets.get(GrabFocus.KEY)).grabFocusAllowed(part))
   //  {
   //    return;
   //  }
 
   // Activate part.
   //if (window.getActivePage() == this) {
   IWorkbenchPartReference::Pointer ref = this->GetReference(part);
   this->InternalBringToTop(ref);
   this->SetActivePart(part);
 }
 
 void WorkbenchPage::ActivatePart(const IWorkbenchPart::Pointer part)
 {
   //  Platform.run(new SafeRunnable(WorkbenchMessages.WorkbenchPage_ErrorActivatingView)
   //      {
   //      public void WorkbenchPage::run()
   //        {
   if (part.IsNotNull())
   {
     //part.setFocus();
     PartPane::Pointer pane = this->GetPane(part);
     pane->SetFocus();
     PartSite::Pointer site = part->GetSite().Cast<PartSite> ();
     pane->ShowFocus(true);
     //this->UpdateTabList(part);
     //SubActionBars bars = (SubActionBars) site.getActionBars();
     //bars.partChanged(part);
   }
   //        }
   //      }
   //      );
 }
 
 void WorkbenchPage::AddPartListener(IPartListener* l)
 {
   partList->GetPartService()->AddPartListener(l);
 }
 
 void WorkbenchPage::AddSelectionListener(ISelectionListener* listener)
 {
   selectionService->AddSelectionListener(listener);
 }
 
 void WorkbenchPage::AddSelectionListener(const QString& partId,
     ISelectionListener* listener)
 {
   selectionService->AddSelectionListener(partId, listener);
 }
 
 void WorkbenchPage::AddPostSelectionListener(
     ISelectionListener* listener)
 {
   selectionService->AddPostSelectionListener(listener);
 }
 
 void WorkbenchPage::AddPostSelectionListener(const QString& partId,
     ISelectionListener* listener)
 {
   selectionService->AddPostSelectionListener(partId, listener);
 }
 
 ILayoutContainer::Pointer WorkbenchPage::GetContainer(
     IWorkbenchPart::Pointer part)
 {
   PartPane::Pointer pane = this->GetPane(part);
   if (pane == 0)
   {
     return ILayoutContainer::Pointer(0);
   }
 
   return pane->GetContainer();
 }
 
 ILayoutContainer::Pointer WorkbenchPage::GetContainer(
     IWorkbenchPartReference::Pointer part)
 {
   PartPane::Pointer pane = this->GetPane(part);
   if (pane == 0)
   {
     return ILayoutContainer::Pointer(0);
   }
 
   return pane->GetContainer();
 }
 
 PartPane::Pointer WorkbenchPage::GetPane(IWorkbenchPart::Pointer part)
 {
   if (part.IsNull())
   {
     return PartPane::Pointer(0);
   }
   return this->GetPane(this->GetReference(part));
 }
 
 PartPane::Pointer WorkbenchPage::GetPane(IWorkbenchPartReference::Pointer part)
 {
   if (part.IsNull())
   {
     return PartPane::Pointer(0);
   }
 
   return part.Cast<WorkbenchPartReference> ()->GetPane();
 }
 
 bool WorkbenchPage::InternalBringToTop(IWorkbenchPartReference::Pointer part)
 {
 
   bool broughtToTop = false;
 
   // Move part.
   if (part.Cast<IEditorReference> ().IsNotNull())
   {
     ILayoutContainer::Pointer container = this->GetContainer(part);
     if (container.Cast<PartStack> () != 0)
     {
       PartStack::Pointer stack = container.Cast<PartStack> ();
       PartPane::Pointer newPart = this->GetPane(part);
       if (stack->GetSelection() != newPart)
       {
         stack->SetSelection(newPart);
       }
       broughtToTop = true;
     }
   }
   else if (part.Cast<IViewReference> ().IsNotNull())
   {
     Perspective::Pointer persp = this->GetActivePerspective();
     if (persp != 0)
     {
       broughtToTop = persp->BringToTop(part.Cast<IViewReference> ());
     }
   }
 
   // Ensure that this part is considered the most recently activated part
   // in this stack
   activationList->BringToTop(part);
 
   return broughtToTop;
 }
 
 void WorkbenchPage::BringToTop(IWorkbenchPart::Pointer part)
 {
   // Sanity check.
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0 || !this->CertifyPart(part))
   {
     return;
   }
 
   //  if (!((GrabFocus)Tweaklets.get(GrabFocus.KEY)).grabFocusAllowed(part))
   //  {
   //    return;
   //  }
 
   //  QString label; // debugging only
   //  if (UIStats.isDebugging(UIStats.BRING_PART_TO_TOP))
   //  {
   //    label = part != 0 ? part.getTitle() : "none"; //$NON-NLS-1$
   //  }
 
   IWorkbenchPartReference::Pointer ref = this->GetReference(part);
   ILayoutContainer::Pointer activeEditorContainer = this->GetContainer(
       this->GetActiveEditor().Cast<IWorkbenchPart> ());
   ILayoutContainer::Pointer activePartContainer = this->GetContainer(
       this->GetActivePart());
   ILayoutContainer::Pointer newPartContainer = this->GetContainer(part);
 
   if (newPartContainer == activePartContainer)
   {
     this->MakeActive(ref);
   }
   else if (newPartContainer == activeEditorContainer)
   {
     if (ref.Cast<IEditorReference> () != 0)
     {
       if (part != 0)
       {
         IWorkbenchPartSite::Pointer site = part->GetSite();
         if (site.Cast<PartSite> () != 0)
         {
           ref = site.Cast<PartSite> ()->GetPane()->GetPartReference();
         }
       }
       this->MakeActiveEditor(ref.Cast<IEditorReference> ());
     }
     else
     {
       this->MakeActiveEditor(IEditorReference::Pointer(0));
     }
   }
   else
   {
     this->InternalBringToTop(ref);
     if (ref != 0)
     {
       partList->FirePartBroughtToTop(ref);
     }
   }
 
 }
 
 void WorkbenchPage::BusyResetPerspective()
 {
 
   ViewIntroAdapterPart::Pointer
       introViewAdapter =
           dynamic_cast<WorkbenchIntroManager*> (GetWorkbenchWindow() ->GetWorkbench()->GetIntroManager())->GetIntroAdapterPart().Cast<
               ViewIntroAdapterPart> ();
   //  PartPane introPane = 0;
   //  boolean introFullScreen = false;
   //  if (introViewAdapter != 0)
   //  {
   //    introPane = ((PartSite) introViewAdapter.getSite()).getPane();
   //    introViewAdapter.setHandleZoomEvents(false);
   //    introFullScreen = introPane.isZoomed();
   //  }
 
   //  //try to prevent intro flicker.
   //  if (introFullScreen)
   //  {
   //    window.getShell().setRedraw(false);
   //  }
 
   //  try
   //  {
 
   //    // Always unzoom
   //    if (isZoomed())
   //    {
   //      zoomOut();
   //    }
 
   // Get the current perspective.
   // This describes the working layout of the page and differs from
   // the original template.
   Perspective::Pointer oldPersp = this->GetActivePerspective();
 
   // Map the current perspective to the original template.
   // If the original template cannot be found then it has been deleted.
   // In that case just return. (PR#1GDSABU).
   IPerspectiveRegistry* reg =
       WorkbenchPlugin::GetDefault() ->GetPerspectiveRegistry();
   PerspectiveDescriptor::Pointer desc = reg->FindPerspectiveWithId(
       oldPersp->GetDesc()->GetId()).Cast<PerspectiveDescriptor> ();
   if (desc == 0)
   {
     desc
         = reg->FindPerspectiveWithId(oldPersp ->GetDesc().Cast<
             PerspectiveDescriptor> ()->GetOriginalId()).Cast<
             PerspectiveDescriptor> ();
   }
   if (desc == 0)
   {
     return;
   }
 
   // Notify listeners that we are doing a reset.
   window->FirePerspectiveChanged(IWorkbenchPage::Pointer(this), desc,
       CHANGE_RESET);
 
   // Create new persp from original template.
   // Suppress the perspectiveOpened and perspectiveClosed events otherwise it looks like two
   // instances of the same perspective are open temporarily (see bug 127470).
   Perspective::Pointer newPersp = this->CreatePerspective(desc, false);
   if (newPersp == 0)
   {
     // We're not going through with the reset, so it is complete.
     window->FirePerspectiveChanged(IWorkbenchPage::Pointer(this), desc,
         CHANGE_RESET_COMPLETE);
     return;
   }
 
   // Update the perspective list and shortcut
   perspList.Swap(oldPersp, newPersp);
 
   // Install new persp.
   this->SetPerspective(newPersp);
 
   // Destroy old persp.
   this->DisposePerspective(oldPersp, false);
 
   // Update the Coolbar layout.
   this->ResetToolBarLayout();
 
   // restore the maximized intro
   if (introViewAdapter)
   {
     try
     {
       // ensure that the intro is visible in the new perspective
       ShowView(IntroConstants::INTRO_VIEW_ID);
       //      if (introFullScreen)
       //      {
       //        toggleZoom(introPane.getPartReference());
       //      }
     } catch (PartInitException& e)
     {
       //TODO IStatus
       WorkbenchPlugin::Log("Could not restore intro", e);
       // WorkbenchPlugin.getStatus(e));
     }
     //      finally
     //      {
     //        // we want the intro back to a normal state before we fire the event
     //        introViewAdapter.setHandleZoomEvents(true);
     //      }
   }
   // Notify listeners that we have completed our reset.
   window->FirePerspectiveChanged(IWorkbenchPage::Pointer(this), desc,
       CHANGE_RESET_COMPLETE);
   //  }
   //  finally
   //  {
   //    // reset the handling of zoom events (possibly for the second time) in case there was
   //    // an exception thrown
   //    if (introViewAdapter != 0)
   //    {
   //      introViewAdapter.setHandleZoomEvents(true);
   //    }
   //
   //    if (introFullScreen)
   //    {
   //      window.getShell().setRedraw(true);
   //    }
   //  }
 }
 
 void WorkbenchPage::RemovePerspective(IPerspectiveDescriptor::Pointer desc)
 {
   Perspective::Pointer newPersp;
   PerspectiveDescriptor::Pointer realDesc = desc.Cast<PerspectiveDescriptor> ();
   newPersp = this->FindPerspective(desc);
   perspList.Remove(newPersp);
 }
 
 void WorkbenchPage::BusySetPerspective(IPerspectiveDescriptor::Pointer desc)
 {
   // Create new layout.
   QString label = desc->GetId(); // debugging only
   Perspective::Pointer newPersp;
   //try
   //{
   //UIStats.start(UIStats.SWITCH_PERSPECTIVE, label);
   PerspectiveDescriptor::Pointer realDesc = desc.Cast<PerspectiveDescriptor> ();
   newPersp = this->FindPerspective(realDesc);
   if (newPersp == 0)
   {
     newPersp = this->CreatePerspective(realDesc, true);
     if (newPersp == 0)
     {
       return;
     }
   }
 
   // Change layout.
   this->SetPerspective(newPersp);
   //  }
   //  catch (std::exception& e)
   //  {
   //    UIStats.end(UIStats.SWITCH_PERSPECTIVE, desc.getId(), label);
   //    throw e;
   //  }
 }
 
 IViewPart::Pointer WorkbenchPage::BusyShowView(const QString& viewID,
     const QString& secondaryID, int mode)
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0)
   {
     return IViewPart::Pointer(0);
   }
 
   // If this view is already visible just return.
   IViewReference::Pointer ref = persp->FindView(viewID, secondaryID);
   IViewPart::Pointer view;
   if (ref != 0)
   {
     view = ref->GetView(true);
   }
   if (view != 0)
   {
     this->BusyShowView(view, mode);
     return view;
   }
 
   // Show the view.
   view = persp->ShowView(viewID, secondaryID);
   if (view != 0)
   {
     this->BusyShowView(view, mode);
 
     IWorkbenchPartReference::Pointer partReference = this->GetReference(view);
     PartPane::Pointer partPane = this->GetPane(partReference);
     partPane->SetInLayout(true);
 
     IWorkbenchPage::Pointer thisPage(this);
     window->FirePerspectiveChanged(thisPage, GetPerspective(), partReference,
         CHANGE_VIEW_SHOW);
     window->FirePerspectiveChanged(thisPage, GetPerspective(), CHANGE_VIEW_SHOW);
   }
   return view;
 }
 
 void WorkbenchPage::BusyShowView(IViewPart::Pointer part, int mode)
 {
   //  if (!((GrabFocus) Tweaklets.get(GrabFocus.KEY)).grabFocusAllowed(part))
   //  {
   //    return;
   //  }
   if (mode == VIEW_ACTIVATE)
   {
     this->Activate(part);
   }
   else if (mode == VIEW_VISIBLE)
   {
     IWorkbenchPartReference::Pointer ref = this->GetActivePartReference();
     // if there is no active part or it's not a view, bring to top
     if (ref == 0 || ref.Cast<IViewReference> () == 0)
     {
       this->BringToTop(part);
     }
     else
     {
       // otherwise check to see if the we're in the same stack as the active view
       IViewReference::Pointer activeView = ref.Cast<IViewReference> ();
       QList<IViewReference::Pointer> viewStack =
           this->GetViewReferenceStack(part);
       for (int i = 0; i < viewStack.size(); i++)
       {
         if (viewStack[i] == activeView)
         {
           return;
         }
       }
       this->BringToTop(part);
     }
   }
 }
 
 bool WorkbenchPage::CertifyPart(IWorkbenchPart::Pointer part)
 {
   //Workaround for bug 22325
   if (part != 0 && part->GetSite().Cast<PartSite> () == 0)
   {
     return false;
   }
 
   if (part.Cast<IEditorPart> () != 0)
   {
     IEditorReference::Pointer ref = this->GetReference(part).Cast<
         IEditorReference> ();
     return ref != 0 && this->GetEditorManager()->ContainsEditor(ref);
   }
   if (part.Cast<IViewPart> () != 0)
   {
     Perspective::Pointer persp = this->GetActivePerspective();
     return persp != 0 && persp->ContainsView(part.Cast<IViewPart> ());
   }
   return false;
 }
 
 bool WorkbenchPage::Close()
 {
   bool ret;
   //BusyIndicator.showWhile(0, new Runnable()
   //    {
   //    public void WorkbenchPage::run()
   //      {
   ret = window->ClosePage(IWorkbenchPage::Pointer(this), true);
   //      }
   //    });
   return ret;
 }
 
 bool WorkbenchPage::CloseAllSavedEditors()
 {
   // get the Saved editors
   QList<IEditorReference::Pointer> editors = this->GetEditorReferences();
   QList<IEditorReference::Pointer> savedEditors;
   for (QList<IEditorReference::Pointer>::iterator iter = editors.begin(); iter
       != editors.end(); ++iter)
   {
     IEditorReference::Pointer editor = *iter;
     if (!editor->IsDirty())
     {
       savedEditors.push_back(editor);
     }
   }
   //there are no unsaved editors
   if (savedEditors.empty())
   {
     return true;
   }
 
   return this->CloseEditors(savedEditors, false);
 }
 
 bool WorkbenchPage::CloseAllEditors(bool save)
 {
   return this->CloseEditors(this->GetEditorReferences(), save);
 }
 
 void WorkbenchPage::UpdateActivePart()
 {
 
   if (this->IsDeferred())
   {
     return;
   }
 
   IWorkbenchPartReference::Pointer oldActivePart =
       partList->GetActivePartReference();
   IWorkbenchPartReference::Pointer oldActiveEditor =
       partList->GetActiveEditorReference();
   IWorkbenchPartReference::Pointer newActivePart;
   IEditorReference::Pointer newActiveEditor;
 
   if (!window->IsClosing())
   {
     // If an editor is active, try to keep an editor active
     if (oldActiveEditor && oldActivePart == oldActiveEditor)
     {
       newActiveEditor = activationList->GetActiveReference(true).Cast<
           IEditorReference> ();
       newActivePart = newActiveEditor;
       if (newActivePart == 0)
       {
         // Only activate a non-editor if there's no editors left
         newActivePart = activationList->GetActiveReference(false);
       }
     }
     else
     {
       // If a non-editor is active, activate whatever was activated most recently
       newActivePart = activationList->GetActiveReference(false);
 
       if (newActivePart.Cast<IEditorReference> () != 0)
       {
         // If that happens to be an editor, make it the active editor as well
         newActiveEditor = newActivePart.Cast<IEditorReference> ();
       }
       else
       {
         // Otherwise, select whatever editor was most recently active
         newActiveEditor = activationList->GetActiveReference(true).Cast<
             IEditorReference> ();
       }
     }
   }
 
   if (oldActiveEditor != newActiveEditor)
   {
     this->MakeActiveEditor(newActiveEditor);
   }
 
   if (newActivePart != oldActivePart)
   {
     this->MakeActive(newActivePart);
   }
 }
 
 void WorkbenchPage::MakeActive(IWorkbenchPartReference::Pointer ref)
 {
   if (ref == 0)
   {
     this->SetActivePart(IWorkbenchPart::Pointer(0));
   }
   else
   {
     IWorkbenchPart::Pointer newActive = ref->GetPart(true);
     if (newActive == 0)
     {
       this->SetActivePart(IWorkbenchPart::Pointer(0));
     }
     else
     {
       this->Activate(newActive);
     }
   }
 }
 
 void WorkbenchPage::MakeActiveEditor(IEditorReference::Pointer ref)
 {
   if (ref == this->GetActiveEditorReference())
   {
     return;
   }
 
   IEditorPart::Pointer part = (ref == 0) ? IEditorPart::Pointer(0)
       : ref->GetEditor(true);
 
   if (part)
   {
     editorMgr->SetVisibleEditor(ref, false);
     //navigationHistory.MarkEditor(part);
   }
 
   actionSwitcher.UpdateTopEditor(part);
 
   if (ref)
   {
     activationList->BringToTop(this->GetReference(part));
   }
 
   partList->SetActiveEditor(ref);
 }
 
 bool WorkbenchPage::CloseEditors(
     const QList<IEditorReference::Pointer>& refArray, bool save)
 {
   if (refArray.empty())
   {
     return true;
   }
 
   IWorkbenchPage::Pointer thisPage(this);
 
   // Check if we're being asked to close any parts that are already closed or cannot
   // be closed at this time
   QList<IEditorReference::Pointer> editorRefs;
   for (QList<IEditorReference::Pointer>::const_iterator iter =
       refArray.begin(); iter != refArray.end(); ++iter)
   {
     IEditorReference::Pointer reference = *iter;
 
     // If we're in the middle of creating this part, this is a programming error. Abort the entire
     // close operation. This usually occurs if someone tries to open a dialog in a method that
     // isn't allowed to do so, and a *syncExec tries to close the part. If this shows up in a log
     // file with a dialog's event loop on the stack, then the code that opened the dialog is usually
     // at fault.
     if (partBeingActivated == reference)
     {
       ctkRuntimeException re(
           "WARNING: Blocked recursive attempt to close part "
               + partBeingActivated->GetId()
               + " while still in the middle of activating it");
       WorkbenchPlugin::Log(re);
       return false;
     }
 
     //    if (reference.Cast<WorkbenchPartReference> () != 0)
     //    {
     //      WorkbenchPartReference::Pointer ref = reference.Cast<WorkbenchPartReference>();
     //
     //      // If we're being asked to close a part that is disposed (ie: already closed),
     //      // skip it and proceed with closing the remaining parts.
     //      if (ref.isDisposed())
     //      {
     //        continue;
     //      }
     //    }
 
     editorRefs.push_back(reference);
   }
 
   // notify the model manager before the close
   QList<IWorkbenchPart::Pointer> partsToClose;
   for (int i = 0; i < editorRefs.size(); i++)
   {
     IWorkbenchPart::Pointer refPart = editorRefs[i]->GetPart(false);
     if (refPart != 0)
     {
       partsToClose.push_back(refPart);
     }
   }
   SaveablesList::Pointer modelManager;
   SaveablesList::PostCloseInfo::Pointer postCloseInfo;
   if (partsToClose.size() > 0)
   {
     modelManager = dynamic_cast<SaveablesList*>(
           this->GetWorkbenchWindow()->GetService<ISaveablesLifecycleListener>());
     // this may prompt for saving and return 0 if the user canceled:
     postCloseInfo = modelManager->PreCloseParts(partsToClose, save,
         this->GetWorkbenchWindow());
     if (postCloseInfo == 0)
     {
       return false;
     }
   }
 
   // Fire pre-removal changes
   for (int i = 0; i < editorRefs.size(); i++)
   {
     IEditorReference::Pointer ref = editorRefs[i];
 
     // Notify interested listeners before the close
     window->FirePerspectiveChanged(thisPage, this->GetPerspective(), ref,
         CHANGE_EDITOR_CLOSE);
 
   }
 
   this->DeferUpdates(true);
   try
   {
     if (modelManager != 0)
     {
       modelManager->PostClose(postCloseInfo);
     }
 
     // Close all editors.
     for (int i = 0; i < editorRefs.size(); i++)
     {
       IEditorReference::Pointer ref = editorRefs[i];
 
       // Remove editor from the presentation
       editorPresentation->CloseEditor(ref);
 
       this->PartRemoved(ref.Cast<WorkbenchPartReference> ());
     }
   } catch (...)
   {
   }
   this->DeferUpdates(false);
 
   // Notify interested listeners after the close
   window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
       CHANGE_EDITOR_CLOSE);
 
   // Return true on success.
   return true;
 }
 
 void WorkbenchPage::DeferUpdates(bool shouldDefer)
 {
   if (shouldDefer)
   {
     if (deferCount == 0)
     {
       this->StartDeferring();
     }
     deferCount++;
   }
   else
   {
     deferCount--;
     if (deferCount == 0)
     {
       this->HandleDeferredEvents();
     }
   }
 }
 
 void WorkbenchPage::StartDeferring()
 {
   //editorPresentation.getLayoutPart().deferUpdates(true);
 }
 
 void WorkbenchPage::HandleDeferredEvents()
 {
   editorPresentation->GetLayoutPart()->DeferUpdates(false);
   this->UpdateActivePart();
   QList<WorkbenchPartReference::Pointer> disposals = pendingDisposals;
   pendingDisposals.clear();
   for (int i = 0; i < disposals.size(); i++)
   {
     this->DisposePart(disposals[i]);
   }
 
 }
 
 bool WorkbenchPage::IsDeferred()
 {
   return deferCount > 0;
 }
 
 bool WorkbenchPage::CloseEditor(IEditorReference::Pointer editorRef, bool save)
 {
   QList<IEditorReference::Pointer> list;
   list.push_back(editorRef);
   return this->CloseEditors(list, save);
 }
 
 bool WorkbenchPage::CloseEditor(IEditorPart::Pointer editor, bool save)
 {
   IWorkbenchPartReference::Pointer ref = this->GetReference(editor);
   if (ref.Cast<IEditorReference> ().IsNotNull())
   {
     QList<IEditorReference::Pointer> list;
     list.push_back(ref.Cast<IEditorReference> ());
     return this->CloseEditors(list, save);
   }
   return false;
 }
 
 void WorkbenchPage::CloseCurrentPerspective(bool saveParts, bool closePage)
 {
     Perspective::Pointer persp = this->GetActivePerspective();
     if (persp != 0)
     {
       this->ClosePerspective(persp, saveParts, closePage);
     }
 }
 
 void WorkbenchPage::ClosePerspective(IPerspectiveDescriptor::Pointer desc,
     bool saveParts, bool closePage)
 {
   Perspective::Pointer persp = this->FindPerspective(desc);
   if (persp != 0)
   {
     this->ClosePerspective(persp, saveParts, closePage);
   }
 }
 
 void WorkbenchPage::ClosePerspective(Perspective::Pointer persp,
     bool saveParts, bool closePage)
 {
 
   //  // Always unzoom
   //  if (isZoomed())
   //  {
   //    zoomOut();
   //  }
 
   QList<IWorkbenchPart::Pointer> partsToSave;
   QList<IWorkbenchPart::Pointer> viewsToClose;
   // collect views that will go away and views that are dirty
   QList<IViewReference::Pointer> viewReferences =
       persp->GetViewReferences();
   for (int i = 0; i < viewReferences.size(); i++)
   {
     IViewReference::Pointer reference = viewReferences[i];
     if (this->GetViewFactory()->GetReferenceCount(reference) == 1)
     {
       IViewPart::Pointer viewPart = reference->GetView(false);
       if (viewPart != 0)
       {
         viewsToClose.push_back(viewPart);
         if (saveParts && reference->IsDirty())
         {
           partsToSave.push_back(viewPart);
         }
       }
     }
   }
   if (saveParts && perspList.Size() == 1)
   {
     // collect editors that are dirty
     QList<IEditorReference::Pointer> editorReferences =
         this->GetEditorReferences();
     for (QList<IEditorReference::Pointer>::iterator refIter =
         editorReferences.begin(); refIter != editorReferences.end(); ++refIter)
     {
       IEditorReference::Pointer reference = *refIter;
       if (reference->IsDirty())
       {
         IEditorPart::Pointer editorPart = reference->GetEditor(false);
         if (editorPart != 0)
         {
           partsToSave.push_back(editorPart);
         }
       }
     }
   }
   if (saveParts && !partsToSave.empty())
   {
     if (!EditorManager::SaveAll(partsToSave, true, true, false,
         IWorkbenchWindow::Pointer(window)))
     {
       // user canceled
       return;
     }
   }
   // Close all editors on last perspective close
   if (perspList.Size() == 1 && this->GetEditorManager()->GetEditorCount() > 0)
   {
     // Close all editors
     if (!this->CloseAllEditors(false))
     {
       return;
     }
   }
 
   // closeAllEditors already notified the saveables list about the editors.
   SaveablesList::Pointer saveablesList(
         dynamic_cast<SaveablesList*>(
           this->GetWorkbenchWindow()->GetWorkbench()->GetService<ISaveablesLifecycleListener>()));
   // we took care of the saving already, so pass in false (postCloseInfo will be non-0)
   SaveablesList::PostCloseInfo::Pointer postCloseInfo =
       saveablesList->PreCloseParts(viewsToClose, false,
           this->GetWorkbenchWindow());
   saveablesList->PostClose(postCloseInfo);
 
   // Dispose of the perspective
   bool isActive = (perspList.GetActive() == persp);
   if (isActive)
   {
     this->SetPerspective(perspList.GetNextActive());
   }
   this->DisposePerspective(persp, true);
   if (closePage && perspList.Size() == 0)
   {
     this->Close();
   }
 }
 
 void WorkbenchPage::CloseAllPerspectives(bool saveEditors, bool closePage)
 {
 
   if (perspList.IsEmpty())
   {
     return;
   }
 
   //  // Always unzoom
   //  if (isZoomed())
   //  {
   //    zoomOut();
   //  }
 
   if (saveEditors)
   {
     if (!this->SaveAllEditors(true))
     {
       return;
     }
   }
   // Close all editors
   if (!this->CloseAllEditors(false))
   {
     return;
   }
 
   // Deactivate the active perspective and part
   this->SetPerspective(Perspective::Pointer(0));
 
   // Close each perspective in turn
   PerspectiveList oldList = perspList;
   perspList = PerspectiveList();
   for (PerspectiveList::iterator itr = oldList.Begin(); itr != oldList.End(); ++itr)
   {
     this->ClosePerspective(*itr, false, false);
   }
   if (closePage)
   {
     this->Close();
   }
 }
 
 void WorkbenchPage::CreateClientComposite()
 {
   void* parent = window->GetPageComposite();
   //  StartupThreading.runWithoutExceptions(new StartupRunnable()
   //      {
   //
   //      public void WorkbenchPage::runWithException()
   //        {
   composite
       = Tweaklets::Get(WorkbenchPageTweaklet::KEY)->CreateClientComposite(
           parent);
   Tweaklets::Get(GuiWidgetsTweaklet::KEY)->SetVisible(composite, false); // Make visible on activate.
   // force the client composite to be layed out
   //          parent.layout();
   //        }
   //      });
 
 }
 
 Perspective::Pointer WorkbenchPage::CreatePerspective(
     PerspectiveDescriptor::Pointer desc, bool notify)
 {
   QString label = desc->GetId(); // debugging only
   try
   {
     //UIStats.start(UIStats.CREATE_PERSPECTIVE, label);
     WorkbenchPage::Pointer thisPage(this);
     Perspective::Pointer persp(new Perspective(desc, thisPage));
     perspList.Add(persp);
     if (notify)
     {
       window->FirePerspectiveOpened(thisPage, desc);
     }
     //if the perspective is fresh and uncustomzied then it is not dirty
     //no reset will be prompted for
     if (!desc->HasCustomDefinition())
     {
       dirtyPerspectives.erase(desc->GetId());
     }
     return persp;
   } catch (WorkbenchException& /*e*/)
   {
     if (!window->GetWorkbenchImpl()->IsStarting())
     {
-      MessageDialog::OpenError(window->GetShell(), "Error",
-          "Problems opening perspective \"" + desc->GetId() + "\"");
+      QMessageBox::critical(reinterpret_cast<QWidget*>(window->GetShell()->GetControl()),
+                            "Error",
+                            "Problems opening perspective \"" + desc->GetId() + "\"");
     }
     return Perspective::Pointer(0);
   }
   //    finally
   //    {
   //      UIStats.end(UIStats.CREATE_PERSPECTIVE, desc.getId(), label);
   //    }
 }
 
 void WorkbenchPage::PartAdded(WorkbenchPartReference::Pointer ref)
 {
   activationList->Add(ref);
   partList->AddPart(ref);
   this->UpdateActivePart();
 }
 
 void WorkbenchPage::PartRemoved(WorkbenchPartReference::Pointer ref)
 {
   activationList->Remove(ref);
   this->DisposePart(ref);
 }
 
 void WorkbenchPage::DisposePart(WorkbenchPartReference::Pointer ref)
 {
   if (this->IsDeferred())
   {
     pendingDisposals.push_back(ref);
   }
   else
   {
     partList->RemovePart(ref);
     ref->Dispose();
   }
 }
 
 void WorkbenchPage::DeactivatePart(IWorkbenchPart::Pointer part)
 {
   if (part.IsNotNull())
   {
     PartSite::Pointer site = part->GetSite().Cast<PartSite> ();
     site->GetPane()->ShowFocus(false);
   }
 }
 
 void WorkbenchPage::DetachView(IViewReference::Pointer ref)
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0)
   {
     return;
   }
 
   PerspectiveHelper* presentation = persp->GetPresentation();
   presentation->DetachPart(ref);
 }
 
 void WorkbenchPage::AttachView(IViewReference::Pointer ref)
 {
   PerspectiveHelper* presentation = this->GetPerspectivePresentation();
   presentation->AttachPart(ref);
 }
 
 WorkbenchPage::~WorkbenchPage()
 {
   // increment reference count to prevent recursive deletes
   this->Register();
 
   {
     {
 
       this->MakeActiveEditor(IEditorReference::Pointer(0));
       this->MakeActive(IWorkbenchPartReference::Pointer(0));
 
       // Close and dispose the editors.
       this->CloseAllEditors(false);
 
       // Need to make sure model data is cleaned up when the page is
       // disposed. Collect all the views on the page and notify the
       // saveable list of a pre/post close. This will free model data.
       QList<IWorkbenchPartReference::Pointer> partsToClose =
           this->GetOpenParts();
       QList<IWorkbenchPart::Pointer> dirtyParts;
       for (int i = 0; i < partsToClose.size(); i++)
       {
         IWorkbenchPart::Pointer part = partsToClose[i]->GetPart(false);
         if (part != 0 && part.Cast<IViewPart> () != 0)
         {
           dirtyParts.push_back(part);
         }
       }
       SaveablesList::Pointer saveablesList(dynamic_cast<SaveablesList*>(
           this->GetWorkbenchWindow()->GetWorkbench()->GetService<ISaveablesLifecycleListener>()));
       SaveablesList::PostCloseInfo::Pointer postCloseInfo =
           saveablesList->PreCloseParts(dirtyParts, false,
               this->GetWorkbenchWindow());
       saveablesList->PostClose(postCloseInfo);
 
       IWorkbenchPage::Pointer thisPage(this);
       // Get rid of perspectives. This will close the views
       for (PerspectiveList::iterator itr = perspList.Begin(); itr
           != perspList.End(); ++itr)
       {
         Perspective::Pointer perspective = *itr;
         window->FirePerspectiveClosed(thisPage, perspective->GetDesc());
         //perspective->Dispose();
       }
       perspList = PerspectiveList();
 
       // Get rid of editor presentation.
       //editorPresentation->Dispose();
 
       // Get rid of composite.
       //composite.dispose();
 
       //navigationHistory.dispose();
 
       //stickyViewMan.clear();
 
       //  if (tracker != 0)
       //  {
       //    tracker.close();
       //  }
 
       //  // if we're destroying a window in a non-shutdown situation then we should
       //  // clean up the working set we made.
       //  if (!window->GetWorkbench()->IsClosing())
       //  {
       //    if (aggregateWorkingSet != 0)
       //    {
       //      PlatformUI.getWorkbench().getWorkingSetManager().removeWorkingSet(
       //          aggregateWorkingSet);
       //    }
       //  }
     }
 
     partBeingActivated = 0;
     pendingDisposals.clear();
 
     stickyViewMan = 0;
     delete viewFactory;
     delete editorPresentation;
     delete editorMgr;
     delete activationList;
 
     deferredActivePersp = 0;
 
     dirtyPerspectives.clear();
 
     delete selectionService;
     partList.reset();
 
   }
 
   // decrement reference count again, without explicit deletion
   this->UnRegister(false);
 }
 
 void WorkbenchPage::DisposePerspective(Perspective::Pointer persp, bool notify)
 {
   // Get rid of perspective.
   perspList.Remove(persp);
   if (notify)
   {
     IWorkbenchPage::Pointer thisPage(this);
     window->FirePerspectiveClosed(thisPage, persp->GetDesc());
   }
   //persp->Dispose();
 
   stickyViewMan->Remove(persp->GetDesc()->GetId());
 }
 
 Perspective::Pointer WorkbenchPage::FindPerspective(
     IPerspectiveDescriptor::Pointer desc)
 {
   for (PerspectiveList::iterator itr = perspList.Begin(); itr
       != perspList.End(); ++itr)
   {
     Perspective::Pointer mgr = *itr;
     if (desc->GetId() == mgr->GetDesc()->GetId())
     {
       return mgr;
     }
   }
   return Perspective::Pointer(0);
 }
 
 IViewPart::Pointer WorkbenchPage::FindView(const QString& id)
 {
   IViewReference::Pointer ref = this->FindViewReference(id);
   if (ref == 0)
   {
     return IViewPart::Pointer(0);
   }
   return ref->GetView(true);
 }
 
 IViewReference::Pointer WorkbenchPage::FindViewReference(
     const QString& viewId)
 {
   return this->FindViewReference(viewId, "");
 }
 
 IViewReference::Pointer WorkbenchPage::FindViewReference(
     const QString& viewId, const QString& secondaryId)
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0)
   {
     return IViewReference::Pointer(0);
   }
   return persp->FindView(viewId, secondaryId);
 }
 
 IEditorPart::Pointer WorkbenchPage::GetActiveEditor()
 {
   return partList->GetActiveEditor();
 }
 
 IEditorReference::Pointer WorkbenchPage::GetActiveEditorReference()
 {
   return partList->GetActiveEditorReference();
 }
 
 IWorkbenchPart::Pointer WorkbenchPage::GetActivePart()
 {
   return partList->GetActivePart();
 }
 
 IWorkbenchPartReference::Pointer WorkbenchPage::GetActivePartReference()
 {
   return partList->GetActivePartReference();
 }
 
 Perspective::Pointer WorkbenchPage::GetActivePerspective()
 {
   return perspList.GetActive();
 }
 
 void* WorkbenchPage::GetClientComposite()
 {
   return composite;
 }
 
 EditorManager* WorkbenchPage::GetEditorManager()
 {
   return editorMgr;
 }
 
 PerspectiveHelper* WorkbenchPage::GetPerspectivePresentation()
 {
   if (this->GetActivePerspective() != 0)
   {
     return this->GetActivePerspective()->GetPresentation();
   }
   return 0;
 }
 
 bool WorkbenchPage::HasView(const QString& perspectiveId, const QString& viewId)
 {
   PerspectiveList::PerspectiveListType list = perspList.GetSortedPerspectives();
   for ( PerspectiveList::PerspectiveListType::iterator it = list.begin(); it!=list.end(); it++)
   {
     SmartPointer<Perspective> p = *it;
     if (p->GetDesc()->GetId() == perspectiveId)
     {
       if (p->ContainsView(viewId))
       {
         return true;
       }
     }
   }
   return false;
 }
 
 /**
  * Answer the editor presentation.
  */
 EditorAreaHelper* WorkbenchPage::GetEditorPresentation()
 {
   return editorPresentation;
 }
 
 QList<IEditorPart::Pointer> WorkbenchPage::GetEditors()
 {
   QList<IEditorReference::Pointer> refs = this->GetEditorReferences();
   QList<IEditorPart::Pointer> result;
   //Display d = getWorkbenchWindow().getShell().getDisplay();
   //Must be backward compatible.
   //    d.syncExec(new Runnable()
   //        {
   //        public void WorkbenchPage::run()
   //          {
   for (QList<IEditorReference::Pointer>::iterator iter = refs.begin(); iter
       != refs.end(); ++iter)
   {
     IEditorPart::Pointer part = (*iter)->GetEditor(true);
     if (part != 0)
     {
       result.push_back(part);
     }
   }
   //          }
   //        });
   return result;
 }
 
 QList<IEditorPart::Pointer> WorkbenchPage::GetDirtyEditors()
 {
   return this->GetEditorManager()->GetDirtyEditors();
 }
 
 QList<ISaveablePart::Pointer> WorkbenchPage::GetDirtyParts()
 {
   QList<ISaveablePart::Pointer> result;
   QList<IWorkbenchPartReference::Pointer> allParts = this->GetAllParts();
   for (int i = 0; i < allParts.size(); i++)
   {
     IWorkbenchPartReference::Pointer reference = allParts[i];
 
     IWorkbenchPart::Pointer part = reference->GetPart(false);
     if (part != 0 && part.Cast<ISaveablePart> () != 0)
     {
       ISaveablePart::Pointer saveable = part.Cast<ISaveablePart> ();
       if (saveable->IsDirty())
       {
         result.push_back(saveable);
       }
     }
   }
 
   return result;
 }
 
 IEditorPart::Pointer WorkbenchPage::FindEditor(IEditorInput::Pointer input)
 {
   return this->GetEditorManager()->FindEditor(input);
 }
 
 QList<IEditorReference::Pointer> WorkbenchPage::FindEditors(
     IEditorInput::Pointer input, const QString& editorId, int matchFlags)
 {
   return this->GetEditorManager()->FindEditors(input, editorId, matchFlags);
 }
 
 QList<IEditorReference::Pointer> WorkbenchPage::GetEditorReferences()
 {
   return editorPresentation->GetEditors();
 }
 
 IAdaptable* WorkbenchPage::GetInput()
 {
   return input;
 }
 
 QString WorkbenchPage::GetLabel()
 {
   QString label = "<Unknown label>";
   //    IWorkbenchAdapter adapter = (IWorkbenchAdapter) Util.getAdapter(input,
   //        IWorkbenchAdapter.class);
   //    if (adapter != 0)
   //    {
   //      label = adapter.getLabel(input);
   //    }
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp != 0)
   {
     label = label + " - " + persp->GetDesc()->GetLabel();
   }
   else if (deferredActivePersp != 0)
   {
     label = label + " - " + deferredActivePersp->GetLabel();
   }
   return label;
 }
 
 IPerspectiveDescriptor::Pointer WorkbenchPage::GetPerspective()
 {
   if (deferredActivePersp != 0)
   {
     return deferredActivePersp;
   }
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp != 0)
   {
     return persp->GetDesc();
   }
   else
   {
     return IPerspectiveDescriptor::Pointer(0);
   }
 }
 
 ISelection::ConstPointer WorkbenchPage::GetSelection() const
 {
   return selectionService->GetSelection();
 }
 
 ISelection::ConstPointer WorkbenchPage::GetSelection(const QString& partId)
 {
   return selectionService->GetSelection(partId);
 }
 
 //ISelectionService::SelectionEvents& WorkbenchPage::GetSelectionEvents(const QString& partId)
 //{
 //  return selectionService->GetSelectionEvents(partId);
 //}
 
 ViewFactory* WorkbenchPage::GetViewFactory()
 {
   if (viewFactory == 0)
   {
     viewFactory = new ViewFactory(this,
         WorkbenchPlugin::GetDefault()->GetViewRegistry());
   }
   return viewFactory;
 }
 
 QList<IViewReference::Pointer> WorkbenchPage::GetViewReferences()
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp != 0)
   {
     return persp->GetViewReferences();
   }
   else
   {
     return QList<IViewReference::Pointer>();
   }
 }
 
 QList<IViewPart::Pointer> WorkbenchPage::GetViews()
 {
   return this->GetViews(Perspective::Pointer(0), true);
 }
 
 QList<IViewPart::Pointer> WorkbenchPage::GetViews(
     Perspective::Pointer persp, bool restore)
 {
   if (persp == 0)
   {
     persp = this->GetActivePerspective();
   }
 
   QList<IViewPart::Pointer> parts;
   if (persp != 0)
   {
     QList<IViewReference::Pointer> refs = persp->GetViewReferences();
     for (int i = 0; i < refs.size(); i++)
     {
       IViewPart::Pointer part = refs[i]->GetPart(restore).Cast<IViewPart> ();
       if (part != 0)
       {
         parts.push_back(part);
       }
     }
   }
   return parts;
 }
 
 IWorkbenchWindow::Pointer WorkbenchPage::GetWorkbenchWindow()
 {
   return IWorkbenchWindow::Pointer(window);
 }
 
 void WorkbenchPage::HideView(IViewReference::Pointer ref)
 {
 
   // Sanity check.
   if (ref == 0)
   {
     return;
   }
 
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0)
   {
     return;
   }
 
   bool promptedForSave = false;
   IViewPart::Pointer view = ref->GetView(false);
   if (view != 0)
   {
 
     if (!this->CertifyPart(view))
     {
       return;
     }
 
     // Confirm.
     if (view.Cast<ISaveablePart> () != 0)
     {
       ISaveablePart::Pointer saveable = view.Cast<ISaveablePart> ();
       if (saveable->IsSaveOnCloseNeeded())
       {
         IWorkbenchWindow::Pointer window =
             view->GetSite()->GetWorkbenchWindow();
         QList<IWorkbenchPart::Pointer> partsToSave;
         partsToSave.push_back(view);
         bool success = EditorManager::SaveAll(partsToSave, true, true, false,
             window);
         if (!success)
         {
           // the user cancelled.
           return;
         }
         promptedForSave = true;
       }
     }
   }
 
   int refCount = this->GetViewFactory()->GetReferenceCount(ref);
   SaveablesList* saveablesList = NULL;
   SaveablesList::PostCloseInfo::Pointer postCloseInfo;
   if (refCount == 1)
   {
     IWorkbenchPart::Pointer actualPart = ref->GetPart(false);
     if (actualPart != 0)
     {
       saveablesList = dynamic_cast<SaveablesList*>(
             actualPart->GetSite()->GetService<ISaveablesLifecycleListener>());
       QList<IWorkbenchPart::Pointer> partsToClose;
       partsToClose.push_back(actualPart);
       postCloseInfo = saveablesList->PreCloseParts(partsToClose,
           !promptedForSave, this->GetWorkbenchWindow());
       if (postCloseInfo == 0)
       {
         // cancel
         return;
       }
     }
   }
 
   IWorkbenchPage::Pointer thisPage(this);
   // Notify interested listeners before the hide
   window->FirePerspectiveChanged(thisPage, persp->GetDesc(), ref,
       CHANGE_VIEW_HIDE);
 
   PartPane::Pointer pane = this->GetPane(ref.Cast<IWorkbenchPartReference> ());
   pane->SetInLayout(false);
 
   this->UpdateActivePart();
 
   if (saveablesList != 0)
   {
     saveablesList->PostClose(postCloseInfo);
   }
 
   // Hide the part.
   persp->HideView(ref);
 
   // Notify interested listeners after the hide
   window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
       CHANGE_VIEW_HIDE);
 }
 
 void WorkbenchPage::RefreshActiveView()
 {
   this->UpdateActivePart();
 }
 
 void WorkbenchPage::HideView(IViewPart::Pointer view)
 {
   this->HideView(this->GetReference(view).Cast<IViewReference> ());
 }
 
 void WorkbenchPage::Init(WorkbenchWindow* w, const QString& layoutID,
     IAdaptable* input, bool openExtras)
 {
   // Save args.
   this->window = w;
   this->input = input;
   this->composite = 0;
   this->viewFactory = 0;
 
   this->activationList = new ActivationList(this);
   this->selectionService = new PageSelectionService(this);
   this->partList.reset(new WorkbenchPagePartList(this->selectionService));
   this->stickyViewMan = new StickyViewManager(this);
 
   //actionSets = new ActionSetManager(w);
 
   deferCount = 0;
 
   // Create presentation.
   this->CreateClientComposite();
   editorPresentation = new EditorAreaHelper(this);
   editorMgr = new EditorManager(WorkbenchWindow::Pointer(window),
       WorkbenchPage::Pointer(this), editorPresentation);
 
   //TODO WorkbenchPage perspective reorder listener?
   //    // add this page as a client to be notified when the UI has re-ordered perspectives
   //    // so that the order can be properly maintained in the receiver.
   //    // E.g. a UI might support drag-and-drop and will need to make this known to ensure
   //    // #saveState and #restoreState do not lose this re-ordering
   //    w.addPerspectiveReorderListener(new IReorderListener()
   //        {
   //        public void WorkbenchPage::reorder(Object perspective, int newLoc)
   //          {
   //            perspList.reorder((IPerspectiveDescriptor)perspective, newLoc);
   //          }
   //        });
 
   if (openExtras)
   {
     this->OpenPerspectiveExtras();
   }
 
   // Get perspective descriptor.
   if (layoutID != "")
   {
     PerspectiveDescriptor::Pointer
         desc =
             WorkbenchPlugin::GetDefault()->GetPerspectiveRegistry()->FindPerspectiveWithId(
                 layoutID).Cast<PerspectiveDescriptor> ();
     if (desc == 0)
     {
       throw WorkbenchException("Unable to create Perspective " + layoutID
           + ". There is no corresponding perspective extension.");
     }
     Perspective::Pointer persp = this->FindPerspective(desc);
     if (persp == 0)
     {
       persp = this->CreatePerspective(desc, true);
     }
     perspList.SetActive(persp);
     window->FirePerspectiveActivated(IWorkbenchPage::Pointer(this), desc);
   }
 
   //  getExtensionTracker() .registerHandler(perspectiveChangeHandler,
   //      ExtensionTracker .createExtensionPointFilter(
   //          getPerspectiveExtensionPoint()));
 }
 
 void WorkbenchPage::OpenPerspectiveExtras()
 {
   //TODO WorkbenchPage perspectice extras
   QString extras = ""; //PrefUtil.getAPIPreferenceStore().getString(
   //    IWorkbenchPreferenceConstants.PERSPECTIVE_BAR_EXTRAS);
   QList<IPerspectiveDescriptor::Pointer> descs;
   foreach (QString id, extras.split(", ", QString::SkipEmptyParts))
   {
     if (id.trimmed().isEmpty()) continue;
     IPerspectiveDescriptor::Pointer desc =
         WorkbenchPlugin::GetDefault()->GetPerspectiveRegistry()->FindPerspectiveWithId(id);
     if (desc != 0)
     {
       descs.push_back(desc);
     }
   }
   // HACK: The perspective switcher currently adds the button for a new perspective to the beginning of the list.
   // So, we process the extra perspectives in reverse order here to have their buttons appear in the order declared.
   for (int i = (int) descs.size(); --i >= 0;)
   {
     PerspectiveDescriptor::Pointer desc =
         descs[i].Cast<PerspectiveDescriptor> ();
     if (this->FindPerspective(desc) == 0)
     {
       this->CreatePerspective(desc, true);
     }
   }
 }
 
 bool WorkbenchPage::IsPartVisible(IWorkbenchPart::Pointer part)
 {
   PartPane::Pointer pane = this->GetPane(part);
   return pane != 0 && pane->GetVisible();
 }
 
 bool WorkbenchPage::IsEditorAreaVisible()
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0)
   {
     return false;
   }
   return persp->IsEditorAreaVisible();
 }
 
 bool WorkbenchPage::IsFastView(IViewReference::Pointer /*ref*/)
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp != 0)
   {
     //return persp->IsFastView(ref);
     return false;
   }
   else
   {
     return false;
   }
 }
 
 bool WorkbenchPage::IsCloseable(IViewReference::Pointer ref)
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp != 0)
   {
     return persp->IsCloseable(ref);
   }
   return false;
 }
 
 bool WorkbenchPage::IsMoveable(IViewReference::Pointer ref)
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp != 0)
   {
     return persp->IsMoveable(ref);
   }
   return false;
 }
 
 bool WorkbenchPage::IsFixedLayout()
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp != 0)
   {
     return persp->IsFixedLayout();
   }
   else
   {
     return false;
   }
 }
 
 bool WorkbenchPage::IsSaveNeeded()
 {
   return this->GetEditorManager()->IsSaveAllNeeded();
 }
 
 void WorkbenchPage::OnActivate()
 {
   Tweaklets::Get(GuiWidgetsTweaklet::KEY)->SetVisible(composite, true);
   Perspective::Pointer persp = this->GetActivePerspective();
 
   if (persp != 0)
   {
     persp->OnActivate();
     this->UpdateVisibility(Perspective::Pointer(0), persp);
   }
 }
 
 void WorkbenchPage::OnDeactivate()
 {
   this->MakeActiveEditor(IEditorReference::Pointer(0));
   this->MakeActive(IWorkbenchPartReference::Pointer(0));
   if (this->GetActivePerspective() != 0)
   {
     this->GetActivePerspective()->OnDeactivate();
   }
   Tweaklets::Get(GuiWidgetsTweaklet::KEY)->SetVisible(composite, false);
 }
 
 void WorkbenchPage::ReuseEditor(IReusableEditor::Pointer editor,
     IEditorInput::Pointer input)
 {
 
   // Rather than calling editor.setInput on the editor directly, we do it through the part reference.
   // This case lets us detect badly behaved editors that are not firing a PROP_INPUT event in response
   // to the input change... but if all editors obeyed their API contract, the "else" branch would be
   // sufficient.
   IWorkbenchPartReference::Pointer ref = this->GetReference(editor);
   if (ref.Cast<EditorReference> () != 0)
   {
     EditorReference::Pointer editorRef = ref.Cast<EditorReference> ();
 
     editorRef->SetInput(input);
   }
   else
   {
     editor->SetInput(input);
   }
   //navigationHistory.markEditor(editor);
 }
 
 IEditorPart::Pointer WorkbenchPage::OpenEditor(IEditorInput::Pointer input,
     const QString& editorID)
 {
   return this->OpenEditor(input, editorID, true, MATCH_INPUT);
 }
 
 IEditorPart::Pointer WorkbenchPage::OpenEditor(IEditorInput::Pointer input,
     const QString& editorID, bool activate)
 {
   return this->OpenEditor(input, editorID, activate, MATCH_INPUT);
 }
 
 IEditorPart::Pointer WorkbenchPage::OpenEditor(
     const IEditorInput::Pointer input, const QString& editorID,
     bool activate, int matchFlags)
 {
   return this->OpenEditor(input, editorID, activate, matchFlags,
       IMemento::Pointer(0));
 }
 
 IEditorPart::Pointer WorkbenchPage::OpenEditor(
     const IEditorInput::Pointer input, const QString& editorID,
     bool activate, int matchFlags, IMemento::Pointer editorState)
 {
   if (input == 0 || editorID == "")
   {
     throw Poco::InvalidArgumentException();
   }
 
   //    BusyIndicator.showWhile(window.getWorkbench().getDisplay(),
   //        new Runnable()
   //        {
   //        public void WorkbenchPage::run()
   //          {
   return this->BusyOpenEditor(input, editorID, activate, matchFlags,
       editorState);
 }
 
 IEditorPart::Pointer WorkbenchPage::OpenEditorFromDescriptor(
     IEditorInput::Pointer input, IEditorDescriptor::Pointer editorDescriptor,
     bool activate, IMemento::Pointer editorState)
 {
   if (input == 0 || !(editorDescriptor.Cast<EditorDescriptor> () != 0))
   {
     throw Poco::InvalidArgumentException();
   }
 
   //    BusyIndicator.showWhile(window.getWorkbench().getDisplay(),
   //        new Runnable()
   //        {
   //        public void WorkbenchPage::run()
   //          {
   return this->BusyOpenEditorFromDescriptor(input, editorDescriptor.Cast<
       EditorDescriptor> (), activate, editorState);
 
   //          }
   //        });
 
 }
 
 IEditorPart::Pointer WorkbenchPage::BusyOpenEditor(IEditorInput::Pointer input,
     const QString& editorID, bool activate, int matchFlags,
     IMemento::Pointer editorState)
 {
 
   Workbench* workbench =
       this->GetWorkbenchWindow().Cast<WorkbenchWindow> ()->GetWorkbenchImpl();
   workbench->LargeUpdateStart();
 
   IEditorPart::Pointer result;
   try
   {
     result = this->BusyOpenEditorBatched(input, editorID, activate, matchFlags,
         editorState);
 
   } catch (std::exception& e)
   {
     workbench->LargeUpdateEnd();
     throw e;
   }
 
   workbench->LargeUpdateEnd();
   return result;
 }
 
 IEditorPart::Pointer WorkbenchPage::BusyOpenEditorFromDescriptor(
     IEditorInput::Pointer input, EditorDescriptor::Pointer editorDescriptor,
     bool activate, IMemento::Pointer editorState)
 {
 
   Workbench* workbench =
       this->GetWorkbenchWindow().Cast<WorkbenchWindow> ()->GetWorkbenchImpl();
   workbench->LargeUpdateStart();
 
   IEditorPart::Pointer result;
   try
   {
     result = this->BusyOpenEditorFromDescriptorBatched(input, editorDescriptor,
         activate, editorState);
 
   } catch (std::exception& e)
   {
     workbench->LargeUpdateEnd();
     throw e;
   }
 
   workbench->LargeUpdateEnd();
   return result;
 }
 
 IEditorPart::Pointer WorkbenchPage::BusyOpenEditorBatched(
     IEditorInput::Pointer input, const QString& editorID, bool activate,
     int matchFlags, IMemento::Pointer editorState)
 {
 
   // If an editor already exists for the input, use it.
   IEditorPart::Pointer editor;
   // Reuse an existing open editor, unless we are in "new editor tab management" mode
   editor = this->GetEditorManager()->FindEditor(editorID, input, matchFlags);
   if (editor != 0)
   {
     if (IEditorRegistry::SYSTEM_EXTERNAL_EDITOR_ID == editorID)
     {
       if (editor->IsDirty())
       {
-        QList<QString> dlgLabels;
-        dlgLabels.push_back("Yes");
-        dlgLabels.push_back("No");
-        dlgLabels.push_back("Cancel");
-        IDialog::Pointer
-            dialog =
-                MessageDialog::CreateMessageDialog(
-                    this->GetWorkbenchWindow()->GetShell(),
-                    "Save",
-                    (void*) 0, // accept the default window icon
-                    "\"" + input->GetName()
-                        + "\" is opened and has unsaved changes. Do you want to save it?",
-                    IDialog::QUESTION, dlgLabels, 0);
-        int saveFile = dialog->Open();
-        if (saveFile == 0)
+        QMessageBox::StandardButton saveFile = QMessageBox::question(
+                                                 this->GetWorkbenchWindow()->GetShell()->GetControl(),
+                                                 "Save", "\"" + input->GetName() + "\" is opened and has unsaved changes. Do you want to save it?",
+                                                 QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Cancel);
+        if (saveFile == QMessageBox::Yes)
         {
           //          try
           //          {
           IEditorPart::Pointer editorToSave = editor;
           //              getWorkbenchWindow().run(false, false,
           //                  new IRunnableWithProgress()
           //                  {
           //                  public void WorkbenchPage::run(IProgressMonitor monitor)
           //                    throws InvocationTargetException,
           //                    InterruptedException
           //                    {
           //TODO progress monitor
           editorToSave->DoSave();//monitor);
           //                    }
           //                  });
           // }
           //              catch (InvocationTargetException& e)
           //              {
           //                throw(RuntimeException) e->GetTargetException();
           //              }
           //          catch (InterruptedException& e)
           //          {
           //            return 0;
           //          }
         }
-        else if (saveFile == 2)
+        else if (saveFile == QMessageBox::Cancel)
         {
           return IEditorPart::Pointer(0);
         }
       }
     }
     else
     {
       //          // do the IShowEditorInput notification before showing the editor
       //          // to reduce flicker
       //          if (editor.Cast<IShowEditorInput> () != 0)
       //          {
       //            ((IShowEditorInput) editor).showEditorInput(input);
       //          }
       this->ShowEditor(activate, editor);
       return editor;
     }
   }
 
   // Otherwise, create a new one. This may cause the new editor to
   // become the visible (i.e top) editor.
   IEditorReference::Pointer ref = this->GetEditorManager()->OpenEditor(
       editorID, input, true, editorState);
   if (ref != 0)
   {
     editor = ref->GetEditor(true);
   }
 
   if (editor != 0)
   {
     this->SetEditorAreaVisible(true);
     if (activate)
     {
       this->Activate(editor);
     }
     else
     {
       this->BringToTop(editor);
     }
     IWorkbenchPage::Pointer thisPage(this);
     window->FirePerspectiveChanged(thisPage, this->GetPerspective(), ref,
         CHANGE_EDITOR_OPEN);
     window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
         CHANGE_EDITOR_OPEN);
   }
 
   return editor;
 }
 
 /*
  * Added to fix Bug 178235 [EditorMgmt] DBCS 3.3 - Cannot open file with external program.
  * See openEditorFromDescriptor().
  */
 IEditorPart::Pointer WorkbenchPage::BusyOpenEditorFromDescriptorBatched(
     IEditorInput::Pointer input, EditorDescriptor::Pointer editorDescriptor,
     bool activate, IMemento::Pointer editorState)
 {
 
   IEditorPart::Pointer editor;
   // Create a new one. This may cause the new editor to
   // become the visible (i.e top) editor.
   IEditorReference::Pointer ref;
   ref = this->GetEditorManager()->OpenEditorFromDescriptor(editorDescriptor,
       input, editorState);
   if (ref != 0)
   {
     editor = ref->GetEditor(true);
   }
 
   if (editor != 0)
   {
     this->SetEditorAreaVisible(true);
     if (activate)
     {
 
       this->Activate(editor);
 
     }
     else
     {
       this->BringToTop(editor);
     }
     IWorkbenchPage::Pointer thisPage(this);
     window->FirePerspectiveChanged(thisPage, this->GetPerspective(), ref,
         CHANGE_EDITOR_OPEN);
     window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
         CHANGE_EDITOR_OPEN);
   }
 
   return editor;
 }
 
 void WorkbenchPage::OpenEmptyTab()
 {
   IEditorPart::Pointer editor;
   EditorReference::Pointer ref;
   ref = this->GetEditorManager()->OpenEmptyTab().Cast<EditorReference> ();
   if (ref != 0)
   {
     editor
         = ref->GetEmptyEditor(
             dynamic_cast<EditorRegistry*> (WorkbenchPlugin::GetDefault()->GetEditorRegistry())->FindEditor(
                 EditorRegistry::EMPTY_EDITOR_ID).Cast<EditorDescriptor> ());
   }
 
   if (editor != 0)
   {
     this->SetEditorAreaVisible(true);
     this->Activate(editor);
     IWorkbenchPage::Pointer thisPage(this);
     window->FirePerspectiveChanged(thisPage, this->GetPerspective(), ref,
         CHANGE_EDITOR_OPEN);
     window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
         CHANGE_EDITOR_OPEN);
   }
 }
 
 void WorkbenchPage::ShowEditor(bool activate, IEditorPart::Pointer editor)
 {
   this->SetEditorAreaVisible(true);
   if (activate)
   {
     //zoomOutIfNecessary(editor);
     this->Activate(editor);
   }
   else
   {
     this->BringToTop(editor);
   }
 }
 
 bool WorkbenchPage::IsEditorPinned(IEditorPart::Pointer editor)
 {
   WorkbenchPartReference::Pointer ref = this->GetReference(editor).Cast<
       WorkbenchPartReference> ();
   return ref != 0 && ref->IsPinned();
 }
 
 /**
  * Removes an IPartListener from the part service.
  */
 void WorkbenchPage::RemovePartListener(IPartListener* l)
 {
   partList->GetPartService()->RemovePartListener(l);
 }
 
 /**
  * Implements IWorkbenchPage
  *
  * @see org.blueberry.ui.IWorkbenchPage#removePropertyChangeListener(IPropertyChangeListener)
  * @since 2.0
  * @deprecated individual views should store a working set if needed and
  *             register a property change listener directly with the
  *             working set manager to receive notification when the view
  *             working set is removed.
  */
 //    void WorkbenchPage::RemovePropertyChangeListener(IPropertyChangeListener listener) {
 //        propertyChangeListeners.remove(listener);
 //    }
 
 
 void WorkbenchPage::RemoveSelectionListener(ISelectionListener* listener)
 {
   selectionService->RemoveSelectionListener(listener);
 }
 
 void WorkbenchPage::RemoveSelectionListener(const QString& partId,
                                             ISelectionListener* listener)
 {
   selectionService->RemoveSelectionListener(partId, listener);
 }
 
 void WorkbenchPage::RemovePostSelectionListener(ISelectionListener* listener)
 {
   selectionService->RemovePostSelectionListener(listener);
 }
 
 void WorkbenchPage::RemovePostSelectionListener(const QString& partId,
                                                 ISelectionListener* listener)
 {
   selectionService->RemovePostSelectionListener(partId, listener);
 }
 
 void WorkbenchPage::RequestActivation(IWorkbenchPart::Pointer part)
 {
   // Sanity check.
   if (!this->CertifyPart(part))
   {
     return;
   }
 
   // Real work.
   this->SetActivePart(part);
 }
 
 /**
  * Resets the layout for the perspective. The active part in the old layout
  * is activated in the new layout for consistent user context.
  */
 void WorkbenchPage::ResetPerspective()
 {
   // Run op in busy cursor.
   // Use set redraw to eliminate the "flash" that can occur in the
   // coolbar as the perspective is reset.
   //    ICoolBarManager2 mgr = (ICoolBarManager2) window.getCoolBarManager2();
   //    try
   //    {
   //      mgr.getControl2().setRedraw(false);
   //      BusyIndicator.showWhile(0, new Runnable()
   //          {
   //          public void WorkbenchPage::run()
   //            {
   this->BusyResetPerspective();
   //            }
   //          });
   //    }finally
   //    {
   //      mgr.getControl2().setRedraw(true);
   //    }
 }
 
 bool WorkbenchPage::RestoreState(IMemento::Pointer memento,
     const IPerspectiveDescriptor::Pointer activeDescriptor)
 {
   //    StartupThreading.runWithoutExceptions(new StartupRunnable()
   //        {
   //
   //        public void WorkbenchPage::runWithException() throws Throwable
   //          {
   this->DeferUpdates(true);
   //        }});
 
   try
   {
     // Restore working set
     QString pageName;
     memento->GetString(WorkbenchConstants::TAG_LABEL, pageName);
 
     //    String label = 0; // debugging only
     //    if (UIStats.isDebugging(UIStats.RESTORE_WORKBENCH))
     //    {
     //      label = pageName == 0 ? "" : "::" + pageName; //$NON-NLS-1$ //$NON-NLS-2$
     //    }
 
     try
     {
       //UIStats.start(UIStats.RESTORE_WORKBENCH, "WorkbenchPage" + label); //$NON-NLS-1$
       //      MultiStatus result =
       //          new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK, NLS.bind(
       //              WorkbenchMessages.WorkbenchPage_unableToRestorePerspective,
       //              pageName), 0);
       bool result = true;
 
       //      String workingSetName = memento .getString(
       //          IWorkbenchConstants.TAG_WORKING_SET);
       //      if (workingSetName != 0)
       //      {
       //        AbstractWorkingSetManager
       //            workingSetManager =
       //                (AbstractWorkingSetManager) getWorkbenchWindow() .getWorkbench().getWorkingSetManager();
       //        setWorkingSet(workingSetManager.getWorkingSet(workingSetName));
       //      }
       //
       //      IMemento workingSetMem = memento .getChild(
       //          IWorkbenchConstants.TAG_WORKING_SETS);
       //      if (workingSetMem != 0)
       //      {
       //        QList<IMemento::Pointer> workingSetChildren =
       //            workingSetMem .getChildren(IWorkbenchConstants.TAG_WORKING_SET);
       //        List workingSetList = new ArrayList(workingSetChildren.length);
       //        for (int i = 0; i < workingSetChildren.length; i++)
       //        {
       //          IWorkingSet
       //              set =
       //                  getWorkbenchWindow().getWorkbench() .getWorkingSetManager().getWorkingSet(
       //                      workingSetChildren[i].getID());
       //          if (set != 0)
       //          {
       //            workingSetList.add(set);
       //          }
       //        }
       //
       //        workingSets = (IWorkingSet[]) workingSetList .toArray(
       //            new IWorkingSet[workingSetList.size()]);
       //      }
       //
       //      aggregateWorkingSetId = memento.getString(ATT_AGGREGATE_WORKING_SET_ID);
       //
       //      IWorkingSet setWithId =
       //          window.getWorkbench().getWorkingSetManager().getWorkingSet(
       //              aggregateWorkingSetId);
       //
       //      // check to see if the set has already been made and assign it if it has
       //      if (setWithId.Cast<AggregateWorkingSet> () != 0)
       //      {
       //        aggregateWorkingSet = (AggregateWorkingSet) setWithId;
       //      }
 
       // Restore editor manager.
       IMemento::Pointer childMem = memento->GetChild(
           WorkbenchConstants::TAG_EDITORS);
       //result.merge(getEditorManager().restoreState(childMem));
       result &= this->GetEditorManager()->RestoreState(childMem);
 
       childMem = memento->GetChild(WorkbenchConstants::TAG_VIEWS);
       if (childMem)
       {
         //result.merge(getViewFactory().restoreState(childMem));
         result &= this->GetViewFactory()->RestoreState(childMem);
       }
 
       // Get persp block.
       childMem = memento->GetChild(WorkbenchConstants::TAG_PERSPECTIVES);
       QString activePartID;
       childMem->GetString(WorkbenchConstants::TAG_ACTIVE_PART, activePartID);
       QString activePartSecondaryID;
       if (!activePartID.isEmpty())
       {
         activePartSecondaryID = ViewFactory::ExtractSecondaryId(activePartID);
         if (!activePartSecondaryID.isEmpty())
         {
           activePartID = ViewFactory::ExtractPrimaryId(activePartID);
         }
       }
       QString activePerspectiveID;
       childMem->GetString(WorkbenchConstants::TAG_ACTIVE_PERSPECTIVE,
           activePerspectiveID);
 
       // Restore perspectives.
       QList<IMemento::Pointer> perspMems(childMem->GetChildren(
           WorkbenchConstants::TAG_PERSPECTIVE));
       Perspective::Pointer activePerspective;
 
       IPerspectiveDescriptor::Pointer validPersp;
       for (int i = 0; i < perspMems.size(); i++)
       {
 
         IMemento::Pointer current = perspMems[i];
         //          StartupThreading
         //          .runWithoutExceptions(new StartupRunnable()
         //              {
         //
         //              public void WorkbenchPage::runWithException() throws Throwable
         //                {
         Perspective::Pointer persp(new Perspective(
             PerspectiveDescriptor::Pointer(0), WorkbenchPage::Pointer(this)));
         //result.merge(persp.restoreState(current));
         result &= persp->RestoreState(current);
         IPerspectiveDescriptor::Pointer desc = persp->GetDesc();
         if (desc.IsNotNull())
         {
           validPersp=desc;
         } else
         {
           IPerspectiveDescriptor::Pointer desc = WorkbenchPlugin::GetDefault()->
       GetPerspectiveRegistry()->CreatePerspective("Hallo",validPersp);
         }
         if (desc == activeDescriptor)
         {
           activePerspective = persp;
         }
         else if ((activePerspective == 0) && desc->GetId()
             == activePerspectiveID)
         {
           activePerspective = persp;
         }
         perspList.Add(persp);
         //berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry()->Add
         window->FirePerspectiveOpened(WorkbenchPage::Pointer(this), desc);
         //                }
         //              });
       }
       bool restoreActivePerspective = false;
       if (!activeDescriptor)
       {
         restoreActivePerspective = true;
 
       }
       else if (activePerspective && activePerspective->GetDesc()
           == activeDescriptor)
       {
         restoreActivePerspective = true;
       }
       else
       {
         restoreActivePerspective = false;
         activePerspective = this->CreatePerspective(activeDescriptor.Cast<
             PerspectiveDescriptor> (), true);
         if (activePerspective == 0)
         {
           //          result .merge(
           //              new Status(IStatus.ERR, PlatformUI.PLUGIN_ID, 0, NLS.bind(
           //                  WorkbenchMessages.Workbench_showPerspectiveError,
           //                  activeDescriptor.getId()), 0));
           result &= false;
         }
       }
 
       perspList.SetActive(activePerspective);
 
       // Make sure we have a valid perspective to work with,
       // otherwise return.
       activePerspective = perspList.GetActive();
       if (activePerspective == 0)
       {
         activePerspective = perspList.GetNextActive();
         perspList.SetActive(activePerspective);
       }
       if (activePerspective && restoreActivePerspective)
       {
         //result.merge(activePerspective.restoreState());
         result &= activePerspective->RestoreState();
       }
 
       if (activePerspective)
       {
         Perspective::Pointer myPerspective = activePerspective;
         QString myActivePartId = activePartID;
         QString mySecondaryId = activePartSecondaryID;
         //          StartupThreading.runWithoutExceptions(new StartupRunnable()
         //              {
         //
         //              public void WorkbenchPage::runWithException() throws Throwable
         //                {
         window->FirePerspectiveActivated(WorkbenchPage::Pointer(this),
             myPerspective->GetDesc());
 
         // Restore active part.
         if (!myActivePartId.isEmpty())
         {
           IWorkbenchPartReference::Pointer ref = myPerspective->FindView(
               myActivePartId, mySecondaryId);
 
           if (ref)
           {
             activationList->SetActive(ref);
           }
         }
         // }});
 
       }
 
       //      childMem = memento->GetChild(WorkbenchConstants::TAG_NAVIGATION_HISTORY);
       //      if (childMem)
       //      {
       //        navigationHistory.restoreState(childMem);
       //      }
       //      else if (GetActiveEditor())
       //      {
       //        navigationHistory.markEditor(getActiveEditor());
       //      }
       //
       // restore sticky view state
       stickyViewMan->Restore(memento);
 
       //      QString blame = activeDescriptor == 0 ? pageName
       //          : activeDescriptor.getId();
       //      UIStats.end(UIStats.RESTORE_WORKBENCH, blame, "WorkbenchPage" + label); //$NON-NLS-1$
 
       //      StartupThreading.runWithoutExceptions(new StartupRunnable()
       //                {
       //                public void WorkbenchPage::runWithException() throws Throwable
       //                  {
       DeferUpdates(false);
       //            }
       //          });
 
       return result;
     } catch (...)
     {
       //      QString blame = activeDescriptor == 0 ? pageName
       //          : activeDescriptor.getId();
       //      UIStats.end(UIStats.RESTORE_WORKBENCH, blame, "WorkbenchPage" + label); //$NON-NLS-1$
       throw ;
     }
   }
   catch (...)
   {
     //      StartupThreading.runWithoutExceptions(new StartupRunnable()
     //                {
     //                public void WorkbenchPage::runWithException() throws Throwable
     //                  {
     DeferUpdates(false);
     //            }
     //          });
 
     throw;
   }
 
 }
 
 bool WorkbenchPage::SaveAllEditors(bool confirm)
 {
   return this->SaveAllEditors(confirm, false);
 }
 
 bool WorkbenchPage::SaveAllEditors(bool confirm, bool addNonPartSources)
 {
   return this->GetEditorManager()->SaveAll(confirm, false, addNonPartSources);
 }
 
 bool WorkbenchPage::SavePart(ISaveablePart::Pointer saveable,
     IWorkbenchPart::Pointer part, bool confirm)
 {
   // Do not certify part do allow editors inside a multipageeditor to
   // call this.
   return this->GetEditorManager()->SavePart(saveable, part, confirm);
 }
 
 bool WorkbenchPage::SaveEditor(IEditorPart::Pointer editor, bool confirm)
 {
   return this->SavePart(editor, editor, confirm);
 }
 
 /**
  * Saves the current perspective.
  */
 void WorkbenchPage::SavePerspective()
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0)
   {
     return;
   }
 
   //    // Always unzoom.
   //    if (isZoomed())
   //    {
   //      zoomOut();
   //    }
 
   persp->SaveDesc();
 }
 
 /**
  * Saves the perspective.
  */
 void WorkbenchPage::SavePerspectiveAs(IPerspectiveDescriptor::Pointer newDesc)
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0)
   {
     return;
   }
   IPerspectiveDescriptor::Pointer oldDesc = persp->GetDesc();
 
   //    // Always unzoom.
   //    if (isZoomed())
   //    {
   //      zoomOut();
   //    }
 
   persp->SaveDescAs(newDesc);
   window->FirePerspectiveSavedAs(IWorkbenchPage::Pointer(this), oldDesc, newDesc);
 }
 
 /**
  * Save the state of the page.
  */
 bool WorkbenchPage::SaveState(IMemento::Pointer memento)
 {
   //  // We must unzoom to get correct layout.
   //  if (isZoomed())
   //  {
   //    zoomOut();
   //  }
 
   //  MultiStatus
   //      result =
   //          new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK, NLS.bind(
   //              WorkbenchMessages.WorkbenchPage_unableToSavePerspective,
   //              getLabel()), 0);
   bool result = true;
 
   // Save editor manager.
   IMemento::Pointer childMem = memento->CreateChild(WorkbenchConstants::TAG_EDITORS);
   //result.merge(editorMgr.saveState(childMem));
   result &= editorMgr->SaveState(childMem);
 
   childMem = memento->CreateChild(WorkbenchConstants::TAG_VIEWS);
   //result.merge(getViewFactory().saveState(childMem));
   result &= this->GetViewFactory()->SaveState(childMem);
 
   // Create persp block.
   childMem = memento->CreateChild(WorkbenchConstants::TAG_PERSPECTIVES);
   if (this->GetPerspective())
   {
     childMem->PutString(WorkbenchConstants::TAG_ACTIVE_PERSPECTIVE,
         this->GetPerspective()->GetId());
   }
   if (this->GetActivePart() != 0)
   {
     if (this->GetActivePart().Cast<IViewPart> ())
     {
       IViewReference::Pointer ref = this->GetReference(this->GetActivePart()).Cast<IViewReference>();
       if (ref)
       {
         childMem->PutString(WorkbenchConstants::TAG_ACTIVE_PART,
             ViewFactory::GetKey(ref));
       }
     }
     else
     {
       childMem->PutString(WorkbenchConstants::TAG_ACTIVE_PART,
           this->GetActivePart()->GetSite()->GetId());
     }
   }
 
   // Save each perspective in opened order
   for (PerspectiveList::PerspectiveListType::iterator itr = perspList.Begin();
       itr != perspList.End(); ++itr)
   {
     IMemento::Pointer gChildMem = childMem->CreateChild(
         WorkbenchConstants::TAG_PERSPECTIVE);
     //result.merge(persp.saveState(gChildMem));
     result &= (*itr)->SaveState(gChildMem);
   }
   //  // Save working set if set
   //  if (workingSet != 0)
   //  {
   //    memento.putString(IWorkbenchConstants.TAG_WORKING_SET,
   //        workingSet .getName());
   //  }
   //
   //  IMemento workingSetMem = memento .createChild(
   //      IWorkbenchConstants.TAG_WORKING_SETS);
   //  for (int i = 0; i < workingSets.length; i++)
   //  {
   //    workingSetMem.createChild(IWorkbenchConstants.TAG_WORKING_SET,
   //        workingSets[i].getName());
   //  }
   //
   //  if (aggregateWorkingSetId != 0)
   //  {
   //    memento.putString(ATT_AGGREGATE_WORKING_SET_ID, aggregateWorkingSetId);
   //  }
   //
   //  navigationHistory.saveState(memento .createChild(
   //      IWorkbenchConstants.TAG_NAVIGATION_HISTORY));
   //
   // save the sticky activation state
   stickyViewMan->Save(memento);
 
   return result;
 }
 
 QString WorkbenchPage::GetId(IWorkbenchPart::Pointer part)
 {
   return this->GetId(this->GetReference(part));
 }
 
 QString WorkbenchPage::GetId(IWorkbenchPartReference::Pointer ref)
 {
   if (ref == 0)
   {
     return "0"; //$NON-NLS-1$
   }
   return ref->GetId();
 }
 
 void WorkbenchPage::SetActivePart(IWorkbenchPart::Pointer newPart)
 {
   // Optimize it.
   if (this->GetActivePart() == newPart)
   {
     return;
   }
 
   if (partBeingActivated != 0)
   {
     if (partBeingActivated->GetPart(false) != newPart)
     {
       WorkbenchPlugin::Log(ctkRuntimeException(
                              QString("WARNING: Prevented recursive attempt to activate part ")
                              + this->GetId(newPart)
                              + " while still in the middle of activating part " + this->GetId(
                                partBeingActivated)));
     }
     return;
   }
 
   //No need to change the history if the active editor is becoming the
   // active part
   //  String label = 0; // debugging only
   //  if (UIStats.isDebugging(UIStats.ACTIVATE_PART))
   //  {
   //    label = newPart != 0 ? newPart.getTitle() : "none"; //$NON-NLS-1$
   //  }
   try
   {
     IWorkbenchPartReference::Pointer partref = this->GetReference(newPart);
     IWorkbenchPartReference::Pointer realPartRef;
     if (newPart != 0)
     {
       IWorkbenchPartSite::Pointer site = newPart->GetSite();
       if (site.Cast<PartSite> () != 0)
       {
         realPartRef = site.Cast<PartSite> ()->GetPane()->GetPartReference();
       }
     }
 
     partBeingActivated = realPartRef;
 
     //UIStats.start(UIStats.ACTIVATE_PART, label);
     // Notify perspective. It may deactivate fast view.
     Perspective::Pointer persp = this->GetActivePerspective();
     if (persp != 0)
     {
       persp->PartActivated(newPart);
     }
 
     // Deactivate old part
     IWorkbenchPart::Pointer oldPart = this->GetActivePart();
     if (oldPart != 0)
     {
       this->DeactivatePart(oldPart);
     }
 
     // Set active part.
     if (newPart != 0)
     {
       activationList->SetActive(newPart);
       if (newPart.Cast<IEditorPart> () != 0)
       {
         this->MakeActiveEditor(realPartRef.Cast<IEditorReference> ());
       }
     }
     this->ActivatePart(newPart);
 
     actionSwitcher.UpdateActivePart(newPart);
 
     partList->SetActivePart(partref);
   }
   catch (std::exception& e)
   {
     partBeingActivated = 0;
     //    Object blame = newPart == 0 ? (Object) this : newPart;
     //    UIStats.end(UIStats.ACTIVATE_PART, blame, label);
     throw e;
   }
 
   partBeingActivated = 0;
 }
 
 void WorkbenchPage::SetEditorAreaVisible(bool showEditorArea)
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0)
   {
     return;
   }
   if (showEditorArea == persp->IsEditorAreaVisible())
   {
     return;
   }
   //  // If parts change always update zoom.
   //  if (isZoomed())
   //  {
   //    zoomOut();
   //  }
   // Update editor area visibility.
   IWorkbenchPage::Pointer thisPage(this);
   if (showEditorArea)
   {
     persp->ShowEditorArea();
     window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
         CHANGE_EDITOR_AREA_SHOW);
   }
   else
   {
     persp->HideEditorArea();
     this->UpdateActivePart();
     window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
         CHANGE_EDITOR_AREA_HIDE);
   }
 }
 
 /**
  * Sets the layout of the page. Assumes the new perspective is not 0.
  * Keeps the active part if possible. Updates the window menubar and
  * toolbar if necessary.
  */
 void WorkbenchPage::SetPerspective(Perspective::Pointer newPersp)
 {
   // Don't do anything if already active layout
   Perspective::Pointer oldPersp = this->GetActivePerspective();
   if (oldPersp == newPersp)
   {
     return;
   }
 
   window->LargeUpdateStart();
   std::exception exc;
   bool exceptionOccured = false;
   try
   {
     IWorkbenchPage::Pointer thisPage(this);
     if (oldPersp != 0)
     {
       // fire the pre-deactivate
       window->FirePerspectivePreDeactivate(thisPage, oldPersp->GetDesc());
     }
 
     if (newPersp != 0)
     {
       bool status = newPersp->RestoreState();
       if (!status)
       {
         QString title = "Restoring problems";
         QString msg = "Unable to read workbench state.";
-        MessageDialog::OpenError(this->GetWorkbenchWindow()->GetShell(), title,
-            msg);
+        QMessageBox::critical(reinterpret_cast<QWidget*>(this->GetWorkbenchWindow()->GetShell()->GetControl()),
+                                                         title, msg);
       }
     }
 
     // Deactivate the old layout
     if (oldPersp != 0)
     {
       oldPersp->OnDeactivate();
 
       // Notify listeners of deactivation
       window->FirePerspectiveDeactivated(thisPage, oldPersp->GetDesc());
     }
 
     // Activate the new layout
     perspList.SetActive(newPersp);
     if (newPersp != 0)
     {
       newPersp->OnActivate();
 
       // Notify listeners of activation
       window->FirePerspectiveActivated(thisPage, newPersp->GetDesc());
     }
 
     this->UpdateVisibility(oldPersp, newPersp);
 
     // Update the window
     //TODO action sets
     //window->UpdateActionSets();
 
     // Update sticky views
     stickyViewMan->Update(oldPersp, newPersp);
 
   }
   catch (std::exception& e)
   {
     exc = e;
     exceptionOccured = true;
   }
 
   window->LargeUpdateEnd();
   if (newPersp == 0)
   {
     return;
   }
   IPerspectiveDescriptor::Pointer desc = newPersp->GetDesc();
   if (desc == 0)
   {
     return;
   }
   if (dirtyPerspectives.erase(desc->GetId()))
   {
     this->SuggestReset();
   }
 
   if (exceptionOccured)
   throw exc;
 }
 
 void WorkbenchPage::UpdateVisibility(Perspective::Pointer oldPersp,
     Perspective::Pointer newPersp)
 {
 
   // Flag all parts in the old perspective
   QList<IViewReference::Pointer> oldRefs;
   if (oldPersp != 0)
   {
     oldRefs = oldPersp->GetViewReferences();
     for (int i = 0; i < oldRefs.size(); i++)
     {
       PartPane::Pointer pane =
       oldRefs[i].Cast<WorkbenchPartReference> ()->GetPane();
       pane->SetInLayout(false);
     }
   }
 
   PerspectiveHelper* pres = 0;
   // Make parts in the new perspective visible
   if (newPersp != 0)
   {
     pres = newPersp->GetPresentation();
     QList<IViewReference::Pointer> newRefs =
     newPersp->GetViewReferences();
     for (int i = 0; i < newRefs.size(); i++)
     {
       WorkbenchPartReference::Pointer ref = newRefs[i].Cast<
       WorkbenchPartReference> ();
       PartPane::Pointer pane = ref->GetPane();
       if (pres->IsPartVisible(ref))
       {
         activationList->BringToTop(ref);
       }
 
       pane->SetInLayout(true);
     }
   }
 
   this->UpdateActivePart();
 
   // Hide any parts in the old perspective that are no longer visible
   for (int i = 0; i < oldRefs.size(); i++)
   {
     WorkbenchPartReference::Pointer ref = oldRefs[i].Cast<
     WorkbenchPartReference> ();
 
     PartPane::Pointer pane = ref->GetPane();
     if (pres == 0 || !pres->IsPartVisible(ref))
     {
       pane->SetVisible(false);
     }
   }
 }
 
 /**
  * Sets the perspective.
  *
  * @param desc
  *            identifies the new perspective.
  */
 void WorkbenchPage::SetPerspective(IPerspectiveDescriptor::Pointer desc)
 {
   if (this->GetPerspective() == desc)
   {
     return;
   }
   //  // Going from multiple to single rows can make the coolbar
   //  // and its adjacent views appear jumpy as perspectives are
   //  // switched. Turn off redraw to help with this.
   //  ICoolBarManager2 mgr = (ICoolBarManager2) window.getCoolBarManager2();
   std::exception exc;
   bool exceptionOccured = false;
   try
   {
     //mgr.getControl2().setRedraw(false);
     //getClientComposite().setRedraw(false);
 
     // Run op in busy cursor.
     //    BusyIndicator.showWhile(0, new Runnable()
     //        {
     //        public void WorkbenchPage::run()
     //          {
     this->BusySetPerspective(desc);
     //          }
     //        });
   }
   catch (std::exception& e)
   {
     exc = e;
     exceptionOccured = true;
   }
 
   //  getClientComposite().setRedraw(true);
   //  mgr.getControl2().setRedraw(true);
   IWorkbenchPart::Pointer part = this->GetActivePart();
   if (part != 0)
   {
     part->SetFocus();
   }
 
   if (exceptionOccured)
   throw exc;
 }
 
 PartService* WorkbenchPage::GetPartService()
 {
   return dynamic_cast<PartService*> (partList->GetPartService());
 }
 
 void WorkbenchPage::ResetToolBarLayout()
 {
   //  ICoolBarManager2 mgr = (ICoolBarManager2) window.getCoolBarManager2();
   //  mgr.resetItemOrder();
 }
 
 IViewPart::Pointer WorkbenchPage::ShowView(const QString& viewID)
 {
   return this->ShowView(viewID, "", VIEW_ACTIVATE);
 }
 
 IViewPart::Pointer WorkbenchPage::ShowView(const QString& viewID,
     const QString& secondaryID, int mode)
 {
 
   if (secondaryID != "")
   {
     if (secondaryID.size() == 0 || secondaryID.indexOf(ViewFactory::ID_SEP) != -1)
     {
       throw ctkInvalidArgumentException(
           "Illegal secondary id (cannot be empty or contain a colon)");
     }
   }
   if (!this->CertifyMode(mode))
   {
     throw ctkInvalidArgumentException("Illegal view mode");
   }
 
   // Run op in busy cursor.
 
   //    BusyIndicator.showWhile(0, new Runnable()
   //        {
   //        public void WorkbenchPage::run()
   //          {
   //  try
   //  {
   return this->BusyShowView(viewID, secondaryID, mode);
   //  } catch (PartInitException& e)
   //  {
   //    result = e;
   //  }
   //          }
   //        });
 
 }
 
 bool WorkbenchPage::CertifyMode(int mode)
 {
   if (mode == VIEW_ACTIVATE || mode == VIEW_VISIBLE || mode == VIEW_CREATE)
   return true;
 
   return false;
 }
 
 QList<IEditorReference::Pointer> WorkbenchPage::GetSortedEditors()
 {
   return activationList->GetEditors();
 }
 
 QList<IPerspectiveDescriptor::Pointer> WorkbenchPage::GetOpenPerspectives()
 {
   QList<Perspective::Pointer> opened = perspList.GetOpenedPerspectives();
   QList<IPerspectiveDescriptor::Pointer> result;
   for (QList<Perspective::Pointer>::iterator iter = opened.begin(); iter
       != opened.end(); ++iter)
   {
     result.push_back((*iter)->GetDesc());
   }
   return result;
 }
 
 QList<Perspective::Pointer> WorkbenchPage::GetOpenInternalPerspectives()
 {
   return perspList.GetOpenedPerspectives();
 }
 
 Perspective::Pointer WorkbenchPage::GetFirstPerspectiveWithView(
     IViewPart::Pointer part)
 {
   QListIterator<Perspective::Pointer> iter(perspList.GetSortedPerspectives());
   iter.toBack();
   while(iter.hasPrevious())
   {
     Perspective::Pointer p = iter.previous();
     if (p->ContainsView(part))
     {
       return p;
     }
   };
   // we should never get here
   return Perspective::Pointer(0);
 }
 
 QList<IPerspectiveDescriptor::Pointer> WorkbenchPage::GetSortedPerspectives()
 {
   QList<Perspective::Pointer> sortedArray =
   perspList.GetSortedPerspectives();
   QList<IPerspectiveDescriptor::Pointer> result;
   for (QList<Perspective::Pointer>::iterator iter = sortedArray.begin();
       iter != sortedArray.end(); ++iter)
   {
     result.push_back((*iter)->GetDesc());
   }
   return result;
 }
 
 QList<IWorkbenchPartReference::Pointer> WorkbenchPage::GetSortedParts()
 {
   //return partList->GetParts(this->GetViewReferences());
   return activationList->GetParts();
 }
 
 IWorkbenchPartReference::Pointer WorkbenchPage::GetReference(
     IWorkbenchPart::Pointer part)
 {
   if (part == 0)
   {
     return IWorkbenchPartReference::Pointer(0);
   }
   IWorkbenchPartSite::Pointer site = part->GetSite();
   if (site.Cast<PartSite> () == 0)
   {
     return IWorkbenchPartReference::Pointer(0);
   }
   PartSite::Pointer partSite = site.Cast<PartSite> ();
   PartPane::Pointer pane = partSite->GetPane();
 
   return partSite->GetPartReference();
 }
 
 // for dynamic UI
 void WorkbenchPage::AddPerspective(Perspective::Pointer persp)
 {
   perspList.Add(persp);
   IWorkbenchPage::Pointer thisPage(this);
   window->FirePerspectiveOpened(thisPage, persp->GetDesc());
 }
 
 QList<IViewReference::Pointer> WorkbenchPage::GetViewReferenceStack(
     IViewPart::Pointer part)
 {
   // Sanity check.
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0 || !this->CertifyPart(part))
   {
     return QList<IViewReference::Pointer>();
   }
 
   ILayoutContainer::Pointer container =
   part->GetSite().Cast<PartSite> ()->GetPane()->GetContainer();
   if (container.Cast<PartStack> () != 0)
   {
     PartStack::Pointer folder = container.Cast<PartStack> ();
     QList<IViewReference::Pointer> list;
     ILayoutContainer::ChildrenType children = folder->GetChildren();
     for (ILayoutContainer::ChildrenType::iterator childIter =
         children.begin(); childIter != children.end(); ++childIter)
     {
       LayoutPart::Pointer stackablePart = *childIter;
       if (stackablePart.Cast<PartPane> () != 0)
       {
         IViewReference::Pointer view =
         stackablePart.Cast<PartPane> ()->GetPartReference().Cast<
         IViewReference> ();
         if (view != 0)
         {
           list.push_back(view);
         }
       }
     }
 
     // sort the list by activation order (most recently activated first)
     std::sort(list.begin(), list.end(), ActivationOrderPred(activationList));
 
     return list;
   }
 
   QList<IViewReference::Pointer> result;
   result.push_back(this->GetReference(part).Cast<IViewReference> ());
   return result;
 }
 
 QList<IViewPart::Pointer> WorkbenchPage::GetViewStack(
     IViewPart::Pointer part)
 {
   QList<IViewReference::Pointer> refStack = this->GetViewReferenceStack(
       part);
 
   QList<IViewPart::Pointer> result;
 
   for (int i = 0; i < refStack.size(); i++)
   {
     IViewPart::Pointer next = refStack[i]->GetView(false);
     if (next != 0)
     {
       result.push_back(next);
     }
   }
 
   return result;
 }
 
 void WorkbenchPage::ResizeView(IViewPart::Pointer part, int width, int height)
 {
   SashInfo sashInfo;
   PartPane::Pointer pane = part->GetSite().Cast<PartSite> ()->GetPane();
   ILayoutContainer::Pointer container = pane->GetContainer();
   LayoutTree::Pointer tree =
   this->GetPerspectivePresentation()->GetLayout()->GetLayoutTree()->Find(
       container.Cast<PartStack> ());
 
   // retrieve our layout sashes from the layout tree
   this->FindSashParts(tree, pane->FindSashes(), sashInfo);
 
   // first set the width
   int deltaWidth = width - pane->GetBounds().width;
   if (sashInfo.right != 0)
   {
     Rectangle rightBounds = sashInfo.rightNode->GetBounds();
     // set the new ratio
     sashInfo.right->SetRatio(static_cast<float>((deltaWidth + sashInfo.right->GetBounds().x)
             - rightBounds.x) / rightBounds.width);
     // complete the resize
     sashInfo.rightNode->SetBounds(rightBounds);
   }
   else if (sashInfo.left != 0)
   {
     Rectangle leftBounds = sashInfo.leftNode->GetBounds();
     // set the ratio
     sashInfo.left->SetRatio(static_cast<float>((sashInfo.left->GetBounds().x - deltaWidth)
             - leftBounds.x) / leftBounds.width);
     // complete the resize
     sashInfo.leftNode->SetBounds(sashInfo.leftNode->GetBounds());
   }
 
   // next set the height
   int deltaHeight = height - pane->GetBounds().height;
   if (sashInfo.bottom != 0)
   {
     Rectangle bottomBounds = sashInfo.bottomNode->GetBounds();
     // set the new ratio
     sashInfo.bottom->SetRatio(static_cast<float>((deltaHeight + sashInfo.bottom->GetBounds().y)
             - bottomBounds.y) / bottomBounds.height);
     // complete the resize
     sashInfo.bottomNode->SetBounds(bottomBounds);
   }
   else if (sashInfo.top != 0)
   {
     Rectangle topBounds = sashInfo.topNode->GetBounds();
     // set the ratio
     sashInfo.top->SetRatio(static_cast<float>((sashInfo.top->GetBounds().y - deltaHeight)
             - topBounds.y) / topBounds.height);
     // complete the resize
     sashInfo.topNode->SetBounds(topBounds);
   }
 
 }
 
 void WorkbenchPage::FindSashParts(LayoutTree::Pointer tree,
     const PartPane::Sashes& sashes, SashInfo& info)
 {
   LayoutTree::Pointer parent(tree->GetParent());
   if (parent == 0)
   {
     return;
   }
 
   if (parent->part.Cast<LayoutPartSash> () != 0)
   {
     // get the layout part sash from this tree node
     LayoutPartSash::Pointer sash = parent->part.Cast<LayoutPartSash> ();
     // make sure it has a sash control
     void* control = sash->GetControl();
     if (control != 0)
     {
       // check for a vertical sash
       if (sash->IsVertical())
       {
         if (sashes.left == control)
         {
           info.left = sash;
           info.leftNode = parent->FindSash(sash);
         }
         else if (sashes.right == control)
         {
           info.right = sash;
           info.rightNode = parent->FindSash(sash);
         }
       }
       // check for a horizontal sash
 
       else
       {
         if (sashes.top == control)
         {
           info.top = sash;
           info.topNode = parent->FindSash(sash);
         }
         else if (sashes.bottom == control)
         {
           info.bottom = sash;
           info.bottomNode = parent->FindSash(sash);
         }
       }
     }
   }
   // recursive call to continue up the tree
   this->FindSashParts(parent, sashes, info);
 }
 
 QList<IWorkbenchPartReference::Pointer> WorkbenchPage::GetAllParts()
 {
   QList<IViewReference::Pointer> views = viewFactory->GetViews();
   QList<IEditorReference::Pointer> editors = this->GetEditorReferences();
 
   QList<IWorkbenchPartReference::Pointer> result;
 
   for (int i = 0; i < views.size(); i++)
   {
     result.push_back(views[i]);
   }
 
   for (QList<IEditorReference::Pointer>::iterator iter = editors.begin(); iter
       != editors.end(); ++iter)
   {
     result.push_back(*iter);
   }
 
   return result;
 }
 
 QList<IWorkbenchPartReference::Pointer> WorkbenchPage::GetOpenParts()
 {
   QList<IWorkbenchPartReference::Pointer> refs = this->GetAllParts();
   QList<IWorkbenchPartReference::Pointer> result;
 
   for (int i = 0; i < refs.size(); i++)
   {
     IWorkbenchPartReference::Pointer reference = refs[i];
 
     IWorkbenchPart::Pointer part = reference->GetPart(false);
     if (part != 0)
     {
       result.push_back(reference);
     }
   }
 
   return result;
 }
 
 void WorkbenchPage::TestInvariants()
 {
   Perspective::Pointer persp = this->GetActivePerspective();
 
   if (persp != 0)
   {
 
     persp->TestInvariants();
 
     // When we have widgets, ensure that there is no situation where the editor area is visible
     // and the perspective doesn't want an editor area.
     if (this->GetClientComposite()
         && editorPresentation->GetLayoutPart()->IsVisible())
     {
       poco_assert(persp->IsEditorAreaVisible());
     }
   }
 
 }
 
 /* (non-Javadoc)
  * @see org.blueberry.ui.IWorkbenchPage#getExtensionTracker()
  */
 //  IExtensionTracker WorkbenchPage::GetExtensionTracker()
 //  {
 //    if (tracker == 0)
 //    {
 //      tracker = new UIExtensionTracker(getWorkbenchWindow().getWorkbench().getDisplay());
 //    }
 //    return tracker;
 //  }
 
 /*
  * (non-Javadoc)
  *
  * @see org.blueberry.ui.IWorkbenchPage#getPerspectiveShortcuts()
  */
 QList<QString> WorkbenchPage::GetPerspectiveShortcuts()
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0)
   {
     return QList<QString>();
   }
   return persp->GetPerspectiveShortcuts();
 }
 
 QList<QString> WorkbenchPage::GetShowViewShortcuts()
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0)
   {
     return QList<QString>();
   }
   return persp->GetShowViewShortcuts();
 }
 
 void WorkbenchPage::SuggestReset()
 {
   IWorkbench* workbench = this->GetWorkbenchWindow()->GetWorkbench();
   //    workbench.getDisplay().asyncExec(new Runnable()
   //        {
   //        public void WorkbenchPage::run()
   //          {
   Shell::Pointer parentShell;
 
   IWorkbenchWindow::Pointer window = workbench->GetActiveWorkbenchWindow();
   if (window == 0)
   {
     if (workbench->GetWorkbenchWindowCount() == 0)
     {
       return;
     }
     window = workbench->GetWorkbenchWindows()[0];
   }
 
   parentShell = window->GetShell();
 
-  if (MessageDialog::OpenQuestion(parentShell,
-          "Reset Perspective?",
-          "Changes to installed plug-ins have affected this perspective. Would you like to reset this perspective to accept these changes?"))
+  if (QMessageBox::question(parentShell.IsNull() ? NULL : reinterpret_cast<QWidget*>(parentShell->GetControl()),
+                            "Reset Perspective?",
+                            "Changes to installed plug-ins have affected this perspective. Would you like to reset this perspective to accept these changes?") ==
+      QMessageBox::Yes)
   {
     IWorkbenchPage::Pointer page = window->GetActivePage();
     if (page == 0)
     {
       return;
     }
     page->ResetPerspective();
   }
   //          }
   //        });
 
 }
 
 bool WorkbenchPage::IsPartVisible(
     IWorkbenchPartReference::Pointer reference)
 {
   IWorkbenchPart::Pointer part = reference->GetPart(false);
   // Can't be visible if it isn't created yet
   if (part == 0)
   {
     return false;
   }
 
   return this->IsPartVisible(part);
 }
 
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryWorkbenchPlugin.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryWorkbenchPlugin.cpp
index 20f4cc01af..758b2e737a 100644
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryWorkbenchPlugin.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryWorkbenchPlugin.cpp
@@ -1,398 +1,396 @@
 /*===================================================================
 
 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 "berryLog.h"
 
 #include "berryWorkbenchPlugin.h"
 
 #include "berryWorkbenchRegistryConstants.h"
 #include "berryWorkbench.h"
 #include "berryPlatform.h"
 
 #include "intro/berryEditorIntroAdapterPart.h"
 #include "defaultpresentation/berryQtWorkbenchPresentationFactory.h"
 
 #include "berryQtStyleManager.h"
 
 #include "berryQtDnDTweaklet.h"
 #include "berryQtImageTweaklet.h"
-#include "berryQtMessageDialogTweaklet.h"
 #include "berryQtWorkbenchTweaklet.h"
 #include "berryQtWorkbenchPageTweaklet.h"
 #include "berryQtWidgetsTweaklet.h"
 #include "berryQtStylePreferencePage.h"
 #include "berryStatusUtil.h"
 #include "berryHandlerServiceFactory.h"
 #include "berryMenuServiceFactory.h"
 #include "berryCommandServiceFactory.h"
 #include "berryWorkbenchSourceProvider.h"
 #include "berryObjectString.h"
 #include "berryObjects.h"
 
 #include "berryShowViewHandler.h"
 
 #include "berryIQtStyleManager.h"
 #include "berryImageDescriptor.h"
 #include "berryIContributor.h"
 #include "berryILog.h"
 
 #include "berryIExtension.h"
 
 #include <QDebug>
 
 namespace berry
 {
 
 bool WorkbenchPlugin::DEBUG = false;
 
 char WorkbenchPlugin::PREFERENCE_PAGE_CATEGORY_SEPARATOR = '/';
 
 WorkbenchPlugin* WorkbenchPlugin::inst = 0;
 
 WorkbenchPlugin::WorkbenchPlugin()
  : AbstractUICTKPlugin()
 {
   inst = this;
   presentationFactory = 0;
   editorRegistry = 0;
   viewRegistry = 0;
   perspRegistry = 0;
   introRegistry = 0;
 }
 
 WorkbenchPlugin::~WorkbenchPlugin()
 {
   delete presentationFactory;
   delete editorRegistry;
   delete viewRegistry;
   delete perspRegistry;
   delete introRegistry;
 
   inst = 0;
 }
 
 bool WorkbenchPlugin::HasExecutableExtension(
     const IConfigurationElement::Pointer& element, const QString& extensionName)
 {
   if (!element->GetAttribute(extensionName).isNull()) return true;
 
   QString elementText = element->GetValue();
   if (!elementText.isEmpty()) return true;
 
   QList<IConfigurationElement::Pointer> children(element->GetChildren(extensionName));
   if (children.size() == 1)
   {
     if (!(children[0]->GetAttribute(WorkbenchRegistryConstants::ATT_CLASS).isNull()))
       return true;
   }
   return false;
 }
 
 bool WorkbenchPlugin::IsBundleLoadedForExecutableExtension(
     const IConfigurationElement::Pointer& element, const QString& extensionName)
 {
   QSharedPointer<ctkPlugin> plugin = WorkbenchPlugin::GetBundleForExecutableExtension(element, extensionName);
 
   if (plugin.isNull())
     return true;
   return plugin->getState() == ctkPlugin::ACTIVE;
 }
 
 QSharedPointer<ctkPlugin> WorkbenchPlugin::GetBundleForExecutableExtension(
     const IConfigurationElement::Pointer& element, const QString& extensionName)
 {
   // this code is derived heavily from
   // ConfigurationElement.createExecutableExtension.
   QString prop;
   QString executable;
   QString contributorName;
   int i = 0;
 
   if (!extensionName.isNull())
     prop = element->GetAttribute(extensionName);
   else
   {
     // property not specified, try as element value
     prop = element->GetValue();
     if (!prop.isNull())
     {
       prop = prop.trimmed();
       if (prop.isEmpty())
         prop = QString();
     }
   }
 
   if (prop.isNull())
   {
     // property not defined, try as a child element
     QList<IConfigurationElement::Pointer> exec(element->GetChildren(extensionName));
     if (!exec.isEmpty())
       contributorName = exec[0]->GetAttribute("plugin");
   }
   else
   {
     // simple property or element value, parse it into its components
     i = prop.indexOf(':');
     if (i != -1)
       executable = prop.left(i).trimmed();
     else
       executable = prop;
 
     i = executable.indexOf('/');
     if (i != -1)
       contributorName = executable.left(i).trimmed();
   }
 
   if (contributorName.isNull())
     contributorName = element->GetContributor()->GetName();
 
   return Platform::GetPlugin(contributorName);
 }
 
 WorkbenchPlugin* WorkbenchPlugin::GetDefault()
 {
   return inst;
 }
 
 std::size_t WorkbenchPlugin::GetBundleCount()
 {
   // TODO BundleContext GetBundles
   //return bundleContext->GetBundles().size();
   return 0;
 }
 
 
 //    ImageRegistry createImageRegistry() {
 //        return WorkbenchImages.getImageRegistry();
 //    }
 
 
 IPerspectiveRegistry* WorkbenchPlugin::GetPerspectiveRegistry() {
   if (perspRegistry == 0) {
     perspRegistry = new PerspectiveRegistry();
 
   // the load methods can touch on WorkbenchImages if an image is
   // missing so we need to wrap the call in
   // a startup block for the case where a custom descriptor exists on
   // startup that does not have an image
   // associated with it. See bug 196352.
   //StartupThreading.runWithoutExceptions(new StartupRunnable() {
   //  public void runWithException() throws Throwable {
       perspRegistry->Load();
   //  }
   //});
 
   }
   return perspRegistry;
 }
 
 
 //    PreferenceManager getPreferenceManager() {
 //        if (preferenceManager == null) {
 //            preferenceManager = new WorkbenchPreferenceManager(
 //                    PREFERENCE_PAGE_CATEGORY_SEPARATOR);
 //
 //            //Get the pages from the registry
 //            PreferencePageRegistryReader registryReader = new PreferencePageRegistryReader(
 //                    getWorkbench());
 //            registryReader
 //                    .loadFromRegistry(Platform.getExtensionRegistry());
 //            preferenceManager.addPages(registryReader.getTopLevelNodes());
 //
 //        }
 //        return preferenceManager;
 //    }
 
 
 //    ISharedImages getSharedImages() {
 //        if (sharedImages == null) {
 //      sharedImages = new SharedImages();
 //    }
 //        return sharedImages;
 //    }
 
 IIntroRegistry* WorkbenchPlugin::GetIntroRegistry()
 {
   if (introRegistry == 0)
   {
     introRegistry = new IntroRegistry();
   }
   return introRegistry;
 }
 
 IViewRegistry* WorkbenchPlugin::GetViewRegistry()
 {
   if (!viewRegistry)
     viewRegistry = new ViewRegistry();
 
   return viewRegistry;
 }
 
 IEditorRegistry* WorkbenchPlugin::GetEditorRegistry()
 {
   if (!editorRegistry)
     editorRegistry = new EditorRegistry();
 
   return editorRegistry;
 }
 
 IPresentationFactory* WorkbenchPlugin::GetPresentationFactory() {
   if (presentationFactory != 0) return presentationFactory;
 
   QString targetID = Workbench::GetInstance()->GetPresentationId();
   presentationFactory = this->CreateExtension<IPresentationFactory>(
           WorkbenchRegistryConstants::PL_PRESENTATION_FACTORIES,
           "factory", targetID);
   if (presentationFactory == 0)
     WorkbenchPlugin::Log("Error creating presentation factory: " +
         targetID + " -- class is not an IPresentationFactory");
 
   return presentationFactory;
 }
 
 void WorkbenchPlugin::Log(const QString& message)
 {
   BERRY_INFO << "LOG: " << message << std::endl;
   //inst->GetLog().log(message);
 }
 
 void WorkbenchPlugin::Log(const ctkException &exc)
 {
   QString str;
   QDebug dbg(&str);
   dbg << exc.printStackTrace();
   BERRY_INFO << "LOG: " << str << std::endl;
   //inst->GetLog().log(exc);
 }
 
 
 void WorkbenchPlugin::Log(const QString& message, const ctkException &t)
 {
   PlatformException exc(message, t);
   WorkbenchPlugin::Log(exc);
 }
 
 void WorkbenchPlugin::Log(const QString& clazz,
                           const QString& methodName, const ctkException &t)
 {
   QString msg = QString("Exception in ") + clazz + "." + methodName + ": "
       + t.what();
 
   WorkbenchPlugin::Log(msg, t);
 }
 
 void WorkbenchPlugin::Log(const QString& message, const SmartPointer<IStatus>& status)
 {
   //1FTUHE0: ITPCORE:ALL - API - Status & logging - loss of semantic info
 
   if (!message.isEmpty())
   {
     GetDefault()->GetLog()->Log(StatusUtil::NewStatus(IStatus::ERROR_TYPE, message, BERRY_STATUS_LOC));
   }
 
   GetDefault()->GetLog()->Log(status);
 }
 
 void WorkbenchPlugin::Log(const SmartPointer<IStatus>& status)
 {
   GetDefault()->GetLog()->Log(status);
 }
 
 void WorkbenchPlugin::start(ctkPluginContext* context)
 {
   //context.addBundleListener(getBundleListener());
   AbstractUICTKPlugin::start(context);
   bundleContext = context;
 
   BERRY_REGISTER_EXTENSION_CLASS(EditorIntroAdapterPart, context)
 
   BERRY_REGISTER_EXTENSION_CLASS(QtDnDTweaklet, context)
   BERRY_REGISTER_EXTENSION_CLASS(QtImageTweaklet, context)
-  BERRY_REGISTER_EXTENSION_CLASS(QtMessageDialogTweaklet, context)
   BERRY_REGISTER_EXTENSION_CLASS(QtWidgetsTweaklet, context)
   BERRY_REGISTER_EXTENSION_CLASS(QtWorkbenchTweaklet, context)
   BERRY_REGISTER_EXTENSION_CLASS(QtWorkbenchPageTweaklet, context)
   BERRY_REGISTER_EXTENSION_CLASS(QtWorkbenchPresentationFactory, context)
 
   BERRY_REGISTER_EXTENSION_CLASS(QtStylePreferencePage, context)
 
   BERRY_REGISTER_EXTENSION_CLASS(HandlerServiceFactory, context)
   BERRY_REGISTER_EXTENSION_CLASS(MenuServiceFactory, context)
   BERRY_REGISTER_EXTENSION_CLASS(CommandServiceFactory, context)
 
   BERRY_REGISTER_EXTENSION_CLASS(WorkbenchSourceProvider, context)
 
   BERRY_REGISTER_EXTENSION_CLASS(ShowViewHandler, context)
 
   styleManager.reset(new QtStyleManager());
   context->registerService<berry::IQtStyleManager>(styleManager.data());
 
   // The UI plugin needs to be initialized so that it can install the callback in PrefUtil,
   // which needs to be done as early as possible, before the workbench
   // accesses any API preferences.
 //  Bundle uiBundle = Platform.getBundle(PlatformUI.PLUGIN_ID);
 //  try
 //  {
 //    // Attempt to load the activator of the ui bundle.  This will force lazy start
 //    // of the ui bundle.  Using the bundle activator class here because it is a
 //    // class that needs to be loaded anyway so it should not cause extra classes
 //    // to be loaded.
 //    if(uiBundle != null)
 //    uiBundle.loadClass(UI_BUNDLE_ACTIVATOR);
 //  }
 //  catch (ClassNotFoundException e)
 //  {
 //    WorkbenchPlugin.log("Unable to load UI activator", e); //$NON-NLS-1$
 //  }
   /*
    * DO NOT RUN ANY OTHER CODE AFTER THIS LINE.  If you do, then you are
    * likely to cause a deadlock in class loader code.  Please see Bug 86450
    * for more information.
    */
 
 }
 
 //const QList<IBundle::Pointer> WorkbenchPlugin::GetBundles()
 //{
 //  return bundleContext.IsNull() ? QList<IBundle::Pointer>() : bundleContext->GetBundles();
 //}
 
 ctkPluginContext* WorkbenchPlugin::GetPluginContext()
 {
   return bundleContext;
 }
 
 void WorkbenchPlugin::stop(ctkPluginContext* context)
 {
   AbstractUICTKPlugin::stop(context);
 
   styleManager.reset();
 
   delete perspRegistry;
   // avoid possible crash, see bug #18399
   perspRegistry = 0;
 }
 
 QString WorkbenchPlugin::GetDataLocation() const
 {
   QFileInfo fileInfo = bundleContext->getDataFile("");
   if (!fileInfo.isWritable()) return QString();
   return fileInfo.absoluteFilePath();
 }
 
 }
 
 Q_EXPORT_PLUGIN2(org_blueberry_ui_qt, berry::WorkbenchPlugin)
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryMessageDialogTweaklet.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryMessageDialogTweaklet.cpp
deleted file mode 100755
index dbc5564f1a..0000000000
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryMessageDialogTweaklet.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/*===================================================================
-
-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 "berryMessageDialogTweaklet.h"
-
-namespace berry {
-
-Tweaklets::TweakKey<MessageDialogTweaklet> MessageDialogTweaklet::KEY =
-  Tweaklets::TweakKey<MessageDialogTweaklet>();
-
-}
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryMessageDialogTweaklet.h b/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryMessageDialogTweaklet.h
deleted file mode 100755
index 0ab6c2e74f..0000000000
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryMessageDialogTweaklet.h
+++ /dev/null
@@ -1,159 +0,0 @@
-/*===================================================================
-
-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 BERRYMESSAGEDIALOGTWEAKLET_H_
-#define BERRYMESSAGEDIALOGTWEAKLET_H_
-
-#include <org_blueberry_ui_qt_Export.h>
-
-#include "internal/berryTweaklets.h"
-
-#include "berryShell.h"
-#include "dialogs/berryIDialog.h"
-
-
-#include <berryMacros.h>
-
-#include <vector>
-#include <string>
-
-namespace berry {
-
-/**
- * A dialog for showing messages to the user.
- */
-struct BERRY_UI_QT MessageDialogTweaklet
-{
-
-  static Tweaklets::TweakKey<MessageDialogTweaklet> KEY;
-
-    /**
-     * Convenience method to open a simple confirm (OK/Cancel) dialog.
-     *
-     * @param parent
-     *            the parent shell of the dialog, or <code>null</code> if none
-     * @param title
-     *            the dialog's title, or <code>null</code> if none
-     * @param message
-     *            the message
-     * @return <code>true</code> if the user presses the OK button,
-     *         <code>false</code> otherwise
-     */
-    virtual bool OpenConfirm(Shell::Pointer parent, const QString& title, const QString& message) = 0;
-
-    /**
-     * Convenience method to open a standard error dialog.
-     *
-     * @param parent
-     *            the parent shell of the dialog, or <code>null</code> if none
-     * @param title
-     *            the dialog's title, or <code>null</code> if none
-     * @param message
-     *            the message
-     */
-    virtual void OpenError(Shell::Pointer parent, const QString& title, const QString& message) = 0;
-
-    /**
-     * Convenience method to open a standard information dialog.
-     *
-     * @param parent
-     *            the parent shell of the dialog, or <code>null</code> if none
-     * @param title
-     *            the dialog's title, or <code>null</code> if none
-     * @param message
-     *            the message
-     */
-    virtual void OpenInformation(Shell::Pointer parent, const QString& title,
-            const QString& message) = 0;
-
-    /**
-     * Convenience method to open a simple Yes/No question dialog.
-     *
-     * @param parent
-     *            the parent shell of the dialog, or <code>null</code> if none
-     * @param title
-     *            the dialog's title, or <code>null</code> if none
-     * @param message
-     *            the message
-     * @return <code>true</code> if the user presses the OK button,
-     *         <code>false</code> otherwise
-     */
-    virtual bool OpenQuestion(Shell::Pointer parent, const QString& title,
-            const QString& message) = 0;
-
-    /**
-     * Convenience method to open a standard warning dialog.
-     *
-     * @param parent
-     *            the parent shell of the dialog, or <code>null</code> if none
-     * @param title
-     *            the dialog's title, or <code>null</code> if none
-     * @param message
-     *            the message
-     */
-    virtual void OpenWarning(Shell::Pointer parent, const QString& title, const QString& message) = 0;
-
-    /**
-     * Create a message dialog. Note that the dialog will have no visual
-     * representation (no widgets) until it is told to open.
-     * <p>
-     * The labels of the buttons to appear in the button bar are supplied in
-     * this constructor as an array. The <code>open</code> method will return
-     * the index of the label in this array corresponding to the button that was
-     * pressed to close the dialog. If the dialog was dismissed without pressing
-     * a button (ESC, etc.) then -1 is returned. Note that the <code>open</code>
-     * method blocks.
-     * </p>
-     *
-     * @param parentShell
-     *            the parent shell
-     * @param dialogTitle
-     *            the dialog title, or <code>null</code> if none
-     * @param dialogTitleImage
-     *            the dialog title image, or <code>null</code> if none
-     * @param dialogMessage
-     *            the dialog message
-     * @param dialogImageType
-     *            one of the following values:
-     *            <ul>
-     *            <li><code>IDialog::NONE</code> for a dialog with no
-     *            image</li>
-     *            <li><code>IDialog::ERR</code> for a dialog with an
-     *            error image</li>
-     *            <li><code>IDialog::INFORMATION</code> for a dialog
-     *            with an information image</li>
-     *            <li><code>IDialog::QUESTION </code> for a dialog with a
-     *            question image</li>
-     *            <li><code>IDialog::WARNING</code> for a dialog with a
-     *            warning image</li>
-     *            </ul>
-     * @param dialogButtonLabels
-     *            an array of labels for the buttons in the button bar
-     * @param defaultIndex
-     *            the index in the button label array of the default button
-     */
-    virtual IDialog::Pointer MessageDialog(Shell::Pointer parentShell, const QString& dialogTitle,
-            void* dialogTitleImage, const QString& dialogMessage, int dialogImageType,
-            const QList<QString>& dialogButtonLabels, int defaultIndex) = 0;
-
-};
-
-}
-
-Q_DECLARE_INTERFACE(berry::MessageDialogTweaklet, "org.blueberry.MessageDialogTweaklet")
-
-#endif /* BERRYMESSAGEDIALOGTWEAKLET_H_ */
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryWorkbenchTweaklet.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryWorkbenchTweaklet.cpp
index deddd56eba..bbdd0ffd14 100755
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryWorkbenchTweaklet.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryWorkbenchTweaklet.cpp
@@ -1,28 +1,25 @@
 /*===================================================================
 
 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 "berryWorkbenchTweaklet.h"
 
 namespace berry
 {
 
 Tweaklets::TweakKey<WorkbenchTweaklet> WorkbenchTweaklet::KEY =
   Tweaklets::TweakKey<WorkbenchTweaklet>();
 
-const QString WorkbenchTweaklet::DIALOG_ID_SHOW_VIEW =
-    "org.blueberry.ui.dialogs.showview";
-
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryWorkbenchTweaklet.h b/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryWorkbenchTweaklet.h
index 1c45ef7294..0268b43143 100755
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryWorkbenchTweaklet.h
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/tweaklets/berryWorkbenchTweaklet.h
@@ -1,51 +1,46 @@
 /*===================================================================
 
 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 BERRYWORKBENCHTWEAKLET_H_
 #define BERRYWORKBENCHTWEAKLET_H_
 
 #include "internal/berryTweaklets.h"
 
 #include "berryShell.h"
 #include "berryDisplay.h"
-#include "dialogs/berryIDialog.h"
 
 namespace berry
 {
 
 class WorkbenchWindow;
 
 struct BERRY_UI_QT WorkbenchTweaklet
 {
 
   static Tweaklets::TweakKey<WorkbenchTweaklet> KEY;
 
-  static const QString DIALOG_ID_SHOW_VIEW; // = "org.blueberry.ui.dialogs.showview";
-
   virtual Display* CreateDisplay() = 0;
 
   virtual bool IsRunning() = 0;
 
-  virtual IDialog::Pointer CreateStandardDialog(const QString& id) = 0;
-
 };
 
 }
 
 Q_DECLARE_INTERFACE(berry::WorkbenchTweaklet, "org.blueberry.WorkbenchTweaklet")
 
 #endif /* BERRYWORKBENCHTWEAKLET_H_ */