diff --git a/BlueBerry/Bundles/org.blueberry.ui/src/berryIWorkbenchPage.h b/BlueBerry/Bundles/org.blueberry.ui/src/berryIWorkbenchPage.h
index f8f2a4d879..1b685bc8af 100644
--- a/BlueBerry/Bundles/org.blueberry.ui/src/berryIWorkbenchPage.h
+++ b/BlueBerry/Bundles/org.blueberry.ui/src/berryIWorkbenchPage.h
@@ -1,876 +1,880 @@
 /*===================================================================
 
 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 BERRYIWORKBENCHPAGE_H_
 #define BERRYIWORKBENCHPAGE_H_
 
 #include <berryMacros.h>
 
 #include "berryIEditorReference.h"
 #include "berryIViewReference.h"
 #include "berryIPerspectiveDescriptor.h"
 #include "berryIEditorPart.h"
 #include "berryIViewPart.h"
 #include "berryIEditorInput.h"
 #include "berryIPartService.h"
 #include "berryISelectionService.h"
 #include "berryIReusableEditor.h"
 
 #include "berryIWorkbenchWindow.h"
 
 #include <vector>
 #include <list>
 
 /**
  * \ingroup org_blueberry_ui
  *
  */
 namespace berry {
 /**
  * A workbench page consists of an arrangement of views and editors intended to
  * be presented together to the user in a single workbench window.
  * <p>
  * A page can contain 0 or more views and 0 or more editors. These views and
  * editors are contained wholly within the page and are not shared with other
  * pages. The layout and visible action set for the page is defined by a
  * perspective.
  * <p>
  * The number of views and editors within a page is restricted to simplify part
  * management for the user. In particular:
  * <ul>
  * <li>Unless a view explicitly allows for multiple instances in its plugin
  * declaration there will be only one instance in a given workbench page.</li>
  * <li>Only one editor can exist for each editor input within a page.
  * <li>
  * </ul>
  * </p>
  * <p>
  * This interface is not intended to be implemented by clients.
  * </p>
  *
  * @see IPerspectiveDescriptor
  * @see IEditorPart
  * @see IViewPart
  */
 struct BERRY_UI IWorkbenchPage : public IPartService, public ISelectionService, public Object {
   berryInterfaceMacro(IWorkbenchPage, berry);
 
   /**
    * An optional attribute within a workspace marker (<code>IMarker</code>)
    * which identifies the preferred editor type to be opened when
    * <code>openEditor</code> is called.
    *
    * @see #openEditor(IEditorInput, String)
    * @see #openEditor(IEditorInput, String, boolean)
    * @deprecated in 3.0 since the notion of markers this is not generally
    *             applicable. Use the IDE-specific constant
    *             <code>IDE.EDITOR_ID_ATTR</code>.
    */
   static const std::string EDITOR_ID_ATTR; // = "org.blueberry.ui.editorID"; //$NON-NLS-1$
 
   /**
    * Change event id when the perspective is reset to its original state.
    *
    * @see IPerspectiveListener
    */
   static const std::string CHANGE_RESET; // = "reset"; //$NON-NLS-1$
 
   /**
    * Change event id when the perspective has completed a reset to its
    * original state.
    *
    * @since 3.0
    * @see IPerspectiveListener
    */
   static const std::string CHANGE_RESET_COMPLETE; // = "resetComplete"; //$NON-NLS-1$
 
   /**
    * Change event id when one or more views are shown in a perspective.
    *
    * @see IPerspectiveListener
    */
   static const std::string CHANGE_VIEW_SHOW; // = "viewShow"; //$NON-NLS-1$
 
   /**
    * Change event id when one or more views are hidden in a perspective.
    *
    * @see IPerspectiveListener
    */
   static const std::string CHANGE_VIEW_HIDE; // = "viewHide"; //$NON-NLS-1$
 
   /**
    * Change event id when one or more editors are opened in a perspective.
    *
    * @see IPerspectiveListener
    */
   static const std::string CHANGE_EDITOR_OPEN; // = "editorOpen"; //$NON-NLS-1$
 
   /**
    * Change event id when one or more editors are closed in a perspective.
    *
    * @see IPerspectiveListener
    */
   static const std::string CHANGE_EDITOR_CLOSE; // = "editorClose"; //$NON-NLS-1$
 
   /**
    * Change event id when the editor area is shown in a perspective.
    *
    * @see IPerspectiveListener
    */
   static const std::string CHANGE_EDITOR_AREA_SHOW; // = "editorAreaShow"; //$NON-NLS-1$
 
   /**
    * Change event id when the editor area is hidden in a perspective.
    *
    * @see IPerspectiveListener
    */
   static const std::string CHANGE_EDITOR_AREA_HIDE; // = "editorAreaHide"; //$NON-NLS-1$
 
   /**
    * Change event id when an action set is shown in a perspective.
    *
    * @see IPerspectiveListener
    */
   static const std::string CHANGE_ACTION_SET_SHOW; // = "actionSetShow"; //$NON-NLS-1$
 
   /**
    * Change event id when an action set is hidden in a perspective.
    *
    * @see IPerspectiveListener
    */
   static const std::string CHANGE_ACTION_SET_HIDE; // = "actionSetHide"; //$NON-NLS-1$
 
   /**
    * Show view mode that indicates the view should be made visible and
    * activated. Use of this mode has the same effect as calling
    * {@link #showView(String)}.
    *
    * @since 3.0
    */
   static const int VIEW_ACTIVATE; // = 1;
 
   /**
    * Show view mode that indicates the view should be made visible. If the
    * view is opened in the container that contains the active view then this
    * has the same effect as <code>VIEW_CREATE</code>.
    *
    * @since 3.0
    */
   static const int VIEW_VISIBLE; // = 2;
 
   /**
    * Show view mode that indicates the view should be made created but not
    * necessarily be made visible. It will only be made visible in the event
    * that it is opened in its own container. In other words, only if it is not
    * stacked with another view.
    *
    * @since 3.0
    */
   static const int VIEW_CREATE; // = 3;
 
   /**
    * Editor opening match mode specifying that no matching against existing
    * editors should be done.
    *
    * @since 3.2
    */
   static const int MATCH_NONE; // = 0;
 
   /**
    * Editor opening match mode specifying that the editor input should be
    * considered when matching against existing editors.
    *
    * @since 3.2
    */
   static const int MATCH_INPUT; // = 1;
 
   /**
    * Editor opening match mode specifying that the editor id should be
    * considered when matching against existing editors.
    *
    * @since 3.2
    */
   static const int MATCH_ID; // = 2;
 
   ~IWorkbenchPage();
 
-
-  public:
-    virtual void RemovePerspective(IPerspectiveDescriptor::Pointer desc) = 0;
   /**
    * Activates the given part. The part will be brought to the front and given
    * focus. The part must belong to this page.
    *
    * @param part
    *            the part to activate
    */
   virtual void Activate(IWorkbenchPart::Pointer part) = 0;
 
   /**
    * Adds a property change listener.
    *
    * @param listener
    *            the property change listener to add
    * @since 2.0
    */
   //virtual void addPropertyChangeListener(IPropertyChangeListener listener);
 
   /**
    * Moves the given part forward in the Z order of this page so as to make it
    * visible, without changing which part has focus. The part must belong to
    * this page.
    *
    * @param part
    *            the part to bring forward
    */
   virtual void BringToTop(IWorkbenchPart::Pointer part) = 0;
 
   /**
    * Closes this workbench page. If this page is the active one, this honor is
    * passed along to one of the window's other pages if possible.
    * <p>
    * If the page has an open editor with unsaved content, the user will be
    * given the opportunity to save it.
    * </p>
    *
    * @return <code>true</code> if the page was successfully closed, and
    *         <code>false</code> if it is still open
    */
   virtual bool Close() = 0;
 
   /**
    * Closes all of the editors belonging to this workbench page.
    * <p>
    * If the page has open editors with unsaved content and <code>save</code>
    * is <code>true</code>, the user will be given the opportunity to save
    * them.
    * </p>
    *
    * @param save
    *
    * @return <code>true</code> if all editors were successfully closed, and
    *         <code>false</code> if at least one is still open
    */
   virtual bool CloseAllEditors(bool save) = 0;
 
   /**
    * Closes the given <code>Array</code> of editor references. The editors
    * must belong to this workbench page.
    * <p>
    * If any of the editors have unsaved content and <code>save</code> is
    * <code>true</code>, the user will be given the opportunity to save
    * them.
    * </p>
    *
    * @param editorRefs
    *            the editors to close
    * @param save
    *            <code>true</code> to save the editor contents if required
    *            (recommended), and <code>false</code> to discard any unsaved
    *            changes
    * @return <code>true</code> if the editors were successfully closed, and
    *         <code>false</code> if the editors are still open
    * @since 3.0
    */
   virtual bool CloseEditors(const std::list<IEditorReference::Pointer>& editorRefs, bool save) = 0;
 
   /**
    * Closes the given editor. The editor must belong to this workbench page.
    * <p>
    * If the editor has unsaved content and <code>save</code> is
    * <code>true</code>, the user will be given the opportunity to save it.
    * </p>
    *
    * @param editor
    *            the editor to close
    * @param save
    *            <code>true</code> to save the editor contents if required
    *            (recommended), and <code>false</code> to discard any unsaved
    *            changes
    * @return <code>true</code> if the editor was successfully closed, and
    *         <code>false</code> if the editor is still open
    */
   virtual bool CloseEditor(IEditorPart::Pointer editor, bool save) = 0;
 
   /**
    * Returns the view in this page with the specified id. There is at most one
    * view in the page with the specified id.
    *
    * @param viewId
    *            the id of the view extension to use
    * @return the view, or <code>null</code> if none is found
    */
   virtual IViewPart::Pointer FindView(const std::string& viewId) = 0;
 
   /**
    * Returns the view reference with the specified id.
    *
    * @param viewId
    *            the id of the view extension to use
    * @return the view reference, or <code>null</code> if none is found
    * @since 3.0
    */
   virtual IViewReference::Pointer FindViewReference(const std::string& viewId) = 0;
 
   /**
    * Returns the view reference with the specified id and secondary id.
    *
    * @param viewId
    *            the id of the view extension to use
    * @param secondaryId
    *            the secondary id to use, or <code>null</code> for no
    *            secondary id
    * @return the view reference, or <code>null</code> if none is found
    * @since 3.0
    */
   virtual IViewReference::Pointer FindViewReference(const std::string& viewId, const std::string& secondaryId) = 0;
 
   /**
    * Returns the active editor open in this page.
    * <p>
    * This is the visible editor on the page, or, if there is more than one
    * visible editor, this is the one most recently brought to top.
    * </p>
    *
    * @return the active editor, or <code>null</code> if no editor is active
    */
   virtual IEditorPart::Pointer GetActiveEditor() = 0;
 
   /**
    * Returns the editor with the specified input. Returns null if there is no
    * opened editor with that input.
    *
    * @param input
    *            the editor input
    * @return an editor with input equals to <code>input</code>
    */
   virtual IEditorPart::Pointer FindEditor(IEditorInput::Pointer input) = 0;
 
   /**
    * Returns an array of editor references that match the given input and/or
    * editor id, as specified by the given match flags. Returns an empty array
    * if there are no matching editors, or if matchFlags is MATCH_NONE.
    *
    * @param input
    *            the editor input, or <code>null</code> if MATCH_INPUT is not
    *            specified in matchFlags
    * @param editorId
    *            the editor id, or <code>null</code> if MATCH_ID is not
    *            specified in matchFlags
    * @param matchFlags
    *            a bit mask consisting of zero or more of the MATCH_* constants
    *            OR-ed together
    * @return the references for the matching editors
    *
    * @see #MATCH_NONE
    * @see #MATCH_INPUT
    * @see #MATCH_ID
    * @since 3.2
    */
   virtual std::vector<IEditorReference::Pointer> FindEditors(IEditorInput::Pointer input, const std::string& editorId,
       int matchFlags) = 0;
 
   /**
    * Returns a list of the editors open in this page.
    * <p>
    * Note that each page has its own editors; editors are never shared between
    * pages.
    * </p>
    *
    * @return a list of open editors
    *
    * @deprecated use #getEditorReferences() instead
    */
   virtual std::vector<IEditorPart::Pointer> GetEditors() = 0;
 
   /**
    * Returns an array of references to open editors in this page.
    * <p>
    * Note that each page has its own editors; editors are never shared between
    * pages.
    * </p>
    *
    * @return a list of open editors
    */
   virtual std::list<IEditorReference::Pointer> GetEditorReferences() = 0;
 
   /**
    * Returns a list of dirty editors in this page.
    *
    * @return a list of dirty editors
    */
   virtual std::vector<IEditorPart::Pointer> GetDirtyEditors() = 0;
 
   /**
    * Returns the input for this page.
    *
    * @return the input for this page, or <code>null</code> if none
    */
   virtual IAdaptable* GetInput() = 0;
 
   /**
    * Returns the page label. This will be a unique identifier within the
    * containing workbench window.
    *
    * @return the page label
    */
   virtual std::string GetLabel() = 0;
 
   /**
    * Returns the current perspective descriptor for this page, or
    * <code>null</code> if there is no current perspective.
    *
    * @return the current perspective descriptor or <code>null</code>
    * @see #setPerspective
    * @see #savePerspective
    */
   virtual IPerspectiveDescriptor::Pointer GetPerspective() = 0;
 
   /**
    * Returns a list of the reference to views visible on this page.
    * <p>
    * Note that each page has its own views; views are never shared between
    * pages.
    * </p>
    *
    * @return a list of references to visible views
    */
   virtual std::vector<IViewReference::Pointer> GetViewReferences() = 0;
 
   /**
    * Returns a list of the views visible on this page.
    * <p>
    * Note that each page has its own views; views are never shared between
    * pages.
    * </p>
    *
    * @return a list of visible views
    *
    * @deprecated use #getViewReferences() instead.
    */
   virtual std::vector<IViewPart::Pointer> GetViews() = 0;
 
   /**
    * Returns the workbench window of this page.
    *
    * @return the workbench window
    */
   virtual IWorkbenchWindow::Pointer GetWorkbenchWindow() = 0;
 
   /**
    * Hides the given view. The view must belong to this page.
    *
    * @param view
    *            the view to hide
    */
   virtual void HideView(IViewPart::Pointer view) = 0;
 
   /**
    * Hides the given view that belongs to the reference, if any.
    *
    * @param view
    *            the references whos view is to be hidden
    * @since 3.0
    */
   virtual void HideView(IViewReference::Pointer view) = 0;
 
   /**
    * Returns true if perspective with given id contains view with given id
    */
   virtual bool HasView(const std::string& perspectiveId, const std::string& viewId) = 0;
 
   /**
    * Returns whether the specified part is visible.
    *
    * @param part
    *            the part to test
    * @return boolean <code>true</code> if part is visible
    */
   virtual bool IsPartVisible(IWorkbenchPart::Pointer part) = 0;
 
+  /**
+   * Removes the perspective specified by desc.
+   *
+   * @param desc
+   *            the perspective that will be removed
+   */
+  virtual void RemovePerspective(IPerspectiveDescriptor::Pointer desc) = 0;
+
   /**
    * Reuses the specified editor by setting its new input.
    *
    * @param editor
    *            the editor to be reused
    * @param input
    *            the new input for the reusable editor
    */
   virtual void ReuseEditor(IReusableEditor::Pointer editor, IEditorInput::Pointer input) = 0;
 
   /**
    * Opens an editor on the given input.
    * <p>
    * If this page already has an editor open on the target input that editor
    * is activated; otherwise, a new editor is opened. Two editor inputs,
    * input1 and input2, are considered the same if
    *
    * <pre>
    * input1.equals(input2) == true
    * </pre>.
    * </p>
    * <p>
    * The editor type is determined by mapping <code>editorId</code> to an
    * editor extension registered with the workbench. An editor id is passed
    * rather than an editor object to prevent the accidental creation of more
    * than one editor for the same input. It also guarantees a consistent
    * lifecycle for editors, regardless of whether they are created by the user
    * or restored from saved data.
    * </p>
    *
    * @param input
    *            the editor input
    * @param editorId
    *            the id of the editor extension to use
    * @return an open and active editor, or <code>null</code> if an external
    *         editor was opened
    * @exception PartInitException
    *                if the editor could not be created or initialized
    */
   virtual IEditorPart::Pointer OpenEditor(IEditorInput::Pointer input, const std::string& editorId) = 0;
 
   /**
    * Opens an editor on the given input.
    * <p>
    * If this page already has an editor open on the target input that editor
    * is brought to the front; otherwise, a new editor is opened. Two editor
    * inputs are considered the same if they equal. See
    * <code>Object.equals(Object)<code>
    * and <code>IEditorInput</code>. If <code>activate == true</code> the editor
    * will be activated.
    * </p><p>
    * The editor type is determined by mapping <code>editorId</code> to an editor
    * extension registered with the workbench.  An editor id is passed rather than
    * an editor object to prevent the accidental creation of more than one editor
    * for the same input. It also guarantees a consistent lifecycle for editors,
    * regardless of whether they are created by the user or restored from saved
    * data.
    * </p>
    *
    * @param input the editor input
    * @param editorId the id of the editor extension to use
    * @param activate if <code>true</code> the editor will be activated
    * @return an open editor, or <code>null</code> if an external editor was opened
    * @exception PartInitException if the editor could not be created or initialized
    */
   virtual IEditorPart::Pointer OpenEditor(IEditorInput::Pointer input, const std::string& editorId,
       bool activate) = 0;
 
   /**
    * Opens an editor on the given input.
    * <p>
    * If this page already has an editor open that matches the given input
    * and/or editor id (as specified by the matchFlags argument), that editor
    * is brought to the front; otherwise, a new editor is opened. Two editor
    * inputs are considered the same if they equal. See
    * <code>Object.equals(Object)<code>
    * and <code>IEditorInput</code>. If <code>activate == true</code> the editor
    * will be activated.
    * </p><p>
    * The editor type is determined by mapping <code>editorId</code> to an editor
    * extension registered with the workbench.  An editor id is passed rather than
    * an editor object to prevent the accidental creation of more than one editor
    * for the same input. It also guarantees a consistent lifecycle for editors,
    * regardless of whether they are created by the user or restored from saved
    * data.
    * </p>
    *
    * @param input the editor input
    * @param editorId the id of the editor extension to use
    * @param activate if <code>true</code> the editor will be activated
    * @param matchFlags a bit mask consisting of zero or more of the MATCH_* constants OR-ed together
    * @return an open editor, or <code>null</code> if an external editor was opened
    * @exception PartInitException if the editor could not be created or initialized
    *
    * @see #MATCH_NONE
    * @see #MATCH_INPUT
    * @see #MATCH_ID
    * @since 3.2
    */
   virtual IEditorPart::Pointer OpenEditor(IEditorInput::Pointer input,
       const std::string& editorId, bool activate, int matchFlags) = 0;
-  public:
-  virtual void CreatePerspective(SmartPointer<berry::IPerspectiveDescriptor> desc)  = 0;
+
   /**
    * Removes the property change listener.
    *
    * @param listener
    *            the property change listener to remove
    * @since 2.0
    */
   //virtual void removePropertyChangeListener(IPropertyChangeListener listener);
 
   /**
    * Changes the visible views, their layout, and the visible action sets
    * within the page to match the current perspective descriptor. This is a
    * rearrangement of components and not a replacement. The contents of the
    * current perspective descriptor are unaffected.
    * <p>
    * For more information on perspective change see
    * <code>setPerspective()</code>.
    * </p>
    */
   virtual void ResetPerspective() = 0;
 
   /**
    * Saves the contents of all dirty editors belonging to this workbench page.
    * If there are no dirty editors this method returns without effect.
    * <p>
    * If <code>confirm</code> is <code>true</code> the user is prompted to
    * confirm the command.
    * </p>
    * <p>
    * Note that as of 3.2, this method also saves views that implement
    * ISaveablePart and are dirty.
    * </p>
    *
    * @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;
 
   /**
    * Saves the contents of the given editor if dirty. If not, this method
    * returns without effect.
    * <p>
    * If <code>confirm</code> is <code>true</code> the user is prompted to
    * confirm the command. Otherwise, the save happens without prompt.
    * </p>
    * <p>
    * The editor must belong to this workbench page.
    * </p>
    *
    * @param editor
    *            the editor to close
    * @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 editor was not saved
    */
   virtual bool SaveEditor(IEditorPart::Pointer editor, bool confirm) = 0;
 
   /**
    * Saves the visible views, their layout, and the visible action sets for
    * this page to the current perspective descriptor. The contents of the
    * current perspective descriptor are overwritten.
    */
   virtual void SavePerspective() = 0;
 
   /**
    * Saves the visible views, their layout, and the visible action sets for
    * this page to the given perspective descriptor. The contents of the given
    * perspective descriptor are overwritten and it is made the current one for
    * this page.
    *
    * @param perspective
    *            the perspective descriptor to save to
    */
   virtual void SavePerspectiveAs(IPerspectiveDescriptor::Pointer perspective) = 0;
 
 
   /**
    * Changes the visible views, their layout, and the visible action sets
    * within the page to match the given perspective descriptor. This is a
    * rearrangement of components and not a replacement. The contents of the
    * old perspective descriptor are unaffected.
    * <p>
    * When a perspective change occurs the old perspective is deactivated
    * (hidden) and cached for future reference. Then the new perspective is
    * activated (shown). The views within the page are shared by all existing
    * perspectives to make it easy for the user to switch between one
    * perspective and another quickly without loss of context.
    * </p>
    * <p>
    * During activation the action sets are modified. If an action set is
    * specified in the new perspective which is not visible in the old one it
    * will be created. If an old action set is not specified in the new
    * perspective it will be disposed.
    * </p>
    * <p>
    * The visible views and their layout within the page also change. If a view
    * is specified in the new perspective which is not visible in the old one a
    * new instance of the view will be created. If an old view is not specified
    * in the new perspective it will be hidden. This view may reappear if the
    * user selects it from the View menu or if they switch to a perspective
    * (which may be the old one) where the view is visible.
    * </p>
    * <p>
    * The open editors are not modified by this method.
    * </p>
    *
    * @param perspective
    *            the perspective descriptor
    */
   virtual void SetPerspective(IPerspectiveDescriptor::Pointer perspective) = 0;
 
   /**
    * Shows the view identified by the given view id in this page and gives it
    * focus. If there is a view identified by the given view id (and with no
    * secondary id) already open in this page, it is given focus.
    *
    * @param viewId
    *            the id of the view extension to use
    * @return the shown view
    * @exception PartInitException
    *                if the view could not be initialized
    */
   virtual IViewPart::Pointer ShowView(const std::string& viewId) = 0;
 
   /**
    * Shows a view in this page with the given id and secondary id. The
    * behaviour of this method varies based on the supplied mode. If
    * <code>VIEW_ACTIVATE</code> is supplied, the view is focus. If
    * <code>VIEW_VISIBLE</code> is supplied, then it is made visible but not
    * given focus. Finally, if <code>VIEW_CREATE</code> is supplied the view
    * is created and will only be made visible if it is not created in a folder
    * that already contains visible views.
    * <p>
    * This allows multiple instances of a particular view to be created. They
    * are disambiguated using the secondary id. If a secondary id is given, the
    * view must allow multiple instances by having specified
    * allowMultiple="true" in its extension.
    * </p>
    *
    * @param viewId
    *            the id of the view extension to use
    * @param secondaryId
    *            the secondary id to use, or <code>null</code> for no
    *            secondary id
    * @param mode
    *            the activation mode. Must be {@link #VIEW_ACTIVATE},
    *            {@link #VIEW_VISIBLE} or {@link #VIEW_CREATE}
    * @return a view
    * @exception PartInitException
    *                if the view could not be initialized
    * @exception IllegalArgumentException
    *                if the supplied mode is not valid
    * @since 3.0
    */
   virtual IViewPart::Pointer ShowView(const std::string& viewId, const std::string& secondaryId, int mode) = 0;
 
   /**
    * Returns <code>true</code> if the editor is pinned and should not be
    * reused.
    *
    * @param editor
    *            the editor to test
    * @return boolean whether the editor is pinned
    */
   virtual bool IsEditorPinned(IEditorPart::Pointer editor) = 0;
 
   /**
    * Returns the perspective shortcuts associated with the current
    * perspective. Returns an empty array if there is no current perspective.
    *
    * @see IPageLayout#addPerspectiveShortcut(String)
    * @return an array of perspective identifiers
    * @since 3.1
    */
   virtual std::vector<std::string> GetPerspectiveShortcuts() = 0;
 
   /**
    * Returns the show view shortcuts associated with the current perspective.
    * Returns an empty array if there is no current perspective.
    *
    * @see IPageLayout#addShowViewShortcut(String)
    * @return an array of view identifiers
    * @since 3.1
    */
   virtual std::vector<std::string> GetShowViewShortcuts() = 0;
 
   /**
    * Returns the descriptors for the perspectives that are open in this page,
    * in the order in which they were opened.
    *
    * @return the open perspective descriptors, in order of opening
    * @since 3.1
    */
   virtual std::vector<IPerspectiveDescriptor::Pointer> GetOpenPerspectives() = 0;
 
   /**
    * Returns the descriptors for the perspectives that are open in this page,
    * in the order in which they were activated (oldest first).
    *
    * @return the open perspective descriptors, in order of activation
    * @since 3.1
    */
   virtual std::vector<IPerspectiveDescriptor::Pointer> GetSortedPerspectives() = 0;
 
   /**
    * Closes current perspective. If last perspective, then entire page
    * is closed.
    *
    * @param saveParts
    *            whether the page's parts should be saved if closed
    * @param closePage
    *            whether the page itself should be closed if last perspective
    */
   virtual void CloseCurrentPerspective(bool saveParts, bool closePage) = 0;
 
   /**
    * Closes the specified perspective in this page. If the last perspective in
    * this page is closed, then all editors are closed. Views that are not
    * shown in other perspectives are closed as well. If <code>saveParts</code>
    * is <code>true</code>, the user will be prompted to save any unsaved
    * changes for parts that are being closed. The page itself is closed if
    * <code>closePage</code> is <code>true</code>.
    *
    * @param desc
    *            the descriptor of the perspective to be closed
    * @param saveParts
    *            whether the page's parts should be saved if closed
    * @param closePage
    *            whether the page itself should be closed if last perspective
    * @since 3.1
    */
   virtual void ClosePerspective(IPerspectiveDescriptor::Pointer desc,
       bool saveParts, bool closePage) = 0;
 
   /**
    * Closes all perspectives in this page. All editors are closed, prompting
    * to save any unsaved changes if <code>saveEditors</code> is
    * <code>true</code>. The page itself is closed if <code>closePage</code>
    * is <code>true</code>.
    *
    * @param saveEditors
    *            whether the page's editors should be saved
    * @param closePage
    *            whether the page itself should be closed
    * @since 3.1
    */
   virtual void CloseAllPerspectives(bool saveEditors, bool closePage) = 0;
 
   /**
    * Find the part reference for the given part. A convenience method to
    * quickly go from part to part reference.
    *
    * @param part
    *            The part to search for. It can be <code>null</code>.
    * @return The reference for the given part, or <code>null</code> if no
    *         reference can be found.
    * @since 3.2
    */
   virtual IWorkbenchPartReference::Pointer GetReference(IWorkbenchPart::Pointer part) = 0;
 };
 }  // namespace berry
 
 #endif /*BERRYIWORKBENCHPAGE_H_*/
diff --git a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchPage.cpp b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchPage.cpp
index 524a38aec7..dc7655fe53 100644
--- a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchPage.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchPage.cpp
@@ -1,4119 +1,4113 @@
 /*===================================================================
 
 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 <berryIExtensionPointService.h>
 #include <berryPlatform.h>
 
 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.remove(perspective);
   PerspectiveListType::size_type origSize = openedList.size();
   openedList.remove(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.rbegin());
     }
   }
 }
 
 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.remove(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*/)
 {
   std::vector<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 (unsigned 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);
 }
 
 std::vector<SmartPointer<IEditorReference> > WorkbenchPage::ActivationList::GetEditors()
 {
   std::vector<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;
 }
 
 std::vector<SmartPointer<IWorkbenchPartReference> > WorkbenchPage::ActivationList::GetParts()
 {
   std::vector<IViewReference::Pointer> views(page->GetViewReferences());
   std::vector<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 (unsigned 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)
   {
     std::string oldId;
     if (_topEditor)
     {
       oldId = _topEditor->GetSite()->GetId();
     }
     std::string 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;
   }
 
   std::string oldId;
   if (!topEditor.Expired())
   {
     oldId = topEditor.Lock()->GetSite()->GetId();
   }
   std::string 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);
 }
 
 const IExtensionPoint* WorkbenchPage::GetPerspectiveExtensionPoint()
 {
   return Platform::GetExtensionPointService()->GetExtensionPoint(
       PlatformUI::PLUGIN_ID + "."
           + WorkbenchRegistryConstants::PL_PERSPECTIVE_EXTENSIONS);
 }
 
 WorkbenchPage::WorkbenchPage(WorkbenchWindow* w, const std::string& 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::Pointer l)
 {
   partList->GetPartService()->AddPartListener(l);
 }
 
 void WorkbenchPage::AddSelectionListener(ISelectionListener::Pointer listener)
 {
   selectionService->AddSelectionListener(listener);
 }
 
 void WorkbenchPage::AddSelectionListener(const std::string& partId,
     ISelectionListener::Pointer listener)
 {
   selectionService->AddSelectionListener(partId, listener);
 }
 
 void WorkbenchPage::AddPostSelectionListener(
     ISelectionListener::Pointer listener)
 {
   selectionService->AddPostSelectionListener(listener);
 }
 
 void WorkbenchPage::AddPostSelectionListener(const std::string& partId,
     ISelectionListener::Pointer 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;
   //  }
 
   //  std::string 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.
   std::string 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 std::string& viewID,
     const std::string& 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> ();
       std::vector<IViewReference::Pointer> viewStack =
           this->GetViewReferenceStack(part);
       for (unsigned 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
   std::list<IEditorReference::Pointer> editors = this->GetEditorReferences();
   std::list<IEditorReference::Pointer> savedEditors;
   for (std::list<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 std::list<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
   std::vector<IEditorReference::Pointer> editorRefs;
   for (std::list<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)
     {
       Poco::RuntimeException re(
           "WARNING: Blocked recursive attempt to close part " //$NON-NLS-1$
               + 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
   std::list<IWorkbenchPart::Pointer> partsToClose;
   for (unsigned 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 = this->GetWorkbenchWindow()->GetService(
         ISaveablesLifecycleListener::GetManifestName()).Cast<SaveablesList> ();
     // 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 (unsigned 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 (unsigned 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();
   std::vector<WorkbenchPartReference::Pointer> disposals = pendingDisposals;
   pendingDisposals.clear();
   for (unsigned 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)
 {
   std::list<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())
   {
     std::list<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();
   //  }
 
   std::vector<IWorkbenchPart::Pointer> partsToSave;
   std::list<IWorkbenchPart::Pointer> viewsToClose;
   // collect views that will go away and views that are dirty
   std::vector<IViewReference::Pointer> viewReferences =
       persp->GetViewReferences();
   for (unsigned 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
     std::list<IEditorReference::Pointer> editorReferences =
         this->GetEditorReferences();
     for (std::list<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 =
           this->GetWorkbenchWindow()->GetWorkbench()->GetService(
               ISaveablesLifecycleListener::GetManifestName()).Cast<
               SaveablesList> ();
   // 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();
   //        }
   //      });
 }
 
-void WorkbenchPage::CreatePerspective(SmartPointer<berry::IPerspectiveDescriptor> desc)
-{
-  this->CreatePerspective(desc.Cast<PerspectiveDescriptor>(), false);
-}
-
-
 Perspective::Pointer WorkbenchPage::CreatePerspective(
     PerspectiveDescriptor::Pointer desc, bool notify)
 {
   std::string 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() + "\"");
     }
     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.
       std::vector<IWorkbenchPartReference::Pointer> partsToClose =
           this->GetOpenParts();
       std::list<IWorkbenchPart::Pointer> dirtyParts;
       for (unsigned 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 =
           this->GetWorkbenchWindow()->GetWorkbench()->GetService(
               ISaveablesLifecycleListener::GetManifestName()).Cast<
               SaveablesList> ();
       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();
 
       // Capture views.
       std::vector<IViewReference::Pointer> refs = viewFactory->GetViews();
 
       //  if (refs.size() > 0)
       //  {
       //    // Dispose views.
       //    for (unsigned int i = 0; i < refs.size(); i++)
       //    {
       //      WorkbenchPartReference::Pointer ref = refs[i].Cast<WorkbenchPartReference>();
       //      //partList.RemovePart(ref);
       //      //this->FirePartClosed(refs[i]);
       //      //              Platform.run(new SafeRunnable() {
       //      //                  public void run() {
       //      // //                       WorkbenchPlugin.log(new Status(IStatus.WARNING, WorkbenchPlugin.PI_WORKBENCH,
       //      // //                               Status.OK, "WorkbenchPage leaked a refcount for view " + ref.getId(), 0));  //$NON-NLS-1$//$NON-NLS-2$
       //
       //      ref.dispose();
       //      //                  }
       //
       //      //                  public void handleException(Throwable e) {
       //      //                   }
       //      //              });
       //    }
       //  }
 
 
       // 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 = 0;
   }
 
   // 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 std::string& id)
 {
   IViewReference::Pointer ref = this->FindViewReference(id);
   if (ref == 0)
   {
     return IViewPart::Pointer(0);
   }
   return ref->GetView(true);
 }
 
 IViewReference::Pointer WorkbenchPage::FindViewReference(
     const std::string& viewId)
 {
   return this->FindViewReference(viewId, "");
 }
 
 IViewReference::Pointer WorkbenchPage::FindViewReference(
     const std::string& viewId, const std::string& 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 std::string& perspectiveId, const std::string& 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;
 }
 
 std::vector<IEditorPart::Pointer> WorkbenchPage::GetEditors()
 {
   std::list<IEditorReference::Pointer> refs = this->GetEditorReferences();
   std::vector<IEditorPart::Pointer> result;
   //Display d = getWorkbenchWindow().getShell().getDisplay();
   //Must be backward compatible.
   //    d.syncExec(new Runnable()
   //        {
   //        public void WorkbenchPage::run()
   //          {
   for (std::list<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;
 }
 
 std::vector<IEditorPart::Pointer> WorkbenchPage::GetDirtyEditors()
 {
   return this->GetEditorManager()->GetDirtyEditors();
 }
 
 std::vector<ISaveablePart::Pointer> WorkbenchPage::GetDirtyParts()
 {
   std::vector<ISaveablePart::Pointer> result;
   std::vector<IWorkbenchPartReference::Pointer> allParts = this->GetAllParts();
   for (unsigned 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);
 }
 
 std::vector<IEditorReference::Pointer> WorkbenchPage::FindEditors(
     IEditorInput::Pointer input, const std::string& editorId, int matchFlags)
 {
   return this->GetEditorManager()->FindEditors(input, editorId, matchFlags);
 }
 
 std::list<IEditorReference::Pointer> WorkbenchPage::GetEditorReferences()
 {
   return editorPresentation->GetEditors();
 }
 
 IAdaptable* WorkbenchPage::GetInput()
 {
   return input;
 }
 
 std::string WorkbenchPage::GetLabel()
 {
   std::string 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 std::string& partId)
 {
   return selectionService->GetSelection(partId);
 }
 
 //ISelectionService::SelectionEvents& WorkbenchPage::GetSelectionEvents(const std::string& partId)
 //{
 //  return selectionService->GetSelectionEvents(partId);
 //}
 
 ViewFactory* WorkbenchPage::GetViewFactory()
 {
   if (viewFactory == 0)
   {
     viewFactory = new ViewFactory(this,
         WorkbenchPlugin::GetDefault()->GetViewRegistry());
   }
   return viewFactory;
 }
 
 std::vector<IViewReference::Pointer> WorkbenchPage::GetViewReferences()
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp != 0)
   {
     return persp->GetViewReferences();
   }
   else
   {
     return std::vector<IViewReference::Pointer>();
   }
 }
 
 std::vector<IViewPart::Pointer> WorkbenchPage::GetViews()
 {
   return this->GetViews(Perspective::Pointer(0), true);
 }
 
 std::vector<IViewPart::Pointer> WorkbenchPage::GetViews(
     Perspective::Pointer persp, bool restore)
 {
   if (persp == 0)
   {
     persp = this->GetActivePerspective();
   }
 
   std::vector<IViewPart::Pointer> parts;
   if (persp != 0)
   {
     std::vector<IViewReference::Pointer> refs = persp->GetViewReferences();
     for (unsigned 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();
         std::vector<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::Pointer saveablesList;
   SaveablesList::PostCloseInfo::Pointer postCloseInfo;
   if (refCount == 1)
   {
     IWorkbenchPart::Pointer actualPart = ref->GetPart(false);
     if (actualPart != 0)
     {
       saveablesList
           = actualPart->GetSite()->GetService(
               ISaveablesLifecycleListener::GetManifestName()).Cast<
               SaveablesList> ();
       std::list<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 std::string& 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 = 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
   std::string extras = ""; //PrefUtil.getAPIPreferenceStore().getString(
   //    IWorkbenchPreferenceConstants.PERSPECTIVE_BAR_EXTRAS);
   Poco::StringTokenizer tok(extras, ", ", Poco::StringTokenizer::TOK_TRIM
       | Poco::StringTokenizer::TOK_IGNORE_EMPTY); //$NON-NLS-1$
   std::vector<IPerspectiveDescriptor::Pointer> descs;
   for (Poco::StringTokenizer::Iterator itr = tok.begin(); itr != tok.end(); ++itr)
   {
     std::string id = *itr;
     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 std::string& editorID)
 {
   return this->OpenEditor(input, editorID, true, MATCH_INPUT);
 }
 
 IEditorPart::Pointer WorkbenchPage::OpenEditor(IEditorInput::Pointer input,
     const std::string& editorID, bool activate)
 {
   return this->OpenEditor(input, editorID, activate, MATCH_INPUT);
 }
 
 IEditorPart::Pointer WorkbenchPage::OpenEditor(
     const IEditorInput::Pointer input, const std::string& editorID,
     bool activate, int matchFlags)
 {
   return this->OpenEditor(input, editorID, activate, matchFlags,
       IMemento::Pointer(0));
 }
 
 IEditorPart::Pointer WorkbenchPage::OpenEditor(
     const IEditorInput::Pointer input, const std::string& 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 std::string& 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 std::string& 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())
       {
         std::vector<std::string> 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)
         {
           //          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)
         {
           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::Pointer 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::Pointer listener)
 {
   selectionService->RemoveSelectionListener(listener);
 }
 
 void WorkbenchPage::RemoveSelectionListener(const std::string& partId,
     ISelectionListener::Pointer listener)
 {
   selectionService->RemoveSelectionListener(partId, listener);
 }
 
 void WorkbenchPage::RemovePostSelectionListener(
     ISelectionListener::Pointer listener)
 {
   selectionService->RemovePostSelectionListener(listener);
 }
 
 void WorkbenchPage::RemovePostSelectionListener(const std::string& partId,
     ISelectionListener::Pointer 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
     std::string 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)
       //      {
       //        std::vector<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);
       std::string activePartID;
       childMem->GetString(WorkbenchConstants::TAG_ACTIVE_PART, activePartID);
       std::string activePartSecondaryID;
       if (!activePartID.empty())
       {
         activePartSecondaryID = ViewFactory::ExtractSecondaryId(activePartID);
         if (!activePartSecondaryID.empty())
         {
           activePartID = ViewFactory::ExtractPrimaryId(activePartID);
         }
       }
       std::string activePerspectiveID;
       childMem->GetString(WorkbenchConstants::TAG_ACTIVE_PERSPECTIVE,
           activePerspectiveID);
 
       // Restore perspectives.
       std::vector<IMemento::Pointer> perspMems(childMem->GetChildren(
           WorkbenchConstants::TAG_PERSPECTIVE));
       Perspective::Pointer activePerspective;
 
       IPerspectiveDescriptor::Pointer validPersp;
       for (std::size_t 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;
         std::string myActivePartId = activePartID;
         std::string mySecondaryId = activePartSecondaryID;
         //          StartupThreading.runWithoutExceptions(new StartupRunnable()
         //              {
         //
         //              public void WorkbenchPage::runWithException() throws Throwable
         //                {
         window->FirePerspectiveActivated(WorkbenchPage::Pointer(this),
             myPerspective->GetDesc());
 
         // Restore active part.
         if (!myActivePartId.empty())
         {
           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);
 
       //      std::string 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 (...)
     {
       //      std::string 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;
 }
 
 std::string WorkbenchPage::GetId(IWorkbenchPart::Pointer part)
 {
   return this->GetId(this->GetReference(part));
 }
 
 std::string 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(Poco::RuntimeException(
               "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)
       {
         std::string title = "Restoring problems";
         std::string msg = "Unable to read workbench state.";
         MessageDialog::OpenError(this->GetWorkbenchWindow()->GetShell(), 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
   std::vector<IViewReference::Pointer> oldRefs;
   if (oldPersp != 0)
   {
     oldRefs = oldPersp->GetViewReferences();
     for (unsigned 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();
     std::vector<IViewReference::Pointer> newRefs =
     newPersp->GetViewReferences();
     for (unsigned 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 (unsigned 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 std::string& viewID)
 {
   return this->ShowView(viewID, "", VIEW_ACTIVATE);
 }
 
 IViewPart::Pointer WorkbenchPage::ShowView(const std::string& viewID,
     const std::string& secondaryID, int mode)
 {
   if (secondaryID != "")
   {
     if (secondaryID.size() == 0 || secondaryID.find_first_of(
             ViewFactory::ID_SEP) != std::string::npos)
     {
       throw Poco::InvalidArgumentException(
           "Illegal secondary id (cannot be empty or contain a colon)");
     }
   }
   if (!this->CertifyMode(mode))
   {
     throw Poco::InvalidArgumentException("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;
 }
 
 std::vector<IEditorReference::Pointer> WorkbenchPage::GetSortedEditors()
 {
   return activationList->GetEditors();
 }
 
 std::vector<IPerspectiveDescriptor::Pointer> WorkbenchPage::GetOpenPerspectives()
 {
   std::list<Perspective::Pointer> opened = perspList.GetOpenedPerspectives();
   std::vector<IPerspectiveDescriptor::Pointer> result;
   for (std::list<Perspective::Pointer>::iterator iter = opened.begin(); iter
       != opened.end(); ++iter)
   {
     result.push_back((*iter)->GetDesc());
   }
   return result;
 }
 
 std::list<Perspective::Pointer> WorkbenchPage::GetOpenInternalPerspectives()
 {
   return perspList.GetOpenedPerspectives();
 }
 
 Perspective::Pointer WorkbenchPage::GetFirstPerspectiveWithView(
     IViewPart::Pointer part)
 {
   std::list<Perspective::Pointer> perspectives =
   perspList.GetSortedPerspectives();
   for (std::list<Perspective::Pointer>::reverse_iterator iter =
       perspectives.rbegin(); iter != perspectives.rend(); ++iter)
   {
     if ((*iter)->ContainsView(part))
     {
       return *iter;
     }
   }
   // we should never get here
   return Perspective::Pointer(0);
 }
 
 std::vector<IPerspectiveDescriptor::Pointer> WorkbenchPage::GetSortedPerspectives()
 {
   std::list<Perspective::Pointer> sortedArray =
   perspList.GetSortedPerspectives();
   std::vector<IPerspectiveDescriptor::Pointer> result;
   for (std::list<Perspective::Pointer>::iterator iter = sortedArray.begin();
       iter != sortedArray.end(); ++iter)
   {
     result.push_back((*iter)->GetDesc());
   }
   return result;
 }
 
 std::vector<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());
 }
 
 std::vector<IViewReference::Pointer> WorkbenchPage::GetViewReferenceStack(
     IViewPart::Pointer part)
 {
   // Sanity check.
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0 || !this->CertifyPart(part))
   {
     return std::vector<IViewReference::Pointer>();
   }
 
   ILayoutContainer::Pointer container =
   part->GetSite().Cast<PartSite> ()->GetPane()->GetContainer();
   if (container.Cast<PartStack> () != 0)
   {
     PartStack::Pointer folder = container.Cast<PartStack> ();
     std::vector<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;
   }
 
   std::vector<IViewReference::Pointer> result;
   result.push_back(this->GetReference(part).Cast<IViewReference> ());
   return result;
 }
 
 std::vector<IViewPart::Pointer> WorkbenchPage::GetViewStack(
     IViewPart::Pointer part)
 {
   std::vector<IViewReference::Pointer> refStack = this->GetViewReferenceStack(
       part);
 
   std::vector<IViewPart::Pointer> result;
 
   for (unsigned 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);
 }
 
 std::vector<IWorkbenchPartReference::Pointer> WorkbenchPage::GetAllParts()
 {
   std::vector<IViewReference::Pointer> views = viewFactory->GetViews();
   std::list<IEditorReference::Pointer> editors = this->GetEditorReferences();
 
   std::vector<IWorkbenchPartReference::Pointer> result;
 
   for (unsigned int i = 0; i < views.size(); i++)
   {
     result.push_back(views[i]);
   }
 
   for (std::list<IEditorReference::Pointer>::iterator iter = editors.begin(); iter
       != editors.end(); ++iter)
   {
     result.push_back(*iter);
   }
 
   return result;
 }
 
 std::vector<IWorkbenchPartReference::Pointer> WorkbenchPage::GetOpenParts()
 {
   std::vector<IWorkbenchPartReference::Pointer> refs = this->GetAllParts();
   std::vector<IWorkbenchPartReference::Pointer> result;
 
   for (unsigned 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()
  */
 std::vector<std::string> WorkbenchPage::GetPerspectiveShortcuts()
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0)
   {
     return std::vector<std::string>();
   }
   return persp->GetPerspectiveShortcuts();
 }
 
 std::vector<std::string> WorkbenchPage::GetShowViewShortcuts()
 {
   Perspective::Pointer persp = this->GetActivePerspective();
   if (persp == 0)
   {
     return std::vector<std::string>();
   }
   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?"))
   {
     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);
 }
 }
\ No newline at end of file
diff --git a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchPage.h b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchPage.h
index 14e39294fe..2995dcc713 100644
--- a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchPage.h
+++ b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchPage.h
@@ -1,1797 +1,1801 @@
 /*===================================================================
 
 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 BERRYWORKBENCHPAGE_H_
 #define BERRYWORKBENCHPAGE_H_
 
 #include <berryIAdaptable.h>
 #include <berryIExtensionPoint.h>
 
 #include "berryIWorkbenchPage.h"
 #include "berryIWorkbenchPartReference.h"
 #include "berryIReusableEditor.h"
 
 #include "berryILayoutContainer.h"
 #include "berryIStickyViewManager.h"
 #include "berryWorkbenchPagePartList.h"
 #include "berryWorkbenchPartReference.h"
 #include "berryPageSelectionService.h"
 #include "berryEditorManager.h"
 #include "berryViewFactory.h"
 
 #include "berryPartPane.h"
 
 #include <list>
 
 namespace berry
 {
 //class PartPane;
 //class PartPane::Sashes;
 class EditorAreaHelper;
 class WorkbenchWindow;
 class Perspective;
 class PerspectiveHelper;
 class PerspectiveDescriptor;
 class LayoutPartSash;
 class LayoutTree;
 class LayoutTreeNode;
 class PartService;
 
 /**
  * \ingroup org_blueberry_ui_internal
  *
  * A collection of views and editors in a workbench.
  */
 class BERRY_UI WorkbenchPage: public IWorkbenchPage
 {
 public:
   berryObjectMacro(WorkbenchPage);
 
 protected:
 
   //TODO Weakpointer
   WorkbenchWindow* window;
 
   friend class ViewFactory;
   friend class WorkbenchWindow;
   friend class EditorAreaHelper;
   friend class WWinPartService;
 
 private:
 
   /**
    * Manages editor contributions and action set part associations.
    */
   class ActionSwitcher
   {
   private:
     IWorkbenchPart::WeakPtr activePart;
 
     IEditorPart::WeakPtr topEditor;
 
     /**
      * Updates the contributions given the new part as the active part.
      *
      * @param newPart
      *            the new active part, may be <code>null</code>
      */
   public:
     void UpdateActivePart(IWorkbenchPart::Pointer newPart);
     /**
      * Updates the contributions given the new part as the topEditor.
      *
      * @param newEditor
      *            the new top editor, may be <code>null</code>
      */
   public:
     void UpdateTopEditor(IEditorPart::Pointer newEditor);
 
     /**
      * Activates the contributions of the given part. If <code>enable</code>
      * is <code>true</code> the contributions are visible and enabled,
      * otherwise they are disabled.
      *
      * @param part
      *            the part whose contributions are to be activated
      * @param enable
      *            <code>true</code> the contributions are to be enabled,
      *            not just visible.
      */
   private:
     void ActivateContributions(IWorkbenchPart::Pointer part, bool enable);
 
     /**
      * Deactivates the contributions of the given part. If <code>remove</code>
      * is <code>true</code> the contributions are removed, otherwise they
      * are disabled.
      *
      * @param part
      *            the part whose contributions are to be deactivated
      * @param remove
      *            <code>true</code> the contributions are to be removed,
      *            not just disabled.
      */
   private:
     void DeactivateContributions(IWorkbenchPart::Pointer part, bool remove);
   };
 
   class ActivationList
   {
   public:
 
     //List of parts in the activation order (oldest first)
     typedef std::deque<IWorkbenchPartReference::Pointer> PartListType;
     typedef std::deque<IWorkbenchPartReference::Pointer>::iterator PartListIter;
     typedef std::deque<IWorkbenchPartReference::Pointer>::reverse_iterator PartListReverseIter;
 
   private:
 
     PartListType parts;
 
     WorkbenchPage* page;
 
   public:
     ActivationList(WorkbenchPage* page);
 
     /*
      * Add/Move the active part to end of the list;
      */
     void SetActive(SmartPointer<IWorkbenchPart> part);
 
     /*
      * Ensures that the given part appears AFTER any other part in the same
      * container.
      */
     void BringToTop(SmartPointer<IWorkbenchPartReference> ref);
 
     /*
      * Returns the last (most recent) iterator (index) of the given container in the activation list, or returns
      * end() if the given container does not appear in the activation list.
      */
     PartListIter LastIndexOfContainer(SmartPointer<ILayoutContainer> container);
 
     /*
      * Add/Move the active part to end of the list;
      */
     void SetActive(SmartPointer<IWorkbenchPartReference> ref);
 
     /*
      * Add the active part to the beginning of the list.
      */
     void Add(SmartPointer<IWorkbenchPartReference> ref);
 
     /*
      * Return the active part. Filter fast views.
      */
     SmartPointer<IWorkbenchPart> GetActive();
 
     /*
      * Return the previously active part. Filter fast views.
      */
     SmartPointer<IWorkbenchPart> GetPreviouslyActive();
 
     SmartPointer<IWorkbenchPartReference> GetActiveReference(bool editorsOnly);
 
     /*
      * Retuns the index of the part within the activation list. The higher
      * the index, the more recently it was used.
      */
     PartListIter IndexOf(SmartPointer<IWorkbenchPart> part);
 
     /*
      * Returns the index of the part reference within the activation list.
      * The higher the index, the more recent it was used.
      */
     PartListIter IndexOf(SmartPointer<IWorkbenchPartReference> ref);
 
     /*
      * Remove a part from the list
      */
     bool Remove(SmartPointer<IWorkbenchPartReference> ref);
 
     /*
      * Returns the topmost editor on the stack, or null if none.
      */
     SmartPointer<IEditorPart> GetTopEditor();
 
     /*
      * Returns the editors in activation order (oldest first).
      */
     std::vector<SmartPointer<IEditorReference> > GetEditors();
 
     /*
      * Return a list with all parts (editors and views).
      */
     std::vector<SmartPointer<IWorkbenchPartReference> > GetParts();
 
   private:
 
     SmartPointer<IWorkbenchPart> GetActive(PartListIter start);
 
     SmartPointer<IWorkbenchPartReference> GetActiveReference(PartListIter start, bool editorsOnly);
 
     /*
      * Find a part in the list starting from the end and filter
      * and views from other perspectives. Will filter fast views
      * unless 'includeActiveFastViews' is true;
      */
     SmartPointer<IWorkbenchPartReference> GetActiveReference(PartListIter start, bool editorsOnly, bool skipPartsObscuredByZoom);
   };
 
   /**
    * Helper class to keep track of all opened perspective. Both the opened
    * and used order is kept.
    */
   struct PerspectiveList
   {
   public:
     typedef std::list<SmartPointer<Perspective> > PerspectiveListType;
     typedef PerspectiveListType::iterator iterator;
 
   private:
 
     /**
      * List of perspectives in the order they were opened;
      */
     PerspectiveListType openedList;
 
     /**
      * List of perspectives in the order they were used. Last element is
      * the most recently used, and first element is the least recently
      * used.
      */
     PerspectiveListType usedList;
 
     /**
      * The perspective explicitly set as being the active one
      */
     SmartPointer<Perspective> active;
 
     void UpdateActionSets(SmartPointer<Perspective> oldPersp,
         SmartPointer<Perspective> newPersp);
 
   public:
 
     /**
      * Creates an empty instance of the perspective list
      */
     PerspectiveList();
 
     /**
      * Update the order of the perspectives in the opened list
      *
      * @param perspective
      * @param newLoc
      */
     void Reorder(IPerspectiveDescriptor::Pointer perspective, int newLoc);
 
     /**
      * Return all perspectives in the order they were activated.
      *
      * @return an array of perspectives sorted by activation order, least
      *         recently activated perspective last.
      */
     PerspectiveListType GetSortedPerspectives();
 
     /**
      * Adds a perspective to the list. No check is done for a duplicate when
      * adding.
      * @param perspective the perspective to add
      * @return boolean <code>true</code> if the perspective was added
      */
     bool Add(SmartPointer<Perspective> perspective);
 
     /**
      * Returns an iterator on the perspective list in the order they were
      * opened.
      */
     PerspectiveListType::iterator Begin();
 
     PerspectiveListType::iterator End();
 
     /**
      * Returns an array with all opened perspectives
      */
     PerspectiveListType GetOpenedPerspectives();
 
     /**
      * Removes a perspective from the list.
      */
     bool Remove(SmartPointer<Perspective> perspective);
 
     /**
      * Swap the opened order of old perspective with the new perspective.
      */
     void Swap(SmartPointer<Perspective> oldPerspective,
         SmartPointer<Perspective> newPerspective);
 
     /**
      * Returns whether the list contains any perspectives
      */
     bool IsEmpty();
 
     /**
      * Returns the most recently used perspective in the list.
      */
     SmartPointer<Perspective> GetActive();
 
     /**
      * Returns the next most recently used perspective in the list.
      */
     SmartPointer<Perspective> GetNextActive();
 
     /**
      * Returns the number of perspectives opened
      */
     PerspectiveListType::size_type Size();
 
     /**
      * Marks the specified perspective as the most recently used one in the
      * list.
      */
     void SetActive(SmartPointer<Perspective> perspective);
   };
 
   IAdaptable* input;
 
   void* composite;
 
   //Could be delete. This information is in the active part list;
   ActivationList* activationList;
 
   EditorManager* editorMgr;
 
   EditorAreaHelper* editorPresentation;
 
   //ListenerList propertyChangeListeners = new ListenerList();
 
   PageSelectionService* selectionService;
 
   WorkbenchPagePartList::Pointer partList; // = new WorkbenchPagePartList(selectionService);
 
   //IActionBars actionBars;
 
   ViewFactory* viewFactory;
 
   PerspectiveList perspList;
 
   SmartPointer<PerspectiveDescriptor> deferredActivePersp;
 
   //NavigationHistory navigationHistory = new NavigationHistory(this);
 
   IStickyViewManager::Pointer stickyViewMan;
 
 
 
   /**
    * Returns true if perspective with given id contains view with given id
    */
   bool HasView(const std::string& perspectiveId, const std::string& viewId);
 
   /**
    * If we're in the process of activating a part, this points to the new part.
    * Otherwise, this is null.
    */
   IWorkbenchPartReference::Pointer partBeingActivated;
 
   /**
    * Contains a list of perspectives that may be dirty due to plugin
    * installation and removal.
    */
   std::set<std::string> dirtyPerspectives;
 
   ActionSwitcher actionSwitcher;
 
   //IExtensionTracker tracker;
 
   // Deferral count... delays disposing parts and sending certain events if nonzero
   int deferCount;
   // Parts waiting to be disposed
   std::vector<WorkbenchPartReference::Pointer> pendingDisposals;
 
   const IExtensionPoint* GetPerspectiveExtensionPoint();
 
 public:
 
   /**
    * Constructs a new page with a given perspective and input.
    *
    * @param w
    *            the parent window
    * @param layoutID
    *            must not be <code>null</code>
    * @param input
    *            the page input
    * @throws WorkbenchException
    *             on null layout id
    */
   WorkbenchPage(WorkbenchWindow* w, const std::string& layoutID,
       IAdaptable* input);
 
   /**
    * Constructs a page. <code>restoreState(IMemento)</code> should be
    * called to restore this page from data stored in a persistance file.
    *
    * @param w
    *            the parent window
    * @param input
    *            the page input
    * @throws WorkbenchException
    */
   WorkbenchPage(WorkbenchWindow* w, IAdaptable* input);
 
   ~WorkbenchPage();
 
   /**
    * Activates a part. The part will be brought to the front and given focus.
    *
    * @param part
    *            the part to activate
    */
   void Activate(IWorkbenchPart::Pointer part);
 
   /**
    * Activates a part. The part is given focus, the pane is hilighted.
    */
 private:
   void ActivatePart(const IWorkbenchPart::Pointer part);
 
   /**
    * Adds an IPartListener to the part service.
    */
 public:
   void AddPartListener(IPartListener::Pointer l);
 
   /*
    * (non-Javadoc) Method declared on ISelectionListener.
    */
 public:
   void AddSelectionListener(ISelectionListener::Pointer listener);
 
   /*
    * (non-Javadoc) Method declared on ISelectionListener.
    */
 public:
   void AddSelectionListener(const std::string& partId,
       ISelectionListener::Pointer listener);
 
   /*
    * (non-Javadoc) Method declared on ISelectionListener.
    */
 public:
   void AddPostSelectionListener(ISelectionListener::Pointer listener);
 
   /*
    * (non-Javadoc) Method declared on ISelectionListener.
    */
 public:
   void AddPostSelectionListener(const std::string& partId,
       ISelectionListener::Pointer listener);
 
 private:
   ILayoutContainer::Pointer GetContainer(IWorkbenchPart::Pointer part);
 
 private:
   ILayoutContainer::Pointer GetContainer(IWorkbenchPartReference::Pointer part);
 
 private:
   SmartPointer<PartPane> GetPane(IWorkbenchPart::Pointer part);
 
 private:
   SmartPointer<PartPane> GetPane(IWorkbenchPartReference::Pointer part);
 
   /**
    * Brings a part to the front of its stack. Does not update the active part or
    * active editor. This should only be called if the caller knows that the part
    * is not in the same stack as the active part or active editor, or if the caller
    * is prepared to update activation after the call.
    *
    * @param part
    */
 private:
   bool InternalBringToTop(IWorkbenchPartReference::Pointer part);
 
   /**
    * Moves a part forward in the Z order of a perspective so it is visible.
    * If the part is in the same stack as the active part, the new part is
    * activated.
    *
    * @param part
    *            the part to bring to move forward
    */
 public:
   void BringToTop(IWorkbenchPart::Pointer part);
 
   /**
    * Resets the layout for the perspective. The active part in the old layout
    * is activated in the new layout for consistent user context.
    *
    * Assumes the busy cursor is active.
    */
 private:
   void BusyResetPerspective();
 
   /**
    * Implements <code>setPerspective</code>.
    *
    * Assumes that busy cursor is active.
    *
    * @param desc
    *            identifies the new perspective.
    */
 private:
   void BusySetPerspective(IPerspectiveDescriptor::Pointer desc);
 
+  /**
+   * Removes the perspective which match the given description.
+   *
+   * @param desc
+   *            identifies the perspective to be removed.
+   */
   public:
     void RemovePerspective(IPerspectiveDescriptor::Pointer desc);
   /**
    * Shows a view.
    *
    * Assumes that a busy cursor is active.
    */
 protected:
   IViewPart::Pointer BusyShowView(const std::string& viewID,
       const std::string& secondaryID, int mode);
 
   /*
    * Performs showing of the view in the given mode.
    */
 private:
   void BusyShowView(IViewPart::Pointer part, int mode);
 
   /**
    * Returns whether a part exists in the current page.
    */
 private:
   bool CertifyPart(IWorkbenchPart::Pointer part);
 
   /**
    * Closes the perspective.
    */
 public:
   bool Close();
 
   /**
    * See IWorkbenchPage
    */
 public:
   bool CloseAllSavedEditors();
 
   /**
    * See IWorkbenchPage
    */
 public:
   bool CloseAllEditors(bool save);
 
 private:
   void UpdateActivePart();
 
   /**
    * Makes the given part active. Brings it in front if necessary. Permits null
    * (indicating that no part should be active).
    *
    * @since 3.1
    *
    * @param ref new active part (or null)
    */
 private:
   void MakeActive(IWorkbenchPartReference::Pointer ref);
 
   /**
    * Makes the given editor active. Brings it to front if necessary. Permits <code>null</code>
    * (indicating that no editor is active).
    *
    * @since 3.1
    *
    * @param ref the editor to make active, or <code>null</code> for no active editor
    */
 private:
   void MakeActiveEditor(IEditorReference::Pointer ref);
 
   /**
    * See IWorkbenchPage
    */
 public:
   bool CloseEditors(const std::list<IEditorReference::Pointer>& refArray,
       bool save);
 
   /**
    * Enables or disables listener notifications. This is used to delay listener notifications until the
    * end of a public method.
    *
    * @param shouldDefer
    */
 private:
   void DeferUpdates(bool shouldDefer);
 
 private:
   void StartDeferring();
 
 private:
   void HandleDeferredEvents();
 
 private:
   bool IsDeferred();
 
   /**
    * See IWorkbenchPage#closeEditor
    */
 public:
   bool CloseEditor(IEditorReference::Pointer editorRef, bool save);
 
   /**
    * See IWorkbenchPage#closeEditor
    */
 public:
   bool CloseEditor(IEditorPart::Pointer editor, bool save);
 
   /**
    * @see IWorkbenchPage#closePerspective(IPerspectiveDescriptor, boolean, boolean)
    */
 public:
 
   void CloseCurrentPerspective(bool saveParts, bool closePage);
   /**
    * Closes current perspective. If last perspective, then entire page
    * is closed.
    *
    * @param saveParts
    *            whether the page's parts should be saved if closed
    * @param closePage
    *            whether the page itself should be closed if last perspective
    */
 
   void ClosePerspective(IPerspectiveDescriptor::Pointer desc, bool saveParts,
       bool closePage);
 
   /**
    * Closes the specified perspective. If last perspective, then entire page
    * is closed.
    *
    * @param persp
    *            the perspective to be closed
    * @param saveParts
    *            whether the parts that are being closed should be saved
    *            (editors if last perspective, views if not shown in other
    *            parspectives)
    */
   /* package */
 protected:
   void ClosePerspective(SmartPointer<Perspective> persp, bool saveParts,
       bool closePage);
 
   /**
    * @see IWorkbenchPage#closeAllPerspectives(boolean, boolean)
    */
 public:
   void CloseAllPerspectives(bool saveEditors, bool closePage);
 
   /**
    * Creates the client composite.
    */
 private:
   void CreateClientComposite();
 
   /**
    * Creates a new view set. Return null on failure.
    *
    * @param desc the perspective descriptor
    * @param notify whether to fire a perspective opened event
    */
 private:
   SmartPointer<Perspective> CreatePerspective(SmartPointer<PerspectiveDescriptor> desc,
       bool notify);
-  public:
-    virtual void CreatePerspective(SmartPointer<berry::IPerspectiveDescriptor> desc);
 
   /**
    * This is called by child objects after a part has been added to the page.
    * The page will in turn notify its listeners.
    */
   /* package */
 protected:
   void PartAdded(WorkbenchPartReference::Pointer ref);
 
   /**
    * This is called by child objects after a part has been added to the page.
    * The part will be queued for disposal after all listeners have been notified
    */
   /* package */
 protected:
   void PartRemoved(WorkbenchPartReference::Pointer ref);
 
 private:
   void DisposePart(WorkbenchPartReference::Pointer ref);
 
   /**
    * Deactivates a part. The pane is unhilighted.
    */
 private:
   void DeactivatePart(IWorkbenchPart::Pointer part);
 
   /**
    * Detaches a view from the WorkbenchWindow.
    */
 public:
   void DetachView(IViewReference::Pointer ref);
 
   /**
    * Removes a detachedwindow.
    */
 public:
   void AttachView(IViewReference::Pointer ref);
 
   /**
    * Dispose a perspective.
    *
    * @param persp the perspective descriptor
    * @param notify whether to fire a perspective closed event
    */
 private:
   void DisposePerspective(SmartPointer<Perspective> persp, bool notify);
 
   /**
    * Returns the first view manager with given ID.
    */
 public:
   SmartPointer<Perspective> FindPerspective(IPerspectiveDescriptor::Pointer desc);
 
   /**
    * See IWorkbenchPage@findView.
    */
 public:
   IViewPart::Pointer FindView(const std::string& id);
 
   /*
    * (non-Javadoc)
    *
    * @see org.blueberry.ui.IWorkbenchPage
    */
 public:
   IViewReference::Pointer FindViewReference(const std::string& viewId);
 
   /*
    * (non-Javadoc)
    *
    * @see org.blueberry.ui.IWorkbenchPage
    */
 public:
   IViewReference::Pointer FindViewReference(const std::string& viewId,
       const std::string& secondaryId);
 
   /**
    * Notify property change listeners about a property change.
    *
    * @param changeId
    *            the change id
    * @param oldValue
    *            old property value
    * @param newValue
    *            new property value
    */
   //private: void FirePropertyChange(String changeId, Object oldValue,
   //            Object newValue) {
   //
   //        UIListenerLogging.logPagePropertyChanged(this, changeId, oldValue, newValue);
   //
   //        Object[] listeners = propertyChangeListeners.getListeners();
   //        PropertyChangeEvent event = new PropertyChangeEvent(this, changeId,
   //                oldValue, newValue);
   //
   //        for (int i = 0; i < listeners.length; i++) {
   //            ((IPropertyChangeListener) listeners[i]).propertyChange(event);
   //        }
   //    }
 
 
   /**
    * @see IWorkbenchPage
    */
 public:
   IEditorPart::Pointer GetActiveEditor();
 
   /**
    * Returns the reference for the active editor, or <code>null</code>
    * if there is no active editor.
    *
    * @return the active editor reference or <code>null</code>
    */
 public:
   IEditorReference::Pointer GetActiveEditorReference();
 
   /*
    * (non-Javadoc) Method declared on IPartService
    */
 public:
   IWorkbenchPart::Pointer GetActivePart();
 
   /*
    * (non-Javadoc) Method declared on IPartService
    */
 public:
   IWorkbenchPartReference::Pointer GetActivePartReference();
 
   /**
    * Returns the active perspective for the page, <code>null</code> if
    * none.
    */
 public:
   SmartPointer<Perspective> GetActivePerspective();
 
   /**
    * Returns the client composite.
    */
 public:
   void* GetClientComposite();
 
   //  for dynamic UI - change access from private to protected
   // for testing purposes only, changed from protected to public
   /**
    * Answer the editor manager for this window.
    */
 public:
   EditorManager* GetEditorManager();
 
   /**
    * Answer the perspective presentation.
    */
 public:
   PerspectiveHelper* GetPerspectivePresentation();
 
   /**
    * Answer the editor presentation.
    */
 public:
   EditorAreaHelper* GetEditorPresentation();
 
   /**
    * Allow access to the part service for this page ... used internally to
    * propogate certain types of events to the page part listeners.
    * @return the part service for this page.
    */
 public: PartService* GetPartService();
 
   /**
    * See IWorkbenchPage.
    */
 public:
   std::vector<IEditorPart::Pointer> GetEditors();
 
 public:
   std::vector<IEditorPart::Pointer> GetDirtyEditors();
 
 public:
   std::vector<ISaveablePart::Pointer> GetDirtyParts();
 
   /**
    * See IWorkbenchPage.
    */
 public:
   IEditorPart::Pointer FindEditor(IEditorInput::Pointer input);
 
   /**
    * See IWorkbenchPage.
    */
 public:
   std::vector<IEditorReference::Pointer> FindEditors(
       IEditorInput::Pointer input, const std::string& editorId, int matchFlags);
 
   /**
    * See IWorkbenchPage.
    */
 public:
   std::list<IEditorReference::Pointer> GetEditorReferences();
 
   /**
    * @see IWorkbenchPage
    */
 public:
   IAdaptable* GetInput();
 
   /**
    * Returns the page label. This is a combination of the page input and
    * active perspective.
    */
 public:
   std::string GetLabel();
 
   /**
    * Returns the perspective.
    */
 public:
   IPerspectiveDescriptor::Pointer GetPerspective();
 
   /*
    * (non-Javadoc) Method declared on ISelectionService
    */
 public:
   ISelection::ConstPointer GetSelection() const;
 
   /*
    * (non-Javadoc) Method declared on ISelectionService
    */
 public:
   ISelection::ConstPointer GetSelection(const std::string& partId);
 
 //public:
 //  SelectionEvents& GetSelectionEvents(const std::string& partId = "");
 
   /*
    * Returns the view factory.
    */
 public:
   ViewFactory* GetViewFactory();
 
   /**
    * See IWorkbenchPage.
    */
 public:
   std::vector<IViewReference::Pointer> GetViewReferences();
 
   /**
    * See IWorkbenchPage.
    */
 public:
   std::vector<IViewPart::Pointer> GetViews();
 
   /**
    * Returns all view parts in the specified perspective
    *
    * @param persp the perspective
    * @return an array of view parts
    * @since 3.1
    */
   /*package*/
 protected:
   std::vector<IViewPart::Pointer> GetViews(SmartPointer<Perspective> persp,
       bool restore);
 
   /**
    * See IWorkbenchPage.
    */
 public:
   IWorkbenchWindow::Pointer GetWorkbenchWindow();
 
   /*
    * (non-Javadoc)
    *
    * @see org.blueberry.ui.IWorkbenchPage#hideView(org.blueberry.ui.IViewReference)
    */
 public:
   void HideView(IViewReference::Pointer ref);
 
   /* package */
 protected:
   void RefreshActiveView();
 
   /**
    * See IPerspective
    */
 public:
   void HideView(IViewPart::Pointer view);
 
   /**
    * Initialize the page.
    *
    * @param w
    *            the parent window
    * @param layoutID
    *            may be <code>null</code> if restoring from file
    * @param input
    *            the page input
    * @param openExtras
    *            whether to process the perspective extras preference
    */
 private:
   void Init(WorkbenchWindow* w, const std::string& layoutID,
       IAdaptable* input, bool openExtras);
 
   /**
    * Opens the perspectives specified in the PERSPECTIVE_BAR_EXTRAS preference (see bug 84226).
    */
 public:
   void OpenPerspectiveExtras();
 
   /**
    * See IWorkbenchPage.
    */
 public:
   bool IsPartVisible(IWorkbenchPart::Pointer part);
 
   /**
    * See IWorkbenchPage.
    */
 public:
   bool IsEditorAreaVisible();
 
   /**
    * Returns whether the view is fast.
    */
 public:
   bool IsFastView(IViewReference::Pointer ref);
 
   /**
    * Return whether the view is closeable or not.
    *
    * @param ref the view reference to check.  Must not be <code>null</code>.
    * @return true if the part is closeable.
    * @since 3.1.1
    */
 public:
   bool IsCloseable(IViewReference::Pointer ref);
 
   /**
    * Return whether the view is moveable or not.
    *
    * @param ref the view reference to check.  Must not be <code>null</code>.
    * @return true if the part is moveable.
    * @since 3.1.1
    */
 public:
   bool IsMoveable(IViewReference::Pointer ref);
 
   /**
    * Returns whether the layout of the active
    * perspective is fixed.
    */
 public:
   bool IsFixedLayout();
 
   /**
    * Return true if the perspective has a dirty editor.
    */
 protected:
   bool IsSaveNeeded();
 
   /**
    * This method is called when the page is activated.
    */
 protected:
   void OnActivate();
 
   /**
    * This method is called when the page is deactivated.
    */
 protected:
   void OnDeactivate();
 
   /**
    * See IWorkbenchPage.
    */
 public:
   void
   ReuseEditor(IReusableEditor::Pointer editor, IEditorInput::Pointer input);
 
   /**
    * See IWorkbenchPage.
    */
 public:
   IEditorPart::Pointer OpenEditor(IEditorInput::Pointer input,
       const std::string& editorID);
 
   /**
    * See IWorkbenchPage.
    */
 public:
   IEditorPart::Pointer OpenEditor(IEditorInput::Pointer input,
       const std::string& editorID, bool activate);
 
   /**
    * See IWorkbenchPage.
    */
 public:
   IEditorPart::Pointer OpenEditor(IEditorInput::Pointer input,
       const std::string& editorID, bool activate, int matchFlags);
 
   /**
    * This is not public API but for use internally.  editorState can be <code>null</code>.
    */
 public:
   IEditorPart::Pointer OpenEditor(IEditorInput::Pointer input,
       const std::string& editorID, bool activate, int matchFlags,
       IMemento::Pointer editorState);
 
   /*
    * Added to fix Bug 178235 [EditorMgmt] DBCS 3.3 - Cannot open file with external program.
    * Opens a new editor using the given input and descriptor. (Normally, editors are opened using
    * an editor ID and an input.)
    */
 public:
   IEditorPart::Pointer OpenEditorFromDescriptor(IEditorInput::Pointer input,
       IEditorDescriptor::Pointer editorDescriptor, bool activate,
       IMemento::Pointer editorState);
 
   /**
    * @see #openEditor(IEditorInput, String, boolean, int)
    */
 private:
   IEditorPart::Pointer BusyOpenEditor(IEditorInput::Pointer input,
       const std::string& editorID, bool activate, int matchFlags,
       IMemento::Pointer editorState);
 
   /*
    * Added to fix Bug 178235 [EditorMgmt] DBCS 3.3 - Cannot open file with external program.
    * See openEditorFromDescriptor().
    */
 private:
   IEditorPart::Pointer BusyOpenEditorFromDescriptor(
       IEditorInput::Pointer input,
       EditorDescriptor::Pointer editorDescriptor, bool activate,
       IMemento::Pointer editorState);
 
   /**
    * Do not call this method.  Use <code>busyOpenEditor</code>.
    *
    * @see IWorkbenchPage#openEditor(IEditorInput, String, boolean)
    */
 protected:
   IEditorPart::Pointer BusyOpenEditorBatched(IEditorInput::Pointer input,
       const std::string& editorID, bool activate, int matchFlags,
       IMemento::Pointer editorState);
 
   /*
    * Added to fix Bug 178235 [EditorMgmt] DBCS 3.3 - Cannot open file with external program.
    * See openEditorFromDescriptor().
    */
 private:
   IEditorPart::Pointer BusyOpenEditorFromDescriptorBatched(
       IEditorInput::Pointer input, EditorDescriptor::Pointer editorDescriptor,
       bool activate, IMemento::Pointer editorState);
 
 public:
   void OpenEmptyTab();
 
 protected:
   void ShowEditor(bool activate, IEditorPart::Pointer editor);
 
   /**
    * See IWorkbenchPage.
    */
 public:
   bool IsEditorPinned(IEditorPart::Pointer editor);
 
   /**
    * Removes an IPartListener from the part service.
    */
 public:
   void RemovePartListener(IPartListener::Pointer l);
 
   /*
    * (non-Javadoc) Method declared on ISelectionListener.
    */
 public:
   void RemoveSelectionListener(ISelectionListener::Pointer listener);
 
   /*
    * (non-Javadoc) Method declared on ISelectionListener.
    */
 public:
   void RemoveSelectionListener(const std::string& partId,
       ISelectionListener::Pointer listener);
 
   /*
    * (non-Javadoc) Method declared on ISelectionListener.
    */
 public:
   void RemovePostSelectionListener(ISelectionListener::Pointer listener);
 
   /*
    * (non-Javadoc) Method declared on ISelectionListener.
    */
 public:
   void RemovePostSelectionListener(const std::string& partId,
       ISelectionListener::Pointer listener);
 
   /**
    * This method is called when a part is activated by clicking within it. In
    * response, the part, the pane, and all of its actions will be activated.
    *
    * In the current design this method is invoked by the part pane when the
    * pane, the part, or any children gain focus.
    */
 public:
   void RequestActivation(IWorkbenchPart::Pointer part);
 
   /**
    * Resets the layout for the perspective. The active part in the old layout
    * is activated in the new layout for consistent user context.
    */
 public:
   void ResetPerspective();
 
   /**
    * Restore this page from the memento and ensure that the active
    * perspective is equals the active descriptor otherwise create a new
    * perspective for that descriptor. If activeDescriptor is null active the
    * old perspective.
    */
 public:
   /*IStatus*/bool RestoreState(IMemento::Pointer memento,
       IPerspectiveDescriptor::Pointer activeDescriptor);
 
   /**
    * See IWorkbenchPage
    */
 public:
   bool SaveAllEditors(bool confirm);
 
   /**
    * @param confirm
    * @param addNonPartSources true if saveables from non-part sources should be saved too
    * @return false if the user cancelled
    *
    */
 public:
   bool SaveAllEditors(bool confirm, bool addNonPartSources);
 
   /*
    * Saves the workbench part.
    */
 protected:
   bool SavePart(ISaveablePart::Pointer saveable, IWorkbenchPart::Pointer part,
       bool confirm);
 
   /**
    * Saves an editors in the workbench. If <code>confirm</code> is <code>true</code>
    * the user is prompted to confirm the command.
    *
    * @param confirm
    *            if user confirmation should be sought
    * @return <code>true</code> if the command succeeded, or <code>false</code>
    *         if the user cancels the command
    */
 public:
   bool SaveEditor(IEditorPart::Pointer editor, bool confirm);
 
   /**
    * Saves the current perspective.
    */
 public:
   void SavePerspective();
 
   /**
    * Saves the perspective.
    */
 public:
   void SavePerspectiveAs(IPerspectiveDescriptor::Pointer newDesc);
 
   /**
    * Save the state of the page.
    */
 public:
   /*IStatus*/bool SaveState(IMemento::Pointer memento);
 
 private:
   std::string GetId(IWorkbenchPart::Pointer part);
 
 private:
   std::string GetId(IWorkbenchPartReference::Pointer ref);
 
   /**
    * Sets the active part.
    */
 private:
   void SetActivePart(IWorkbenchPart::Pointer newPart);
 
   /**
    * See IWorkbenchPage.
    */
 public:
   void SetEditorAreaVisible(bool showEditorArea);
 
   /**
    * Sets the layout of the page. Assumes the new perspective is not null.
    * Keeps the active part if possible. Updates the window menubar and
    * toolbar if necessary.
    */
 private:
   void SetPerspective(SmartPointer<Perspective> newPersp);
 
   /*
    * Update visibility state of all views.
    */
 private:
   void UpdateVisibility(SmartPointer<Perspective> oldPersp,
       SmartPointer<Perspective> newPersp);
 
   /**
    * Sets the perspective.
    *
    * @param desc
    *            identifies the new perspective.
    */
 public:
   void SetPerspective(IPerspectiveDescriptor::Pointer desc);
 
   /**
    * Restore the toolbar layout for the active perspective.
    */
 protected:
   void ResetToolBarLayout();
 
   /**
    * See IWorkbenchPage.
    */
 public:
   IViewPart::Pointer ShowView(const std::string& viewID);
 
   /*
    * (non-Javadoc)
    *
    * @see org.blueberry.ui.IWorkbenchPage#showView(java.lang.String,
    *      java.lang.String, int)
    */
 public:
   IViewPart::Pointer ShowView(const std::string& viewID,
       const std::string& secondaryID, int mode);
 
   /**
    * @param mode the mode to test
    * @return whether the mode is recognized
    * @since 3.0
    */
 private:
   bool CertifyMode(int mode);
 
   /*
    * Returns the editors in activation order (oldest first).
    */
 public:
   std::vector<IEditorReference::Pointer> GetSortedEditors();
 
   /**
    * @see IWorkbenchPage#getOpenPerspectives()
    */
 public:
   std::vector<IPerspectiveDescriptor::Pointer> GetOpenPerspectives();
 
   /**
    * Return all open Perspective objects.
    *
    * @return all open Perspective objects
    * @since 3.1
    */
   /*package*/
 protected:
   std::list<SmartPointer<Perspective> > GetOpenInternalPerspectives();
 
   /**
    * Checks perspectives in the order they were activiated
    * for the specfied part.  The first sorted perspective
    * that contains the specified part is returned.
    *
    * @param part specified part to search for
    * @return the first sorted perspespective containing the part
    * @since 3.1
    */
   /*package*/
 protected:
   SmartPointer<Perspective> GetFirstPerspectiveWithView(IViewPart::Pointer part);
 
   /**
    * Returns the perspectives in activation order (oldest first).
    */
 public:
   std::vector<IPerspectiveDescriptor::Pointer> GetSortedPerspectives();
 
   /*
    * Returns the parts in activation order (oldest first).
    */
 public:
   std::vector<IWorkbenchPartReference::Pointer> GetSortedParts();
 
   /**
    * Returns the reference to the given part, or <code>null</code> if it has no reference
    * (i.e. it is not a top-level part in this workbench page).
    *
    * @param part the part
    * @return the part's reference or <code>null</code> if the given part does not belong
    * to this workbench page
    */
 public:
   IWorkbenchPartReference::Pointer GetReference(IWorkbenchPart::Pointer part);
 
   //  private: class ActivationList {
   //        //List of parts in the activation order (oldest first)
   //        List parts = new ArrayList();
   //
   //        /*
   //         * Add/Move the active part to end of the list;
   //         */
   //        void setActive(IWorkbenchPart part) {
   //            if (parts.size() <= 0) {
   //        return;
   //      }
   //      IWorkbenchPartReference ref = getReference(part);
   //      if (ref != null) {
   //        if (ref == parts.get(parts.size() - 1)) {
   //          return;
   //        }
   //        parts.remove(ref);
   //        parts.add(ref);
   //      }
   //        }
   //
   //        /*
   //     * Ensures that the given part appears AFTER any other part in the same
   //     * container.
   //     */
   //        void bringToTop(IWorkbenchPartReference ref) {
   //            ILayoutContainer targetContainer = getContainer(ref);
   //
   //            int newIndex = lastIndexOfContainer(targetContainer);
   //
   //            //New index can be -1 if there is no last index
   //            if (newIndex >= 0 && ref == parts.get(newIndex))
   //        return;
   //
   //            parts.remove(ref);
   //            if(newIndex >= 0)
   //              parts.add(newIndex, ref);
   //            else
   //              parts.add(ref);
   //        }
   //
   //        /*
   //         * Returns the last (most recent) index of the given container in the activation list, or returns
   //         * -1 if the given container does not appear in the activation list.
   //         */
   //        int lastIndexOfContainer(ILayoutContainer container) {
   //            for (int i = parts.size() - 1; i >= 0; i--) {
   //                IWorkbenchPartReference ref = (IWorkbenchPartReference)parts.get(i);
   //
   //                ILayoutContainer cnt = getContainer(ref);
   //                if (cnt == container) {
   //                    return i;
   //                }
   //            }
   //
   //            return -1;
   //        }
   //
   //        /*
   //         * Add/Move the active part to end of the list;
   //         */
   //        void setActive(IWorkbenchPartReference ref) {
   //            setActive(ref.getPart(true));
   //        }
   //
   //        /*
   //         * Add the active part to the beginning of the list.
   //         */
   //        void add(IWorkbenchPartReference ref) {
   //            if (parts.indexOf(ref) >= 0) {
   //        return;
   //      }
   //
   //            IWorkbenchPart part = ref.getPart(false);
   //            if (part != null) {
   //                PartPane pane = ((PartSite) part.getSite()).getPane();
   //                if (pane instanceof MultiEditorInnerPane) {
   //                    MultiEditorInnerPane innerPane = (MultiEditorInnerPane) pane;
   //                    add(innerPane.getParentPane().getPartReference());
   //                    return;
   //                }
   //            }
   //            parts.add(0, ref);
   //        }
   //
   //        /*
   //         * Return the active part. Filter fast views.
   //         */
   //        IWorkbenchPart getActive() {
   //            if (parts.isEmpty()) {
   //        return null;
   //      }
   //            return getActive(parts.size() - 1);
   //        }
   //
   //        /*
   //         * Return the previously active part. Filter fast views.
   //         */
   //        IWorkbenchPart getPreviouslyActive() {
   //            if (parts.size() < 2) {
   //        return null;
   //      }
   //            return getActive(parts.size() - 2);
   //        }
   //
   //  private: IWorkbenchPart getActive(int start) {
   //            IWorkbenchPartReference ref = getActiveReference(start, false);
   //
   //            if (ref == null) {
   //                return null;
   //            }
   //
   //            return ref.getPart(true);
   //        }
   //
   //  public: IWorkbenchPartReference getActiveReference(boolean editorsOnly) {
   //            return getActiveReference(parts.size() - 1, editorsOnly);
   //        }
   //
   //  private: IWorkbenchPartReference getActiveReference(int start, boolean editorsOnly) {
   //            // First look for parts that aren't obscured by the current zoom state
   //            IWorkbenchPartReference nonObscured = getActiveReference(start, editorsOnly, true);
   //
   //            if (nonObscured != null) {
   //                return nonObscured;
   //            }
   //
   //            // Now try all the rest of the parts
   //            return getActiveReference(start, editorsOnly, false);
   //        }
   //
   //        /*
   //         * Find a part in the list starting from the end and filter
   //         * and views from other perspectives. Will filter fast views
   //         * unless 'includeActiveFastViews' is true;
   //         */
   //  private: IWorkbenchPartReference getActiveReference(int start, boolean editorsOnly, boolean skipPartsObscuredByZoom) {
   //            IWorkbenchPartReference[] views = getViewReferences();
   //            for (int i = start; i >= 0; i--) {
   //                WorkbenchPartReference ref = (WorkbenchPartReference) parts
   //                        .get(i);
   //
   //                if (editorsOnly && !(ref instanceof IEditorReference)) {
   //                    continue;
   //                }
   //
   //                // Skip parts whose containers have disabled auto-focus
   //                PartPane pane = ref.getPane();
   //
   //                if (pane != null) {
   //                    if (!pane.allowsAutoFocus()) {
   //                        continue;
   //                    }
   //
   //                    if (skipPartsObscuredByZoom) {
   //                        if (pane.isObscuredByZoom()) {
   //                            continue;
   //                        }
   //                    }
   //                }
   //
   //                // Skip fastviews (unless overridden)
   //                if (ref instanceof IViewReference) {
   //                    if (ref == getActiveFastView() || !((IViewReference) ref).isFastView()) {
   //                        for (int j = 0; j < views.length; j++) {
   //                            if (views[j] == ref) {
   //                                return ref;
   //                            }
   //                        }
   //                    }
   //                } else {
   //                    return ref;
   //                }
   //            }
   //            return null;
   //        }
   //
   //        /*
   //         * Retuns the index of the part within the activation list. The higher
   //         * the index, the more recently it was used.
   //         */
   //        int indexOf(IWorkbenchPart part) {
   //          IWorkbenchPartReference ref = getReference(part);
   //          if (ref == null) {
   //            return -1;
   //          }
   //            return parts.indexOf(ref);
   //        }
   //
   //        /*
   //         * Returns the index of the part reference within the activation list.
   //         * The higher the index, the more recent it was used.
   //         */
   //        int indexOf(IWorkbenchPartReference ref) {
   //            return parts.indexOf(ref);
   //        }
   //
   //        /*
   //         * Remove a part from the list
   //         */
   //        boolean remove(IWorkbenchPartReference ref) {
   //            return parts.remove(ref);
   //        }
   //
   //        /*
   //         * Returns the editors in activation order (oldest first).
   //         */
   //  private: IEditorReference[] getEditors() {
   //            ArrayList editors = new ArrayList(parts.size());
   //            for (Iterator i = parts.iterator(); i.hasNext();) {
   //                IWorkbenchPartReference part = (IWorkbenchPartReference) i
   //                        .next();
   //                if (part instanceof IEditorReference) {
   //                    editors.add(part);
   //                }
   //            }
   //            return (IEditorReference[]) editors
   //                    .toArray(new IEditorReference[editors.size()]);
   //        }
   //
   //        /*
   //         * Return a list with all parts (editors and views).
   //         */
   //        private: IWorkbenchPartReference[] getParts() {
   //            IWorkbenchPartReference[] views = getViewReferences();
   //            ArrayList resultList = new ArrayList(parts.size());
   //            for (Iterator iterator = parts.iterator(); iterator.hasNext();) {
   //                IWorkbenchPartReference ref = (IWorkbenchPartReference) iterator
   //                        .next();
   //                if (ref instanceof IViewReference) {
   //                    //Filter views from other perspectives
   //                    for (int i = 0; i < views.length; i++) {
   //                        if (views[i] == ref) {
   //                            resultList.add(ref);
   //                            break;
   //                        }
   //                    }
   //                } else {
   //                    resultList.add(ref);
   //                }
   //            }
   //            IWorkbenchPartReference[] result = new IWorkbenchPartReference[resultList
   //                    .size()];
   //            return (IWorkbenchPartReference[]) resultList.toArray(result);
   //        }
   //
   //        /*
   //         * Returns the topmost editor on the stack, or null if none.
   //         */
   //        IEditorPart getTopEditor() {
   //            IEditorReference editor = (IEditorReference)getActiveReference(parts.size() - 1, true);
   //
   //            if (editor == null) {
   //                return null;
   //            }
   //
   //            return editor.getEditor(true);
   //        }
   //    };
 
 
   // for dynamic UI
 protected:
   void AddPerspective(SmartPointer<Perspective> persp);
 
   /**
    * Find the stack of view references stacked with this view part.
    *
    * @param part
    *            the part
    * @return the stack of references
    * @since 3.0
    */
 private:
   std::vector<IViewReference::Pointer> GetViewReferenceStack(
       IViewPart::Pointer part);
 
   /*
    * (non-Javadoc)
    *
    * @see org.blueberry.ui.IWorkbenchPage#getViewStack(org.blueberry.ui.IViewPart)
    */
 public:
   std::vector<IViewPart::Pointer> GetViewStack(IViewPart::Pointer part);
 
   /**
    * Allow for programmatically resizing a part.
    * <p>
    * <em>EXPERIMENTAL</em>
    * </p>
    * <p>
    * Known limitations:
    * <ul>
    * <li>currently applies only to views</li>
    * <li>has no effect when view is zoomed</li>
    * </ul>
    */
 public:
   void ResizeView(IViewPart::Pointer part, int width, int height);
 
 private:
 
   struct ActivationOrderPred : std::binary_function<IViewReference::Pointer,
   IViewReference::Pointer, bool>
   {
     ActivationOrderPred(ActivationList* partList);
 
     ActivationList* activationList;
 
     bool operator()(const IViewReference::Pointer o1, const IViewReference::Pointer o2) const;
   };
 
   // provides sash information for the given pane
   struct SashInfo
   {
     SmartPointer<LayoutPartSash> right;
 
     SmartPointer<LayoutPartSash> left;
 
     SmartPointer<LayoutPartSash> top;
 
     SmartPointer<LayoutPartSash> bottom;
 
     SmartPointer<LayoutTreeNode> rightNode;
 
     SmartPointer<LayoutTreeNode> leftNode;
 
     SmartPointer<LayoutTreeNode> topNode;
 
     SmartPointer<LayoutTreeNode> bottomNode;
   };
 
   void FindSashParts(SmartPointer<LayoutTree> tree, const PartPane::Sashes& sashes,
       SashInfo& info);
 
   /**
    * Returns all parts that are owned by this page
    *
    * @return
    */
 protected:
   std::vector<IWorkbenchPartReference::Pointer> GetAllParts();
 
   /**
    * Returns all open parts that are owned by this page (that is, all parts
    * for which a part opened event would have been sent -- these would be
    * activated parts whose controls have already been created.
    */
 protected:
   std::vector<IWorkbenchPartReference::Pointer> GetOpenParts();
 
   /**
    * Sanity-checks the objects in this page. Throws an Assertation exception
    * if an object's internal state is invalid. ONLY INTENDED FOR USE IN THE
    * UI TEST SUITES.
    */
 public:
   void TestInvariants();
 
   /* (non-Javadoc)
    * @see org.blueberry.ui.IWorkbenchPage#getExtensionTracker()
    */
   //public: IExtensionTracker GetExtensionTracker();
 
   /*
    * (non-Javadoc)
    *
    * @see org.blueberry.ui.IWorkbenchPage#getPerspectiveShortcuts()
    */
 public:
   std::vector<std::string> GetPerspectiveShortcuts();
 
   /*
    * (non-Javadoc)
    *
    * @see org.blueberry.ui.IWorkbenchPage#getShowViewShortcuts()
    */
 public:
   std::vector<std::string> GetShowViewShortcuts();
 
   /**
    * @since 3.1
    */
 private:
   void SuggestReset();
 
 public:
   bool IsPartVisible(IWorkbenchPartReference::Pointer reference);
 };
 }
 #endif /*BERRYWORKBENCHPAGE_H_*/