diff --git a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtMainWindowControl.cpp b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtMainWindowControl.cpp
index 85bd520ddc..a2c71cfc35 100755
--- a/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtMainWindowControl.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui.qt/src/internal/berryQtMainWindowControl.cpp
@@ -1,155 +1,155 @@
 /*===================================================================
 
 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 "berryQtMainWindowControl.h"
 
 #include <berryShell.h>
 
 #include <QEvent>
 #include <QMoveEvent>
 #include <QResizeEvent>
 #include <QWindowStateChangeEvent>
 
 namespace berry {
 
 QtMainWindowControl::QtMainWindowControl(Shell* shell, QWidget* parent, Qt::WindowFlags flags)
  : QMainWindow(parent, flags)
 {
   controller = new QtWidgetController(shell);
 
   // TODO WeakPointer: QVariant should hold a weak pointer
   QVariant variant(QVariant::UserType);
   variant.setValue(controller);
   this->setProperty(QtWidgetController::PROPERTY_ID, variant);
 }
 
 void QtMainWindowControl::changeEvent(QEvent* event)
 {
   if (!controller->shell)
     return QMainWindow::changeEvent(event);
 
   typedef IShellListener::Events::ShellEventType::ListenerList ListenerList;
   ShellEvent::Pointer shellEvent(new ShellEvent(Shell::Pointer(controller->shell)));
   switch (event->type())
   {
   case QEvent::ActivationChange:
   {
     if (isActiveWindow())
     {
       ListenerList activatedListeners(controller->shellEvents.shellActivated.GetListeners());
       for (ListenerList::iterator listener = activatedListeners.begin();
            listener != activatedListeners.end(); ++listener)
       {
         (*listener)->Execute(shellEvent);
         if (!shellEvent->doit) {
           event->accept();
           return;
         }
       }
     }
     else
     {
       ListenerList deactivatedListeners(controller->shellEvents.shellDeactivated.GetListeners());
       for (ListenerList::iterator listener = deactivatedListeners.begin();
            listener != deactivatedListeners.end(); ++listener)
       {
         (*listener)->Execute(shellEvent);
         if (!shellEvent->doit) {
           event->accept();
           return;
         }
       }
     }
   }
     break;
   case QEvent::WindowStateChange:
   {
     QWindowStateChangeEvent* stateEvent = dynamic_cast<QWindowStateChangeEvent*>(event);
     Qt::WindowStates oldState = stateEvent->oldState();
     if (this->isMinimized() && !(oldState & Qt::WindowMinimized))
     {
       ListenerList iconifiedListeners(controller->shellEvents.shellIconified.GetListeners());
       for (ListenerList::iterator listener = iconifiedListeners.begin();
          listener != iconifiedListeners.end(); ++listener)
       {
         (*listener)->Execute(shellEvent);
         if (!shellEvent->doit) {
           event->accept();
           return;
         }
       }
     }
     else if (oldState & Qt::WindowMinimized && !this->isMinimized())
     {
       ListenerList deiconifiedListeners(controller->shellEvents.shellDeiconified.GetListeners());
       for (ListenerList::iterator listener = deiconifiedListeners.begin();
          listener != deiconifiedListeners.end(); ++listener)
       {
         (*listener)->Execute(shellEvent);
         if (!shellEvent->doit) return;
       }
     }
   }
     break;
   default:
     break;
   }
 
   QMainWindow::changeEvent(event);
 }
 
 void QtMainWindowControl::closeEvent(QCloseEvent* event)
 {
   if (!controller->shell)
     return QMainWindow::changeEvent(event);
 
   typedef IShellListener::Events::ShellEventType::ListenerList ListenerList;
 
   ShellEvent::Pointer shellEvent(new ShellEvent(Shell::Pointer(controller->shell)));
 
   ListenerList closedListeners(controller->shellEvents.shellClosed.GetListeners());
   for (ListenerList::iterator listener = closedListeners.begin();
        listener != closedListeners.end(); ++listener)
   {
     (*listener)->Execute(shellEvent);
     if (!shellEvent->doit) {
-      event->accept();
+      event->ignore();
       return;
     }
   }
 
   QMainWindow::closeEvent(event);
 }
 
 void QtMainWindowControl::moveEvent(QMoveEvent* event)
 {
   GuiTk::ControlEvent::Pointer controlEvent(new GuiTk::ControlEvent(this, event->pos().x(), event->pos().y()));
   controller->controlEvents.movedEvent(controlEvent);
 }
 
 void QtMainWindowControl::resizeEvent(QResizeEvent* event)
 {
   GuiTk::ControlEvent::Pointer controlEvent(new GuiTk::ControlEvent(this, 0, 0, event->size().width(), event->size().height()));
   controller->controlEvents.resizedEvent(controlEvent);
 }
 
 void QtMainWindowControl::inFocusEvent(QFocusEvent* /*event*/)
 {
   GuiTk::ControlEvent::Pointer controlEvent(new GuiTk::ControlEvent(this));
   controller->controlEvents.activatedEvent(controlEvent);
 }
 
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.cpp b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.cpp
index 17a936a311..8b914c99a6 100644
--- a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.cpp
+++ b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.cpp
@@ -1,1778 +1,1790 @@
 /*===================================================================
 
 BlueBerry Platform
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "berryWorkbenchWindow.h"
 
 #include "berryIWorkbenchPage.h"
 #include "berryIPerspectiveDescriptor.h"
 #include "berryUIException.h"
 #include "berryConstants.h"
 
 #include "intro/berryIntroConstants.h"
 #include "berryWorkbenchPlugin.h"
 #include "berryWorkbenchPage.h"
 #include "berryWorkbench.h"
 #include "berryWorkbenchConstants.h"
 #include "berryPartSite.h"
 #include "berryIServiceLocatorCreator.h"
 
 #include "tweaklets/berryGuiWidgetsTweaklet.h"
 #include "tweaklets/berryWorkbenchTweaklet.h"
 
 #include "services/berryIServiceFactory.h"
 
 #include "berryPlatformUI.h"
 
 #include "berryDebugUtil.h"
 
 namespace berry
 {
 
 const int WorkbenchWindow::FILL_ALL_ACTION_BARS =
     ActionBarAdvisor::FILL_MENU_BAR | ActionBarAdvisor::FILL_COOL_BAR
         | ActionBarAdvisor::FILL_STATUS_LINE;
 
 WorkbenchWindow::WorkbenchWindow(int number) :
   Window(Shell::Pointer(0)), pageComposite(0), windowAdvisor(0),
       actionBarAdvisor(0), number(number), largeUpdates(0), closing(false),
       shellActivated(false), updateDisabled(true), emptyWindowContentsCreated(
           false), emptyWindowContents(0), asMaximizedState(false), partService(
           this), serviceLocatorOwner(
           new ServiceLocatorOwner(this))
 {
   this->Register(); // increase the reference count to avoid deleting
   // this object when temporary smart pointers
   // go out of scope
 
   // Make sure there is a workbench. This call will throw
   // an exception if workbench not created yet.
   IWorkbench* workbench = PlatformUI::GetWorkbench();
   IServiceLocatorCreator::Pointer slc =
       workbench->GetService(IServiceLocatorCreator::GetManifestName()).Cast<
           IServiceLocatorCreator> ();
 
   IServiceLocator::Pointer locator(workbench);
   this->serviceLocator = slc->CreateServiceLocator(IServiceLocator::WeakPtr(
       locator), IServiceFactory::ConstPointer(0), IDisposable::WeakPtr(
       serviceLocatorOwner)).Cast<ServiceLocator> ();
 
   //  initializeDefaultServices();
 
   // Add contribution managers that are exposed to other plugins.
   //addMenuBar();
   //addCoolBar(SWT.NONE);  // style is unused
   //addStatusLine();
 
   this->FireWindowOpening();
 
   // Fill the action bars
   this->FillActionBars(FILL_ALL_ACTION_BARS);
 
   this->UnRegister(false); // decrease reference count and avoid deleting
   // the window
 }
 
 WorkbenchWindow::~WorkbenchWindow()
 {
   //BERRY_INFO << "WorkbenchWindow::~WorkbenchWindow()";
 }
 
 Object::Pointer WorkbenchWindow::GetService(const std::string& key)
 {
   return serviceLocator->GetService(key);
 }
 
 bool WorkbenchWindow::HasService(const std::string& key) const
 {
   return serviceLocator->HasService(key);
 }
 
 Shell::Pointer WorkbenchWindow::GetShell()
 {
   return Window::GetShell();
 }
 
 bool WorkbenchWindow::ClosePage(IWorkbenchPage::Pointer in, bool save)
 {
   // Validate the input.
   if (!pageList.Contains(in))
   {
     return false;
   }
   WorkbenchPage::Pointer oldPage = in.Cast<WorkbenchPage> ();
 
   // Save old perspective.
   if (save && oldPage->IsSaveNeeded())
   {
     if (!oldPage->SaveAllEditors(true))
     {
       return false;
     }
   }
 
   // If old page is activate deactivate.
   bool oldIsActive = (oldPage == this->GetActivePage());
   if (oldIsActive)
   {
     this->SetActivePage(IWorkbenchPage::Pointer(0));
   }
 
   // Close old page.
   pageList.Remove(oldPage);
   partService.PageClosed(oldPage);
   //this->FirePageClosed(oldPage);
   //oldPage->Dispose();
 
   // Activate new page.
   if (oldIsActive)
   {
     IWorkbenchPage::Pointer newPage = pageList.GetNextActive();
     if (newPage != 0)
     {
       this->SetActivePage(newPage);
     }
   }
   if (!closing && pageList.IsEmpty())
   {
     this->ShowEmptyWindowContents();
   }
   return true;
 }
 
 void WorkbenchWindow::AddPerspectiveListener(IPerspectiveListener::Pointer l)
 {
   perspectiveEvents.AddListener(l);
 }
 
 void WorkbenchWindow::RemovePerspectiveListener(IPerspectiveListener::Pointer l)
 {
   perspectiveEvents.RemoveListener(l);
 }
 
 IPerspectiveListener::Events& WorkbenchWindow::GetPerspectiveEvents()
 {
   return perspectiveEvents;
 }
 
 void WorkbenchWindow::FireWindowOpening()
 {
   // let the application do further configuration
   this->GetWindowAdvisor()->PreWindowOpen();
 }
 
 void WorkbenchWindow::FireWindowRestored()
 {
   //StartupThreading.runWithWorkbenchExceptions(new StartupRunnable() {
   //  public void runWithException() throws Throwable {
   this->GetWindowAdvisor()->PostWindowRestore();
   //  }
   //});
 }
 
 void WorkbenchWindow::FireWindowCreated()
 {
   this->GetWindowAdvisor()->PostWindowCreate();
 }
 
 void WorkbenchWindow::FireWindowOpened()
 {
   this->GetWorkbenchImpl()->FireWindowOpened(IWorkbenchWindow::Pointer(this));
   this->GetWindowAdvisor()->PostWindowOpen();
 }
 
 bool WorkbenchWindow::FireWindowShellClosing()
 {
   return this->GetWindowAdvisor()->PreWindowShellClose();
 }
 
 void WorkbenchWindow::FireWindowClosed()
 {
   // let the application do further deconfiguration
   this->GetWindowAdvisor()->PostWindowClose();
   this->GetWorkbenchImpl()->FireWindowClosed(IWorkbenchWindow::Pointer(this));
 }
 
 ///**
 // * Fires page activated
 // */
 //void WorkbenchWindow::FirePageActivated(IWorkbenchPage::Pointer page) {
 ////  String label = null; // debugging only
 ////  if (UIStats.isDebugging(UIStats.NOTIFY_PAGE_LISTENERS)) {
 ////    label = "activated " + page.getLabel(); //$NON-NLS-1$
 ////  }
 ////  try {
 ////    UIStats.start(UIStats.NOTIFY_PAGE_LISTENERS, label);
 ////    UIListenerLogging.logPageEvent(this, page,
 ////        UIListenerLogging.WPE_PAGE_ACTIVATED);
 //    pageEvents.FirePageActivated(page);
 //    partService.pageActivated(page);
 ////  } finally {
 ////    UIStats.end(UIStats.NOTIFY_PAGE_LISTENERS, page.getLabel(), label);
 ////  }
 //}
 //
 ///**
 // * Fires page closed
 // */
 //void WorkbenchWindow::FirePageClosed(IWorkbenchPage::Pointer page) {
 //  String label = null; // debugging only
 //  if (UIStats.isDebugging(UIStats.NOTIFY_PAGE_LISTENERS)) {
 //    label = "closed " + page.getLabel(); //$NON-NLS-1$
 //  }
 //  try {
 //    UIStats.start(UIStats.NOTIFY_PAGE_LISTENERS, label);
 //    UIListenerLogging.logPageEvent(this, page,
 //        UIListenerLogging.WPE_PAGE_CLOSED);
 //    pageListeners.firePageClosed(page);
 //    partService.pageClosed(page);
 //  } finally {
 //    UIStats.end(UIStats.NOTIFY_PAGE_LISTENERS, page.getLabel(), label);
 //  }
 //
 //}
 //
 ///**
 // * Fires page opened
 // */
 //void WorkbenchWindow::FirePageOpened(IWorkbenchPage::Pointer page) {
 //  String label = null; // debugging only
 //  if (UIStats.isDebugging(UIStats.NOTIFY_PAGE_LISTENERS)) {
 //    label = "opened " + page.getLabel(); //$NON-NLS-1$
 //  }
 //  try {
 //    UIStats.start(UIStats.NOTIFY_PAGE_LISTENERS, label);
 //    UIListenerLogging.logPageEvent(this, page,
 //        UIListenerLogging.WPE_PAGE_OPENED);
 //    pageListeners.firePageOpened(page);
 //    partService.pageOpened(page);
 //  } finally {
 //    UIStats.end(UIStats.NOTIFY_PAGE_LISTENERS, page.getLabel(), label);
 //  }
 //}
 
 void WorkbenchWindow::FirePerspectiveActivated(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer perspective)
 {
   //  UIListenerLogging.logPerspectiveEvent(this, page, perspective,
   //      UIListenerLogging.PLE_PERSP_ACTIVATED);
   perspectiveEvents.perspectiveActivated(page, perspective);
 }
 
 void WorkbenchWindow::FirePerspectivePreDeactivate(
     IWorkbenchPage::Pointer page, IPerspectiveDescriptor::Pointer perspective)
 {
   //  UIListenerLogging.logPerspectiveEvent(this, page, perspective,
   //      UIListenerLogging.PLE_PERSP_PRE_DEACTIVATE);
   perspectiveEvents.perspectivePreDeactivate(page, perspective);
 }
 
 void WorkbenchWindow::FirePerspectiveDeactivated(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer perspective)
 {
   //  UIListenerLogging.logPerspectiveEvent(this, page, perspective,
   //      UIListenerLogging.PLE_PERSP_DEACTIVATED);
   perspectiveEvents.perspectiveDeactivated(page, perspective);
 }
 
 void WorkbenchWindow::FirePerspectiveChanged(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer perspective, const std::string& changeId)
 {
   // Some callers call this even when there is no active perspective.
   // Just ignore this case.
   if (perspective != 0)
   {
     //    UIListenerLogging.logPerspectiveChangedEvent(this, page,
     //        perspective, null, changeId);
     perspectiveEvents.perspectiveChanged(page, perspective, changeId);
   }
 }
 
 void WorkbenchWindow::FirePerspectiveChanged(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer perspective,
     IWorkbenchPartReference::Pointer partRef, const std::string& changeId)
 {
   // Some callers call this even when there is no active perspective.
   // Just ignore this case.
   if (perspective != 0)
   {
     //    UIListenerLogging.logPerspectiveChangedEvent(this, page,
     //        perspective, partRef, changeId);
     perspectiveEvents.perspectivePartChanged(page, perspective, partRef,
         changeId);
   }
 }
 
 void WorkbenchWindow::FirePerspectiveClosed(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer perspective)
 {
   //  UIListenerLogging.logPerspectiveEvent(this, page, perspective,
   //      UIListenerLogging.PLE_PERSP_CLOSED);
   perspectiveEvents.perspectiveClosed(page, perspective);
 }
 
 void WorkbenchWindow::FirePerspectiveOpened(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer perspective)
 {
   //  UIListenerLogging.logPerspectiveEvent(this, page, perspective,
   //      UIListenerLogging.PLE_PERSP_OPENED);
   perspectiveEvents.perspectiveOpened(page, perspective);
 }
 
 void WorkbenchWindow::FirePerspectiveSavedAs(IWorkbenchPage::Pointer page,
     IPerspectiveDescriptor::Pointer oldPerspective,
     IPerspectiveDescriptor::Pointer newPerspective)
 {
   //  UIListenerLogging.logPerspectiveSavedAs(this, page, oldPerspective,
   //      newPerspective);
   perspectiveEvents.perspectiveSavedAs(page, oldPerspective, newPerspective);
 }
 
 void WorkbenchWindow::FillActionBars(int flags)
 {
   //  Workbench workbench = getWorkbenchImpl();
   //  workbench.largeUpdateStart();
   //try {
   this->GetActionBarAdvisor()->FillActionBars(flags);
 
   //    final IMenuService menuService = (IMenuService) serviceLocator
   //        .getService(IMenuService.class);
   //    menuService.populateContributionManager(
   //        (ContributionManager) getActionBars().getMenuManager(),
   //        MenuUtil.MAIN_MENU);
   //    ICoolBarManager coolbar = getActionBars().getCoolBarManager();
   //    if (coolbar != null) {
   //      menuService.populateContributionManager(
   //          (ContributionManager) coolbar,
   //          MenuUtil.MAIN_TOOLBAR);
   //    }
   //
   //  } finally {
   //    workbench.largeUpdateEnd();
   //  }
 }
 
 Point WorkbenchWindow::GetInitialSize()
 {
   return this->GetWindowConfigurer()->GetInitialSize();
 }
 
 bool WorkbenchWindow::Close()
 {
   //BERRY_INFO << "WorkbenchWindow::Close()";
 
   if (controlResizeListener)
   {
     Tweaklets::Get(GuiWidgetsTweaklet::KEY)->RemoveControlListener(GetShell()->GetControl(), controlResizeListener);
   }
 
   bool ret = false;
   //BusyIndicator.showWhile(null, new Runnable() {
   //      public void run() {
   ret = this->BusyClose();
   //      }
   //    });
 
   if (!ret && controlResizeListener)
   {
     Tweaklets::Get(GuiWidgetsTweaklet::KEY)->AddControlListener(GetShell()->GetControl(), controlResizeListener);
   }
 
   return ret;
 }
 
 bool WorkbenchWindow::BusyClose()
 {
   // Whether the window was actually closed or not
   bool windowClosed = false;
 
   // Setup internal flags to indicate window is in
   // progress of closing and no update should be done.
   closing = true;
   updateDisabled = true;
 
   try
   {
     // Only do the check if it is OK to close if we are not closing
     // via the workbench as the workbench will check this itself.
     Workbench* workbench = this->GetWorkbenchImpl();
     std::size_t count = workbench->GetWorkbenchWindowCount();
 
     // also check for starting - if the first window dies on startup
     // then we'll need to open a default window.
     if (!workbench->IsStarting() && !workbench->IsClosing() && count <= 1
         && workbench->GetWorkbenchConfigurer() ->GetExitOnLastWindowClose())
     {
       windowClosed = workbench->Close();
     }
     else
     {
       if (this->OkToClose())
       {
         windowClosed = this->HardClose();
       }
     }
   } catch (std::exception& exc)
   {
     if (!windowClosed)
     {
       // Reset the internal flags if window was not closed.
       closing = false;
       updateDisabled = false;
     }
 
     throw exc;
   }
 
   //    if (windowClosed && tracker != null) {
   //      tracker.close();
   //    }
 
   return windowClosed;
 }
 
 void WorkbenchWindow::MakeVisible()
 {
   Shell::Pointer shell = GetShell();
   if (shell)
   {
     // see bug 96700 and bug 4414 for a discussion on the use of open()
     // here
     shell->Open();
   }
 }
 
 bool WorkbenchWindow::OkToClose()
 {
   // Save all of the editors.
   if (!this->GetWorkbenchImpl()->IsClosing())
   {
     if (!this->SaveAllPages(true))
     {
       return false;
     }
   }
   return true;
 }
 
 bool WorkbenchWindow::SaveAllPages(bool bConfirm)
 {
   bool bRet = true;
   PageList::iterator itr = pageList.Begin();
   while (bRet && itr != pageList.End())
   {
     bRet = (*itr)->SaveAllEditors(bConfirm);
     ++itr;
   }
   return bRet;
 }
 
 bool WorkbenchWindow::HardClose()
 {
   std::exception exc;
   bool exceptionOccured = false;
 
   try
   {
     // Clear the action sets, fix for bug 27416.
     //getActionPresentation().clearActionSets();
 
     // Remove the handler submissions. Bug 64024.
     /*
      final IWorkbench workbench = getWorkbench();
      final IHandlerService handlerService = (IHandlerService) workbench.getService(IHandlerService.class);
      handlerService.deactivateHandlers(handlerActivations);
      final Iterator activationItr = handlerActivations.iterator();
      while (activationItr.hasNext()) {
      final IHandlerActivation activation = (IHandlerActivation) activationItr
      .next();
      activation.getHandler().dispose();
      }
      handlerActivations.clear();
      globalActionHandlersByCommandId.clear();
      */
 
     // Remove the enabled submissions. Bug 64024.
     /*
      final IContextService contextService = (IContextService) workbench.getService(IContextService.class);
      contextService.unregisterShell(getShell());
      */
 
     this->CloseAllPages();
 
     this->FireWindowClosed();
 
     // time to wipe out our populate
     /*
      IMenuService menuService = (IMenuService) workbench
      .getService(IMenuService.class);
      menuService
      .releaseContributions(((ContributionManager) getActionBars()
      .getMenuManager()));
      ICoolBarManager coolbar = getActionBars().getCoolBarManager();
      if (coolbar != null) {
      menuService
      .releaseContributions(((ContributionManager) coolbar));
      }
      */
 
     //getActionBarAdvisor().dispose();
     //getWindowAdvisor().dispose();
     //detachedWindowShells.dispose();
     delete windowAdvisor;
     windowAdvisor = 0;
 
     // Null out the progress region. Bug 64024.
     //progressRegion = null;
 
     // Remove drop targets
     /*
      DragUtil.removeDragTarget(null, trimDropTarget);
      DragUtil.removeDragTarget(getShell(), trimDropTarget);
      trimDropTarget = null;
 
      if (trimMgr2 != null) {
      trimMgr2.dispose();
      trimMgr2 = null;
      }
 
      if (trimContributionMgr != null) {
      trimContributionMgr.dispose();
      trimContributionMgr = null;
      }
      */
   } catch (std::exception& e)
   {
     exc = e;
     exceptionOccured = true;
   }
 
   bool result = Window::Close();
   // Bring down all of the services ... after the window goes away
   serviceLocator->Dispose();
   //menuRestrictions.clear();
 
   if (exceptionOccured)
     throw exc;
 
   return result;
 }
 
 void WorkbenchWindow::CloseAllPages()
 {
   // Deactivate active page.
   this->SetActivePage(IWorkbenchPage::Pointer(0));
 
   // Clone and deref all so that calls to getPages() returns
   // empty list (if called by pageClosed event handlers)
   PageList oldList = pageList;
   pageList.Clear();
 
   // Close all.
   for (PageList::iterator itr = oldList.Begin(); itr != oldList.End(); ++itr)
   {
     partService.PageClosed(*itr);
     //(*itr)->FirePageClosed(page);
     //page.dispose();
   }
   if (!closing)
   {
     this->ShowEmptyWindowContents();
   }
 }
 
 IWorkbenchPage::Pointer WorkbenchWindow::GetActivePage()
 {
   return pageList.GetActive();
 }
 
 IWorkbench* WorkbenchWindow::GetWorkbench()
 {
   return PlatformUI::GetWorkbench();
 }
 
 IPartService* WorkbenchWindow::GetPartService()
 {
   return &partService;
 }
 
 ISelectionService* WorkbenchWindow::GetSelectionService()
 {
   return partService.GetSelectionService();
 }
 
 bool WorkbenchWindow::IsClosing()
 {
   return closing || this->GetWorkbenchImpl()->IsClosing();
 }
 
 int WorkbenchWindow::Open()
 {
   if (pageList.IsEmpty())
   {
     this->ShowEmptyWindowContents();
   }
 
   this->FireWindowCreated();
   this->GetWindowAdvisor()->OpenIntro();
 
   int result = Window::Open();
 
   // It's time for a layout ... to insure that if TrimLayout
   // is in play, it updates all of the trim it's responsible
   // for. We have to do this before updating in order to get
   // the PerspectiveBar management correct...see defect 137334
   //getShell().layout();
 
   this->FireWindowOpened();
   //  if (perspectiveSwitcher != null) {
   //    perspectiveSwitcher.updatePerspectiveBar();
   //    perspectiveSwitcher.updateBarParent();
   //  }
 
   return result;
 }
 
 void* WorkbenchWindow::GetPageComposite()
 {
   return pageComposite;
 }
 
 void* WorkbenchWindow::CreateContents(Shell::Pointer parent)
 {
   // we know from Window.create that the parent is a Shell.
   this->GetWindowAdvisor()->CreateWindowContents(parent);
   // the page composite must be set by createWindowContents
   poco_assert(pageComposite != 0)
 ; // "createWindowContents must call configurer.createPageComposite"); //$NON-NLS-1$
   return pageComposite;
 }
 
 void WorkbenchWindow::CreateDefaultContents(Shell::Pointer shell)
 {
   //pageComposite = Tweaklets::Get(WorkbenchTweaklet::KEY)->CreateDefaultWindowContents(shell);
   this->CreatePageComposite(shell->GetControl());
 }
 
 bool WorkbenchWindow::UnableToRestorePage(IMemento::Pointer pageMem)
 {
   std::string pageName;
   pageMem->GetString(WorkbenchConstants::TAG_LABEL, pageName);
 
   //  return new Status(IStatus.ERROR, PlatformUI.PLUGIN_ID, 0, NLS.bind(
   //      WorkbenchMessages.WorkbenchWindow_unableToRestorePerspective,
   //      pageName), null);
   WorkbenchPlugin::Log("Unable to restore perspective: " + pageName);
   return false;
 }
 
 bool WorkbenchWindow::RestoreState(IMemento::Pointer memento,
     IPerspectiveDescriptor::Pointer activeDescriptor)
 {
   //TODO WorkbenchWindow restore state
   poco_assert(GetShell());
 
   //  final MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK,
   //      WorkbenchMessages.WorkbenchWindow_problemsRestoringWindow, null);
   bool result = true;
 
   // Restore the window advisor state.
   IMemento::Pointer windowAdvisorState = memento
   ->GetChild(WorkbenchConstants::TAG_WORKBENCH_WINDOW_ADVISOR);
   if (windowAdvisorState)
   {
     //result.add(getWindowAdvisor().restoreState(windowAdvisorState));
     result &= GetWindowAdvisor()->RestoreState(windowAdvisorState);
   }
 
   // Restore actionbar advisor state.
   IMemento::Pointer actionBarAdvisorState = memento
   ->GetChild(WorkbenchConstants::TAG_ACTION_BAR_ADVISOR);
   if (actionBarAdvisorState)
   {
     //    result.add(getActionBarAdvisor()
     //        .restoreState(actionBarAdvisorState));
     result &= GetActionBarAdvisor()
     ->RestoreState(actionBarAdvisorState);
   }
 
   // Read window's bounds and state.
   Rectangle displayBounds;
   //  StartupThreading.runWithoutExceptions(new StartupRunnable() {
   //
   //    public void runWithException() {
   displayBounds = Tweaklets::Get(GuiWidgetsTweaklet::KEY)->GetScreenSize();
   //displayBounds = GetShell()->GetDisplay()->GetBounds();
 
   //    }});
   Rectangle shellBounds;
 
   //  final IMemento fastViewMem = memento
   //      .getChild(IWorkbenchConstants.TAG_FAST_VIEW_DATA);
   //  if (fastViewMem != null) {
   //    if (fastViewBar != null) {
   //      StartupThreading.runWithoutExceptions(new StartupRunnable() {
   //
   //        public void runWithException() {
   //          fastViewBar.restoreState(fastViewMem);
   //        }});
   //
   //    }
   //  }
 
   memento->GetInteger(WorkbenchConstants::TAG_X, shellBounds.x);
   memento->GetInteger(WorkbenchConstants::TAG_Y, shellBounds.y);
   memento->GetInteger(WorkbenchConstants::TAG_WIDTH, shellBounds.width);
   memento->GetInteger(WorkbenchConstants::TAG_HEIGHT, shellBounds.height);
   if (!shellBounds.IsEmpty())
   {
     //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
     //
     //      public void runWithException() {
     if (!shellBounds.Intersects(displayBounds))
     {
       Rectangle clientArea(Tweaklets::Get(GuiWidgetsTweaklet::KEY)->GetAvailableScreenSize());
       shellBounds.x = clientArea.x;
       shellBounds.y = clientArea.y;
     }
     GetShell()->SetBounds(shellBounds);
     //      }});
   }
   std::string maximized; memento->GetString(WorkbenchConstants::TAG_MAXIMIZED, maximized);
   if (maximized == "true")
   {
     //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
     //
     //      public void runWithException() {
     GetShell()->SetMaximized(true);
     //      }});
 
   }
   std::string minimized; memento->GetString(WorkbenchConstants::TAG_MINIMIZED, minimized);
   if (minimized == "true")
   {
     // getShell().setMinimized(true);
   }
 
   //  // restore the width of the perspective bar
   //  if (perspectiveSwitcher != null) {
   //    perspectiveSwitcher.restoreState(memento);
   //  }
 
   //  // Restore the cool bar order by creating all the tool bar contribution
   //  // items
   //  // This needs to be done before pages are created to ensure proper
   //  // canonical creation
   //  // of cool items
   //  final ICoolBarManager2 coolBarMgr = (ICoolBarManager2) getCoolBarManager2();
   //      if (coolBarMgr != null) {
   //    IMemento coolBarMem = memento
   //        .getChild(IWorkbenchConstants.TAG_COOLBAR_LAYOUT);
   //    if (coolBarMem != null) {
   //      // Check if the layout is locked
   //      final Integer lockedInt = coolBarMem
   //          .getInteger(IWorkbenchConstants.TAG_LOCKED);
   //      StartupThreading.runWithoutExceptions(new StartupRunnable(){
   //
   //        public void runWithException() {
   //          if ((lockedInt != null) && (lockedInt.intValue() == 1)) {
   //            coolBarMgr.setLockLayout(true);
   //          } else {
   //            coolBarMgr.setLockLayout(false);
   //          }
   //        }});
   //
   //      // The new layout of the cool bar manager
   //      ArrayList coolBarLayout = new ArrayList();
   //      // Traverse through all the cool item in the memento
   //      IMemento contributionMems[] = coolBarMem
   //          .getChildren(IWorkbenchConstants.TAG_COOLITEM);
   //      for (int i = 0; i < contributionMems.length; i++) {
   //        IMemento contributionMem = contributionMems[i];
   //        String type = contributionMem
   //            .getString(IWorkbenchConstants.TAG_ITEM_TYPE);
   //        if (type == null) {
   //          // Do not recognize that type
   //          continue;
   //        }
   //        String id = contributionMem
   //            .getString(IWorkbenchConstants.TAG_ID);
   //
   //        // Prevent duplicate items from being read back in.
   //        IContributionItem existingItem = coolBarMgr.find(id);
   //        if ((id != null) && (existingItem != null)) {
   //          if (Policy.DEBUG_TOOLBAR_DISPOSAL) {
   //            System.out
   //                .println("Not loading duplicate cool bar item: " + id); //$NON-NLS-1$
   //          }
   //          coolBarLayout.add(existingItem);
   //          continue;
   //        }
   //        IContributionItem newItem = null;
   //        if (type.equals(IWorkbenchConstants.TAG_TYPE_SEPARATOR)) {
   //          if (id != null) {
   //            newItem = new Separator(id);
   //          } else {
   //            newItem = new Separator();
   //          }
   //        } else if (id != null) {
   //          if (type
   //              .equals(IWorkbenchConstants.TAG_TYPE_GROUPMARKER)) {
   //            newItem = new GroupMarker(id);
   //
   //          } else if (type
   //              .equals(IWorkbenchConstants.TAG_TYPE_TOOLBARCONTRIBUTION)
   //              || type
   //                  .equals(IWorkbenchConstants.TAG_TYPE_PLACEHOLDER)) {
   //
   //            // Get Width and height
   //            Integer width = contributionMem
   //                .getInteger(IWorkbenchConstants.TAG_ITEM_X);
   //            Integer height = contributionMem
   //                .getInteger(IWorkbenchConstants.TAG_ITEM_Y);
   //            // Look for the object in the current cool bar
   //            // manager
   //            IContributionItem oldItem = coolBarMgr.find(id);
   //            // If a tool bar contribution item already exists
   //            // for this id then use the old object
   //            if (oldItem != null) {
   //              newItem = oldItem;
   //            } else {
   //              IActionBarPresentationFactory actionBarPresentation = getActionBarPresentationFactory();
   //              newItem = actionBarPresentation.createToolBarContributionItem(
   //                  actionBarPresentation.createToolBarManager(), id);
   //              if (type
   //                  .equals(IWorkbenchConstants.TAG_TYPE_PLACEHOLDER)) {
   //                IToolBarContributionItem newToolBarItem = (IToolBarContributionItem) newItem;
   //                if (height != null) {
   //                  newToolBarItem.setCurrentHeight(height
   //                      .intValue());
   //                }
   //                if (width != null) {
   //                  newToolBarItem.setCurrentWidth(width
   //                      .intValue());
   //                }
   //                newItem = new PlaceholderContributionItem(
   //                    newToolBarItem);
   //              }
   //              // make it invisible by default
   //              newItem.setVisible(false);
   //              // Need to add the item to the cool bar manager
   //              // so that its canonical order can be preserved
   //              IContributionItem refItem = findAlphabeticalOrder(
   //                  IWorkbenchActionConstants.MB_ADDITIONS,
   //                  id, coolBarMgr);
   //              if (refItem != null) {
   //                coolBarMgr.insertAfter(refItem.getId(),
   //                    newItem);
   //              } else {
   //                coolBarMgr.add(newItem);
   //              }
   //            }
   //            // Set the current height and width
   //            if ((width != null)
   //                && (newItem instanceof IToolBarContributionItem)) {
   //              ((IToolBarContributionItem) newItem)
   //                  .setCurrentWidth(width.intValue());
   //            }
   //            if ((height != null)
   //                && (newItem instanceof IToolBarContributionItem)) {
   //              ((IToolBarContributionItem) newItem)
   //                  .setCurrentHeight(height.intValue());
   //            }
   //          }
   //        }
   //        // Add new item into cool bar manager
   //        if (newItem != null) {
   //          coolBarLayout.add(newItem);
   //          newItem.setParent(coolBarMgr);
   //          coolBarMgr.markDirty();
   //        }
   //      }
   //
   //      // We need to check if we have everything we need in the layout.
   //      boolean newlyAddedItems = false;
   //      IContributionItem[] existingItems = coolBarMgr.getItems();
   //      for (int i = 0; i < existingItems.length && !newlyAddedItems; i++) {
   //        IContributionItem existingItem = existingItems[i];
   //
   //        /*
   //         * This line shouldn't be necessary, but is here for
   //         * robustness.
   //         */
   //        if (existingItem == null) {
   //          continue;
   //        }
   //
   //        boolean found = false;
   //        Iterator layoutItemItr = coolBarLayout.iterator();
   //        while (layoutItemItr.hasNext()) {
   //          IContributionItem layoutItem = (IContributionItem) layoutItemItr
   //              .next();
   //          if ((layoutItem != null)
   //              && (layoutItem.equals(existingItem))) {
   //            found = true;
   //            break;
   //          }
   //        }
   //
   //        if (!found) {
   //          if (existingItem != null) {
   //            newlyAddedItems = true;
   //          }
   //        }
   //      }
   //
   //      // Set the cool bar layout to the given layout.
   //      if (!newlyAddedItems) {
   //        final IContributionItem[] itemsToSet = new IContributionItem[coolBarLayout
   //            .size()];
   //        coolBarLayout.toArray(itemsToSet);
   //        StartupThreading
   //            .runWithoutExceptions(new StartupRunnable() {
   //
   //              public void runWithException() {
   //                coolBarMgr.setItems(itemsToSet);
   //              }
   //            });
   //      }
   //
   //    } else {
   //      // For older workbenchs
   //      coolBarMem = memento
   //          .getChild(IWorkbenchConstants.TAG_TOOLBAR_LAYOUT);
   //      if (coolBarMem != null) {
   //        // Restore an older layout
   //        restoreOldCoolBar(coolBarMem);
   //      }
   //    }
   //  }
 
   // Recreate each page in the window.
   IWorkbenchPage::Pointer newActivePage;
   std::vector<IMemento::Pointer> pageArray = memento
   ->GetChildren(WorkbenchConstants::TAG_PAGE);
   for (std::size_t i = 0; i < pageArray.size(); i++)
   {
     IMemento::Pointer pageMem = pageArray[i];
     std::string strFocus; pageMem->GetString(WorkbenchConstants::TAG_FOCUS, strFocus);
     if (strFocus.empty())
     {
       continue;
     }
 
     // Get the input factory.
     IAdaptable* input = 0;
     IMemento::Pointer inputMem = pageMem->GetChild(WorkbenchConstants::TAG_INPUT);
     if (inputMem)
     {
       std::string factoryID; inputMem->GetString(WorkbenchConstants::TAG_FACTORY_ID, factoryID);
       if (factoryID.empty())
       {
         WorkbenchPlugin
         ::Log("Unable to restore page - no input factory ID.");
         //result.add(unableToRestorePage(pageMem));
         result &= UnableToRestorePage(pageMem);
         continue;
       }
       //      try {
       //        UIStats.start(UIStats.RESTORE_WORKBENCH,
       //            "WorkbenchPageFactory"); //$NON-NLS-1$
       //        StartupThreading
       //            .runWithoutExceptions(new StartupRunnable() {
       //
       //              public void runWithException() throws Throwable {
       //                IElementFactory factory = PlatformUI
       //                    .getWorkbench().getElementFactory(
       //                        factoryID);
       //                if (factory == null) {
       //                  WorkbenchPlugin
       //                      .log("Unable to restore page - cannot instantiate input factory: " + factoryID); //$NON-NLS-1$
       //                  result
       //                      .add(unableToRestorePage(pageMem));
       //                  return;
       //                }
       //
       //                // Get the input element.
       //                input[0] = factory.createElement(inputMem);
       //              }
       //            });
       //
       //        if (input[0] == null) {
       //          WorkbenchPlugin
       //              .log("Unable to restore page - cannot instantiate input element: " + factoryID); //$NON-NLS-1$
       //          result.add(unableToRestorePage(pageMem));
       //          continue;
       //        }
       //      } finally {
       //        UIStats.end(UIStats.RESTORE_WORKBENCH, factoryID,
       //            "WorkbenchPageFactory"); //$NON-NLS-1$
       //      }
     }
     // Open the perspective.
     IAdaptable* finalInput = input;
     WorkbenchPage::Pointer newPage;
     try
     {
       //      StartupThreading.runWithWorkbenchExceptions(new StartupRunnable(){
       //
       //        public void runWithException() throws WorkbenchException {
       newPage = new WorkbenchPage(this, finalInput);
       //        }});
 
       //result.add(newPage[0].restoreState(pageMem, activeDescriptor));
       result &= newPage->RestoreState(pageMem, activeDescriptor);
       pageList.Add(newPage);
       //      StartupThreading.runWithoutExceptions(new StartupRunnable() {
       //
       //        public void runWithException() throws Throwable {
       partService.PageOpened(newPage);
       //          firePageOpened(newPage[0]);
       //        }});
 
     }
     catch (const WorkbenchException& e)
     {
       WorkbenchPlugin::Log(
           "Unable to restore perspective - constructor failed.", e); //$NON-NLS-1$
       //result.add(e.getStatus());
       continue;
     }
 
     if (!strFocus.empty())
     {
       newActivePage = newPage;
     }
   }
 
   // If there are no pages create a default.
   if (pageList.IsEmpty())
   {
     try
     {
       const std::string defPerspID = this->GetWorkbenchImpl()->GetPerspectiveRegistry()
       ->GetDefaultPerspective();
       if (!defPerspID.empty())
       {
         WorkbenchPage::Pointer newPage;
         //StartupThreading.runWithWorkbenchExceptions(new StartupRunnable() {
 
         //  public void runWithException() throws Throwable {
         newPage = new WorkbenchPage(this, defPerspID,
             this->GetDefaultPageInput());
         //  }});
 
         pageList.Add(newPage);
         //StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
         //  public void runWithException() throws Throwable {
         //    firePageOpened(newPage[0]);
         partService.PageOpened(newPage);
         //  }});
       }
     }
     catch (WorkbenchException& e)
     {
       WorkbenchPlugin
       ::Log(
           "Unable to create default perspective - constructor failed.", e);
       result = false;
       //TODO set product name
       //      String productName = WorkbenchPlugin.getDefault()
       //          .getProductName();
       //      if (productName == null) {
       //        productName = ""; //$NON-NLS-1$
       //      }
       //      getShell().setText(productName);
     }
   }
 
   // Set active page.
   if (newActivePage.IsNull())
   {
     newActivePage = pageList.GetNextActive().Cast<IWorkbenchPage>();
   }
 
   //StartupThreading.runWithoutExceptions(new StartupRunnable() {
 
   //  public void runWithException() throws Throwable {
   this->SetActivePage(newActivePage);
   //  }});
 
 
   IMemento::Pointer introMem = memento->GetChild(WorkbenchConstants::TAG_INTRO);
   if (introMem) {
 //    StartupThreading.runWithoutExceptions(new StartupRunnable() {
 //
 //      public void runWithException() throws Throwable {
     bool isStandby = false;
     introMem->GetBoolean(WorkbenchConstants::TAG_STANDBY, isStandby);
         GetWorkbench()->GetIntroManager()->ShowIntro(
                 IWorkbenchWindow::Pointer(this), isStandby);
 //      }
 //    });
   }
   //
   //  // Only restore the trim state if we're using the default layout
   //  if (defaultLayout != null) {
   //    // Restore the trim state. We pass in the 'root'
   //    // memento since we have to check for pre-3.2
   //    // state.
   //    result.add(restoreTrimState(memento));
   //  }
 
   return result;
 }
 
 IAdaptable* WorkbenchWindow::GetDefaultPageInput()
 {
   return this->GetWorkbenchImpl()->GetDefaultPageInput();
 }
 
 IWorkbenchPage::Pointer WorkbenchWindow::OpenPage(
     const std::string& perspId, IAdaptable* input)
 {
   // Run op in busy cursor.
   IWorkbenchPage::Pointer result;
   //BusyIndicator.showWhile(null, new Runnable() {
   //  public void run() {
   result = this->BusyOpenPage(perspId, input);
 
   // }
 
   return result;
 }
 
 SmartPointer<IWorkbenchPage> WorkbenchWindow::OpenPage(IAdaptable* input)
 {
   std::string perspId = this->GetWorkbenchImpl()->GetDefaultPerspectiveId();
   return this->OpenPage(perspId, input);
 }
 
 IWorkbenchPage::Pointer WorkbenchWindow::BusyOpenPage(
     const std::string& perspID, IAdaptable* input)
 {
   IWorkbenchPage::Pointer newPage;
 
   if (pageList.IsEmpty())
   {
     newPage = new WorkbenchPage(this, perspID, input);
     pageList.Add(newPage);
     //this->FirePageOpened(newPage);
     partService.PageOpened(newPage);
     this->SetActivePage(newPage);
   }
   else
   {
     IWorkbenchWindow::Pointer window = this->GetWorkbench()->OpenWorkbenchWindow(perspID, input);
     newPage = window->GetActivePage();
   }
 
   return newPage;
 }
 
 int WorkbenchWindow::GetNumber()
 {
   return number;
 }
 
 void WorkbenchWindow::LargeUpdateStart()
 {
   largeUpdates++;
 }
 
 void WorkbenchWindow::LargeUpdateEnd()
 {
   if (--largeUpdates == 0)
   {
     //TODO WorkbenchWindow update action bars after large update
     //this->UpdateActionBars();
   }
 }
 
 void WorkbenchWindow::SetActivePage(IWorkbenchPage::Pointer in)
 {
   if (this->GetActivePage() == in)
   {
     return;
   }
 
   // 1FVGTNR: ITPUI:WINNT - busy cursor for switching perspectives
   //BusyIndicator.showWhile(getShell().getDisplay(), new Runnable() {
   //  public void run() {
   // Deactivate old persp.
   WorkbenchPage::Pointer currentPage = pageList.GetActive();
   if (currentPage.IsNotNull())
   {
     currentPage->OnDeactivate();
   }
 
   // Activate new persp.
   if (in.IsNull() || pageList.Contains(in))
   {
     pageList.SetActive(in);
   }
   WorkbenchPage::Pointer newPage = pageList.GetActive();
   //Composite parent = getPageComposite();
   //StackLayout layout = (StackLayout) parent.getLayout();
   if (newPage.IsNotNull())
   {
     //layout.topControl = newPage.getClientComposite();
     //parent.layout();
     this->HideEmptyWindowContents();
     newPage->OnActivate();
     //this->FirePageActivated(newPage);
     partService.PageActivated(newPage);
     //TODO perspective
     if (newPage->GetPerspective() != 0)
     {
       this->FirePerspectiveActivated(newPage, newPage->GetPerspective());
     }
   }
   else
   {
     //layout.topControl = null;
     //parent.layout();
   }
 
   //updateFastViewBar();
 
   if (this->IsClosing())
   {
     return;
   }
 
   updateDisabled = false;
 
   // Update action bars ( implicitly calls updateActionBars() )
   //updateActionSets();
   //submitGlobalActions();
 
   //if (perspectiveSwitcher != null) {
   //  perspectiveSwitcher.update(false);
   //}
 
   //getMenuManager().update(IAction.TEXT);
   //  }
   //});
 }
 
 bool WorkbenchWindow::SaveState(IMemento::Pointer memento)
 {
   //  MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK,
   //        WorkbenchMessages.WorkbenchWindow_problemsSavingWindow, null);
   bool result = true;
 
   // Save the window's state and bounds.
   if (GetShell()->GetMaximized() || asMaximizedState)
   {
     memento->PutString(WorkbenchConstants::TAG_MAXIMIZED, "true");
   }
   if (GetShell()->GetMinimized())
   {
     memento->PutString(WorkbenchConstants::TAG_MINIMIZED, "true");
   }
   if (normalBounds.IsEmpty())
   {
     normalBounds = GetShell()->GetBounds();
   }
 
   //  IMemento fastViewBarMem = memento
   //      .createChild(IWorkbenchConstants.TAG_FAST_VIEW_DATA);
   //  if (fastViewBar != null) {
   //    fastViewBar.saveState(fastViewBarMem);
   //  }
 
   memento->PutInteger(WorkbenchConstants::TAG_X, normalBounds.x);
   memento->PutInteger(WorkbenchConstants::TAG_Y, normalBounds.y);
   memento->PutInteger(WorkbenchConstants::TAG_WIDTH, normalBounds.width);
   memento->PutInteger(WorkbenchConstants::TAG_HEIGHT, normalBounds.height);
 
   IWorkbenchPage::Pointer activePage = GetActivePage();
   if (activePage
       && activePage->FindView(IntroConstants::INTRO_VIEW_ID))
   {
     IMemento::Pointer introMem = memento
         ->CreateChild(WorkbenchConstants::TAG_INTRO);
     bool isStandby = GetWorkbench()->GetIntroManager()
         ->IsIntroStandby(GetWorkbench()->GetIntroManager()->GetIntro());
     introMem->PutBoolean(WorkbenchConstants::TAG_STANDBY, isStandby);
   }
 
   //  // save the width of the perspective bar
   //  IMemento persBarMem = memento
   //      .createChild(IWorkbenchConstants.TAG_PERSPECTIVE_BAR);
   //  if (perspectiveSwitcher != null) {
   //    perspectiveSwitcher.saveState(persBarMem);
   //  }
 
   //  // / Save the order of the cool bar contribution items
   //        ICoolBarManager2 coolBarMgr = (ICoolBarManager2) getCoolBarManager2();
   //        if (coolBarMgr != null) {
   //          coolBarMgr.refresh();
   //      IMemento coolBarMem = memento
   //          .createChild(IWorkbenchConstants.TAG_COOLBAR_LAYOUT);
   //            if (coolBarMgr.getLockLayout() == true) {
   //        coolBarMem.putInteger(IWorkbenchConstants.TAG_LOCKED, 1);
   //      } else {
   //        coolBarMem.putInteger(IWorkbenchConstants.TAG_LOCKED, 0);
   //      }
   //            IContributionItem[] items = coolBarMgr.getItems();
   //      for (int i = 0; i < items.length; i++) {
   //        IMemento coolItemMem = coolBarMem
   //            .createChild(IWorkbenchConstants.TAG_COOLITEM);
   //        IContributionItem item = items[i];
   //        // The id of the contribution item
   //        if (item.getId() != null) {
   //          coolItemMem.putString(IWorkbenchConstants.TAG_ID, item
   //              .getId());
   //        }
   //        // Write out type and size if applicable
   //        if (item.isSeparator()) {
   //          coolItemMem.putString(IWorkbenchConstants.TAG_ITEM_TYPE,
   //              IWorkbenchConstants.TAG_TYPE_SEPARATOR);
   //        } else if (item.isGroupMarker() && !item.isSeparator()) {
   //          coolItemMem.putString(IWorkbenchConstants.TAG_ITEM_TYPE,
   //              IWorkbenchConstants.TAG_TYPE_GROUPMARKER);
   //        } else {
   //          if (item instanceof PlaceholderContributionItem) {
   //            coolItemMem.putString(
   //                IWorkbenchConstants.TAG_ITEM_TYPE,
   //                IWorkbenchConstants.TAG_TYPE_PLACEHOLDER);
   //          } else {
   //            // Store the identifier.
   //            coolItemMem
   //                .putString(
   //                    IWorkbenchConstants.TAG_ITEM_TYPE,
   //                    IWorkbenchConstants.TAG_TYPE_TOOLBARCONTRIBUTION);
   //          }
   //
   //          /*
   //           * Retrieve a reasonable approximation of the height and
   //           * width, if possible.
   //           */
   //          final int height;
   //          final int width;
   //          if (item instanceof IToolBarContributionItem) {
   //            IToolBarContributionItem toolBarItem = (IToolBarContributionItem) item;
   //            toolBarItem.saveWidgetState();
   //            height = toolBarItem.getCurrentHeight();
   //            width = toolBarItem.getCurrentWidth();
   //          } else if (item instanceof PlaceholderContributionItem) {
   //            PlaceholderContributionItem placeholder = (PlaceholderContributionItem) item;
   //            height = placeholder.getHeight();
   //            width = placeholder.getWidth();
   //          } else {
   //            height = -1;
   //            width = -1;
   //          }
   //
   //          // Store the height and width.
   //          coolItemMem.putInteger(IWorkbenchConstants.TAG_ITEM_X,
   //              width);
   //          coolItemMem.putInteger(IWorkbenchConstants.TAG_ITEM_Y,
   //              height);
   //        }
   //      }
   //    }
 
 
   // Save each page.
   for (PageList::iterator itr = pageList.Begin();
       itr != pageList.End(); ++itr)
   {
     WorkbenchPage::Pointer page = itr->Cast<WorkbenchPage>();
 
     // Save perspective.
     IMemento::Pointer pageMem = memento
     ->CreateChild(WorkbenchConstants::TAG_PAGE);
     pageMem->PutString(WorkbenchConstants::TAG_LABEL, page->GetLabel());
     //result.add(page.saveState(pageMem));
     result &= page->SaveState(pageMem);
 
     if (page == GetActivePage().Cast<WorkbenchPage>())
     {
       pageMem->PutString(WorkbenchConstants::TAG_FOCUS, "true");
     }
 
     //    // Get the input.
     //    IAdaptable* input = page->GetInput();
     //    if (input != 0) {
     //      IPersistableElement persistable = (IPersistableElement) Util.getAdapter(input,
     //          IPersistableElement.class);
     //      if (persistable == null) {
     //        WorkbenchPlugin
     //            .log("Unable to save page input: " //$NON-NLS-1$
     //                + input
     //                + ", because it does not adapt to IPersistableElement"); //$NON-NLS-1$
     //      } else {
     //        // Save input.
     //        IMemento inputMem = pageMem
     //            .createChild(IWorkbenchConstants.TAG_INPUT);
     //        inputMem.putString(IWorkbenchConstants.TAG_FACTORY_ID,
     //            persistable.getFactoryId());
     //        persistable.saveState(inputMem);
     //      }
     //    }
   }
 
   // Save window advisor state.
   IMemento::Pointer windowAdvisorState = memento
   ->CreateChild(WorkbenchConstants::TAG_WORKBENCH_WINDOW_ADVISOR);
   //result.add(getWindowAdvisor().saveState(windowAdvisorState));
   result &= GetWindowAdvisor()->SaveState(windowAdvisorState);
 
   // Save actionbar advisor state.
   IMemento::Pointer actionBarAdvisorState = memento
   ->CreateChild(WorkbenchConstants::TAG_ACTION_BAR_ADVISOR);
   //result.add(getActionBarAdvisor().saveState(actionBarAdvisorState));
   result &= GetActionBarAdvisor()->SaveState(actionBarAdvisorState);
 
   //  // Only save the trim state if we're using the default layout
   //  if (defaultLayout != null) {
   //    IMemento trimState = memento.createChild(IWorkbenchConstants.TAG_TRIM);
   //    result.add(saveTrimState(trimState));
   //  }
 
   return result;
 }
 
 WorkbenchWindowConfigurer::Pointer WorkbenchWindow::GetWindowConfigurer()
 {
   if (windowConfigurer.IsNull())
   {
     // lazy initialize
     windowConfigurer = new WorkbenchWindowConfigurer(WorkbenchWindow::Pointer(this));
   }
   return windowConfigurer;
 }
 
+bool WorkbenchWindow::CanHandleShellCloseEvent()
+{
+  if (!Window::CanHandleShellCloseEvent())
+  {
+    return false;
+  }
+
+  // let the advisor or other interested parties
+  // veto the user's explicit request to close the window
+  return FireWindowShellClosing();
+}
+
 void WorkbenchWindow::ConfigureShell(Shell::Pointer shell)
 {
   Window::ConfigureShell(shell);
 
   detachedWindowShells = new ShellPool(shell, Constants::TITLE
       | Constants::MAX | Constants::CLOSE | Constants::RESIZE | Constants::BORDER );
 
   std::string title = this->GetWindowConfigurer()->BasicGetTitle();
   if (title != "")
   {
     shell->SetText(title);
   }
 
   //  final IWorkbench workbench = getWorkbench();
   //  workbench.getHelpSystem().setHelp(shell,
   //      IWorkbenchHelpContextIds.WORKBENCH_WINDOW);
 
   //    final IContextService contextService = (IContextService) getWorkbench().getService(IContextService.class);
   //    contextService.registerShell(shell, IContextService.TYPE_WINDOW);
 
   this->TrackShellActivation(shell);
   this->TrackShellResize(shell);
 }
 
 ShellPool::Pointer WorkbenchWindow::GetDetachedWindowPool()
 {
   return detachedWindowShells;
 }
 
 WorkbenchAdvisor* WorkbenchWindow::GetAdvisor()
 {
   return this->GetWorkbenchImpl()->GetAdvisor();
 }
 
 WorkbenchWindowAdvisor* WorkbenchWindow::GetWindowAdvisor()
 {
   if (windowAdvisor == 0)
   {
     windowAdvisor = this->GetAdvisor()->CreateWorkbenchWindowAdvisor(this->GetWindowConfigurer());
     poco_check_ptr(windowAdvisor);
   }
   return windowAdvisor;
 }
 
 ActionBarAdvisor::Pointer WorkbenchWindow::GetActionBarAdvisor()
 {
   if (actionBarAdvisor.IsNull())
   {
     actionBarAdvisor = this->GetWindowAdvisor()->CreateActionBarAdvisor(this->GetWindowConfigurer()->GetActionBarConfigurer());
     poco_assert(actionBarAdvisor.IsNotNull());
   }
   return actionBarAdvisor;
 }
 
 Workbench* WorkbenchWindow::GetWorkbenchImpl()
 {
   return dynamic_cast<Workbench*>(this->GetWorkbench());
 }
 
 void WorkbenchWindow::ShowEmptyWindowContents()
 {
   if (!emptyWindowContentsCreated)
   {
     void* parent = this->GetPageComposite();
     emptyWindowContents = this->GetWindowAdvisor()->CreateEmptyWindowContents(
         parent);
     emptyWindowContentsCreated = true;
     //    // force the empty window composite to be layed out
     //    ((StackLayout) parent.getLayout()).topControl = emptyWindowContents;
     //    parent.layout();
   }
 }
 
 void WorkbenchWindow::HideEmptyWindowContents()
 {
   if (emptyWindowContentsCreated)
   {
     if (emptyWindowContents != 0)
     {
       Tweaklets::Get(GuiWidgetsTweaklet::KEY)->Dispose(emptyWindowContents);
       emptyWindowContents = 0;
       //this->GetPageComposite().layout();
     }
     emptyWindowContentsCreated = false;
   }
 }
 
 WorkbenchWindow::ServiceLocatorOwner::ServiceLocatorOwner(WorkbenchWindow* wnd)
 : window(wnd)
 {
 
 }
 
 void WorkbenchWindow::ServiceLocatorOwner::Dispose()
 {
   Shell::Pointer shell = window->GetShell();
   if (shell != 0)
   {
     window->Close();
   }
 }
 
 bool WorkbenchWindow::PageList::Add(IWorkbenchPage::Pointer object)
 {
   pagesInCreationOrder.push_back(object);
   pagesInActivationOrder.push_front(object);
   // It will be moved to top only when activated.
   return true;
 }
 
 WorkbenchWindow::PageList::iterator WorkbenchWindow::PageList::Begin()
 {
   return pagesInCreationOrder.begin();
 }
 
 WorkbenchWindow::PageList::iterator WorkbenchWindow::PageList::End()
 {
   return pagesInCreationOrder.end();
 }
 
 bool WorkbenchWindow::PageList::Contains(IWorkbenchPage::Pointer object)
 {
   return std::find(pagesInCreationOrder.begin(), pagesInCreationOrder.end(),
       object) != pagesInCreationOrder.end();
 }
 
 bool WorkbenchWindow::PageList::Remove(IWorkbenchPage::Pointer object)
 {
   if (active == object)
   {
     active = 0;
   }
   pagesInActivationOrder.remove(object);
   std::size_t origSize = pagesInCreationOrder.size();
   pagesInCreationOrder.remove(object);
   return origSize != pagesInCreationOrder.size();
 }
 
 void WorkbenchWindow::PageList::Clear()
 {
   pagesInCreationOrder.clear();
   pagesInActivationOrder.clear();
   active = 0;
 }
 
 bool WorkbenchWindow::PageList::IsEmpty()
 {
   return pagesInCreationOrder.empty();
 }
 
 const std::list<IWorkbenchPage::Pointer>& WorkbenchWindow::PageList::GetPages()
 {
   return pagesInCreationOrder;
 }
 
 void WorkbenchWindow::PageList::SetActive(IWorkbenchPage::Pointer page)
 {
   if (active == page)
   {
     return;
   }
 
   active = page;
 
   if (page.IsNotNull())
   {
     pagesInActivationOrder.remove(page);
     pagesInActivationOrder.push_back(page);
   }
 }
 
 WorkbenchPage::Pointer WorkbenchWindow::PageList::GetActive()
 {
   return active.Cast<WorkbenchPage>();
 }
 
 WorkbenchPage::Pointer WorkbenchWindow::PageList::GetNextActive()
 {
   if (active.IsNull())
   {
     if (pagesInActivationOrder.empty())
     {
       return WorkbenchPage::Pointer(0);
     }
 
     return pagesInActivationOrder.back().Cast<WorkbenchPage>();
   }
 
   if (pagesInActivationOrder.size() < 2)
   {
     return WorkbenchPage::Pointer(0);
   }
 
   std::list<IWorkbenchPage::Pointer>::reverse_iterator riter =
   pagesInActivationOrder.rbegin();
   return (++riter)->Cast<WorkbenchPage>();
 }
 
 WorkbenchWindow::ShellActivationListener::ShellActivationListener(WorkbenchWindow::Pointer w) :
 window(w)
 {
 }
 
 void WorkbenchWindow::ShellActivationListener::ShellActivated(ShellEvent::Pointer /*event*/)
 {
   WorkbenchWindow::Pointer wnd(window);
 
   wnd->shellActivated = true;
   wnd->serviceLocator->Activate();
   wnd->GetWorkbenchImpl()->SetActivatedWindow(wnd);
   WorkbenchPage::Pointer currentPage = wnd->GetActivePage().Cast<WorkbenchPage>();
   if (currentPage != 0)
   {
     IWorkbenchPart::Pointer part = currentPage->GetActivePart();
     if (part != 0)
     {
       PartSite::Pointer site = part->GetSite().Cast<PartSite>();
       site->GetPane()->ShellActivated();
     }
     IEditorPart::Pointer editor = currentPage->GetActiveEditor();
     if (editor != 0)
     {
       PartSite::Pointer site = editor->GetSite().Cast<PartSite>();
       site->GetPane()->ShellActivated();
     }
     wnd->GetWorkbenchImpl()->FireWindowActivated(wnd);
   }
   //liftRestrictions();
 }
 
 void WorkbenchWindow::ShellActivationListener::ShellDeactivated(ShellEvent::Pointer /*event*/)
 {
   WorkbenchWindow::Pointer wnd(window);
 
   wnd->shellActivated = false;
   //imposeRestrictions();
   wnd->serviceLocator->Deactivate();
   WorkbenchPage::Pointer currentPage = wnd->GetActivePage().Cast<WorkbenchPage>();
   if (currentPage != 0)
   {
     IWorkbenchPart::Pointer part = currentPage->GetActivePart();
     if (part != 0)
     {
       PartSite::Pointer site = part->GetSite().Cast<PartSite>();
       site->GetPane()->ShellDeactivated();
     }
     IEditorPart::Pointer editor = currentPage->GetActiveEditor();
     if (editor != 0)
     {
       PartSite::Pointer site = editor->GetSite().Cast<PartSite>();
       site->GetPane()->ShellDeactivated();
     }
     wnd->GetWorkbenchImpl()->FireWindowDeactivated(wnd);
   }
 }
 
 void WorkbenchWindow::TrackShellActivation(Shell::Pointer shell)
 {
   shellActivationListener = new ShellActivationListener(WorkbenchWindow::Pointer(this));
   shell->AddShellListener(shellActivationListener);
 }
 
 WorkbenchWindow::ControlResizeListener::ControlResizeListener(WorkbenchWindow* w)
 : window(w)
 {
 }
 
 GuiTk::IControlListener::Events::Types WorkbenchWindow::ControlResizeListener::GetEventTypes() const
 {
   return Events::MOVED | Events::RESIZED;
 }
 
 void WorkbenchWindow::
 ControlResizeListener::ControlMoved(GuiTk::ControlEvent::Pointer /*e*/)
 {
   this->SaveBounds();
 }
 
 void WorkbenchWindow::
 ControlResizeListener::ControlResized(GuiTk::ControlEvent::Pointer /*e*/)
 {
   this->SaveBounds();
 }
 
 void WorkbenchWindow::ControlResizeListener::SaveBounds()
 {
   WorkbenchWindow::Pointer wnd(window);
 
   Shell::Pointer shell = wnd->GetShell();
   if (shell == 0)
   {
     return;
   }
   //  if (shell->IsDisposed())
   //  {
   //    return;
   //  }
   if (shell->GetMinimized())
   {
     return;
   }
   if (shell->GetMaximized())
   {
     wnd->asMaximizedState = true;
     return;
   }
   wnd->asMaximizedState = false;
   wnd->normalBounds = shell->GetBounds();
 }
 
 void WorkbenchWindow::TrackShellResize(Shell::Pointer newShell)
 {
   controlResizeListener = new ControlResizeListener(this);
   Tweaklets::Get(GuiWidgetsTweaklet::KEY)->AddControlListener(newShell->GetControl(), controlResizeListener);
 }
 
 }
diff --git a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.h b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.h
index 43e0932ee6..6a406926d8 100644
--- a/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.h
+++ b/BlueBerry/Bundles/org.blueberry.ui/src/internal/berryWorkbenchWindow.h
@@ -1,630 +1,632 @@
 /*===================================================================
 
 BlueBerry Platform
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef BERRYWORKBENCHWINDOW_H_
 #define BERRYWORKBENCHWINDOW_H_
 
 #include "berryIWorkbenchWindow.h"
 
 #include "berryIPerspectiveListener.h"
 #include "guitk/berryGuiTkIControlListener.h"
 #include "berryWindow.h"
 
 #include "berryWorkbenchWindowConfigurer.h"
 #include "berryShellPool.h"
 #include "berryServiceLocator.h"
 #include "berryWWinPartService.h"
 
 #include "application/berryWorkbenchAdvisor.h"
 #include "application/berryWorkbenchWindowAdvisor.h"
 #include "application/berryActionBarAdvisor.h"
 
 #include <list>
 
 namespace berry
 {
 
 struct IWorkbench;
 struct IWorkbenchPage;
 class WorkbenchPage;
 struct IPartService;
 struct ISelectionService;
 struct IPerspectiveDescriptor;
 
 class Workbench;
 
 /**
  * \ingroup org_blueberry_ui
  *
  */
 class BERRY_UI WorkbenchWindow: public Window, public IWorkbenchWindow
 {
 
 public:
 
   berryObjectMacro(WorkbenchWindow);
 
   WorkbenchWindow(int number);
 
   ~WorkbenchWindow();
 
   Object::Pointer GetService(const std::string& key);
 
   bool HasService(const std::string& key) const;
 
   int Open();
   bool Close();
 
   Shell::Pointer GetShell();
 
   /**
    * @see org.blueberry.ui.IPageService
    */
   void AddPerspectiveListener(IPerspectiveListener::Pointer l);
 
   /**
    * @see org.blueberry.ui.IPageService
    */
   void RemovePerspectiveListener(IPerspectiveListener::Pointer l);
 
   /**
    * @see org.blueberry.ui.IPageService
    */
   IPerspectiveListener::Events& GetPerspectiveEvents();
 
   SmartPointer<IWorkbenchPage> GetActivePage();
 
   /**
    * Sets the active page within the window.
    *
    * @param in
    *            identifies the new active page, or <code>null</code> for no
    *            active page
    */
   void SetActivePage(SmartPointer<IWorkbenchPage> in);
 
   IWorkbench* GetWorkbench();
 
   IPartService* GetPartService();
 
   ISelectionService* GetSelectionService();
 
   SmartPointer<IWorkbenchPage> OpenPage(const std::string& perspectiveId,
       IAdaptable* input);
 
   SmartPointer<IWorkbenchPage> OpenPage(IAdaptable* input);
 
   //TODO menu manager
   //virtual void* GetMenuManager() = 0;
 
   virtual bool SaveState(IMemento::Pointer memento);
 
   /**
    * Called when this window is about to be closed.
    *
    * Subclasses may overide to add code that returns <code>false</code> to
    * prevent closing under certain conditions.
    */
   virtual bool OkToClose();
 
   bool RestoreState(IMemento::Pointer memento, SmartPointer<
       IPerspectiveDescriptor> activeDescriptor);
 
   /**
    * Returns the number. This corresponds to a page number in a window or a
    * window number in the workbench.
    */
   int GetNumber();
 
   /**
    * <p>
    * Indicates the start of a large update within this window. This is used to
    * disable CPU-intensive, change-sensitive services that were temporarily
    * disabled in the midst of large changes. This method should always be
    * called in tandem with <code>largeUpdateEnd</code>, and the event loop
    * should not be allowed to spin before that method is called.
    * </p>
    * <p>
    * Important: always use with <code>largeUpdateEnd</code>!
    * </p>
    *
    * @since 3.1
    */
   void LargeUpdateStart();
 
   /**
    * <p>
    * Indicates the end of a large update within this window. This is used to
    * re-enable services that were temporarily disabled in the midst of large
    * changes. This method should always be called in tandem with
    * <code>largeUpdateStart</code>, and the event loop should not be
    * allowed to spin before this method is called.
    * </p>
    * <p>
    * Important: always protect this call by using <code>finally</code>!
    * </p>
    *
    * @since 3.1
    */
   void LargeUpdateEnd();
 
 protected:
 
   friend class WorkbenchConfigurer;
   friend class WorkbenchWindowConfigurer;
   friend class WorkbenchWindowConfigurer::WindowActionBarConfigurer;
   friend class Workbench;
   friend class LayoutPartSash;
   friend class EditorSashContainer;
   friend class WorkbenchPage;
   friend class DetachedWindow;
 
   /**
    * Returns the GUI dependent page composite, under which the window's
    * pages create their controls.
    */
   void* GetPageComposite();
 
   /**
    * Creates and remembers the client composite, under which workbench pages
    * create their controls.
    *
    * @since 3.0
    */
   virtual void* CreatePageComposite(void* parent) = 0;
 
   /**
    * Creates the contents of the workbench window, including trim controls and
    * the client composite. This MUST create the client composite via a call to
    * <code>createClientComposite</code>.
    *
    * @since 3.0
    */
   void* CreateContents(Shell::Pointer parent);
 
   /**
    * Creates the default contents and layout of the shell.
    *
    * @param shell
    *            the shell
    */
   virtual void CreateDefaultContents(Shell::Pointer shell);
 
   /**
    * Returns the unique object that applications use to configure this window.
    * <p>
    * IMPORTANT This method is declared package-private to prevent regular
    * plug-ins from downcasting IWorkbenchWindow to WorkbenchWindow and getting
    * hold of the workbench window configurer that would allow them to tamper
    * with the workbench window. The workbench window configurer is available
    * only to the application.
    * </p>
    */
   WorkbenchWindowConfigurer::Pointer GetWindowConfigurer();
 
+  bool CanHandleShellCloseEvent();
+
   /*
    * @see berry::Window#configureShell(Shell::Pointer)
    */
   void ConfigureShell(Shell::Pointer shell);
 
   ShellPool::Pointer GetDetachedWindowPool();
 
   /**
    * Fills the window's real action bars.
    *
    * @param flags
    *            indicate which bars to fill
    */
   void FillActionBars(int flags);
 
   /**
    * The <code>WorkbenchWindow</code> implementation of this method
    * delegates to the window configurer.
    *
    * @since 3.0
    */
   Point GetInitialSize();
 
   /**
    * Returns the default page input for workbench pages opened in this window.
    *
    * @return the default page input or <code>null</code> if none
    * @since 3.1
    */
   IAdaptable* GetDefaultPageInput();
 
   bool IsClosing();
 
   /**
    * Opens a new page. Assumes that busy cursor is active.
    * <p>
    * <b>Note:</b> Since release 2.0, a window is limited to contain at most
    * one page. If a page exist in the window when this method is used, then
    * another window is created for the new page. Callers are strongly
    * recommended to use the <code>IWorkbench.openPerspective</code> APIs to
    * programmatically show a perspective.
    * </p>
    */
   SmartPointer<IWorkbenchPage> BusyOpenPage(const std::string& perspID,
       IAdaptable* input);
 
   bool ClosePage(SmartPointer<IWorkbenchPage> in, bool save);
 
   /**
    * Makes the window visible and frontmost.
    */
   void MakeVisible();
 
   /**
    * The composite under which workbench pages create their controls.
    *
    * @since 3.0
    */
   void* pageComposite;
 
 private:
 
   /**
    * Constant indicating that all the actions bars should be filled.
    *
    * @since 3.0
    */
   static const int FILL_ALL_ACTION_BARS;
 
   ShellPool::Pointer detachedWindowShells;
 
   /**
    * Object for configuring this workbench window. Lazily initialized to an
    * instance unique to this window.
    *
    * @since 3.0
    */
   WorkbenchWindowConfigurer::Pointer windowConfigurer;
 
   WorkbenchWindowAdvisor* windowAdvisor;
 
   ActionBarAdvisor::Pointer actionBarAdvisor;
 
   int number;
 
   /**
    * The number of large updates that are currently going on. If this is
    * number is greater than zero, then UI updateActionBars is a no-op.
    */
   int largeUpdates;
 
   bool closing;
   bool shellActivated;
   bool updateDisabled;
 
   /**
    * The map of services maintained by the workbench window. These services
    * are initialized during workbench window during the
    * {@link #configureShell(Shell)}.
    */
   ServiceLocator::Pointer serviceLocator;
 
   bool emptyWindowContentsCreated;
   void* emptyWindowContents;
 
   Rectangle normalBounds;
 
   bool asMaximizedState;
 
   IPerspectiveListener::Events perspectiveEvents;
 
   WWinPartService partService;
 
   struct ServiceLocatorOwner: public IDisposable
   {
     ServiceLocatorOwner(WorkbenchWindow* wnd);
 
     WorkbenchWindow* window;
 
     void Dispose();
   };
 
   IDisposable::Pointer serviceLocatorOwner;
 
   class PageList
   {
 
   private:
     // List of pages in the order they were created;
     std::list<SmartPointer<IWorkbenchPage> > pagesInCreationOrder;
 
     // List of pages where the top is the last activated.
     std::list<SmartPointer<IWorkbenchPage> > pagesInActivationOrder;
 
     // The page explicitly activated
     SmartPointer<IWorkbenchPage> active;
 
   public:
 
     typedef std::list<SmartPointer<IWorkbenchPage> >::iterator iterator;
 
     bool Add(SmartPointer<IWorkbenchPage> object);
 
     iterator Begin();
 
     iterator End();
 
     void Clear();
 
     bool Contains(SmartPointer<IWorkbenchPage> object);
 
     bool Remove(SmartPointer<IWorkbenchPage> object);
 
     bool IsEmpty();
 
     const std::list<SmartPointer<IWorkbenchPage> >& GetPages();
 
     void SetActive(SmartPointer<IWorkbenchPage> page);
 
     SmartPointer<WorkbenchPage> GetActive();
 
     SmartPointer<WorkbenchPage> GetNextActive();
   };
 
   PageList pageList;
 
   /**
    * Notifies interested parties (namely the advisor) that the window is about
    * to be opened.
    *
    * @since 3.1
    */
   void FireWindowOpening();
 
   /**
    * Notifies interested parties (namely the advisor) that the window has been
    * restored from a previously saved state.
    *
    * @throws WorkbenchException
    *             passed through from the advisor
    * @since 3.1
    */
   void FireWindowRestored();
 
   /**
    * Notifies interested parties (namely the advisor) that the window has been
    * created.
    *
    * @since 3.1
    */
   void FireWindowCreated();
 
   /**
    * Notifies interested parties (namely the advisor and the window listeners)
    * that the window has been opened.
    *
    * @since 3.1
    */
   void FireWindowOpened();
 
   /**
    * Notifies interested parties (namely the advisor) that the window's shell
    * is closing. Allows the close to be vetoed.
    *
    * @return <code>true</code> if the close should proceed,
    *         <code>false</code> if it should be canceled
    * @since 3.1
    */
   bool FireWindowShellClosing();
 
   /**
    * Notifies interested parties (namely the advisor and the window listeners)
    * that the window has been closed.
    *
    * @since 3.1
    */
   void FireWindowClosed();
 
   //  /**
   //   * Fires page activated
   //   */
   //  void FirePageActivated(IWorkbenchPage::Pointer page);
   //
   //  /**
   //   * Fires page closed
   //   */
   //  void FirePageClosed(IWorkbenchPage::Pointer page);
   //
   //  /**
   //   * Fires page opened
   //   */
   //  void FirePageOpened(IWorkbenchPage::Pointer page);
 
   /**
    * Fires perspective activated
    */
   void FirePerspectiveActivated(SmartPointer<IWorkbenchPage> page,
       IPerspectiveDescriptor::Pointer perspective);
 
   /**
    * Fires perspective deactivated.
    *
    * @since 3.2
    */
   void FirePerspectivePreDeactivate(SmartPointer<IWorkbenchPage> page,
       IPerspectiveDescriptor::Pointer perspective);
 
   /**
    * Fires perspective deactivated.
    *
    * @since 3.1
    */
   void FirePerspectiveDeactivated(SmartPointer<IWorkbenchPage> page,
       IPerspectiveDescriptor::Pointer perspective);
 
   /**
    * Fires perspective changed
    */
   void FirePerspectiveChanged(SmartPointer<IWorkbenchPage> ,
       IPerspectiveDescriptor::Pointer perspective, const std::string& changeId);
 
   /**
    * Fires perspective changed for an affected part
    */
   void FirePerspectiveChanged(SmartPointer<IWorkbenchPage> ,
       IPerspectiveDescriptor::Pointer perspective,
       IWorkbenchPartReference::Pointer partRef, const std::string& changeId);
 
   /**
    * Fires perspective closed
    */
   void FirePerspectiveClosed(SmartPointer<IWorkbenchPage> ,
       IPerspectiveDescriptor::Pointer perspective);
 
   /**
    * Fires perspective opened
    */
   void FirePerspectiveOpened(SmartPointer<IWorkbenchPage> ,
       IPerspectiveDescriptor::Pointer perspective);
 
   /**
    * Fires perspective saved as.
    *
    * @since 3.1
    */
   void FirePerspectiveSavedAs(SmartPointer<IWorkbenchPage> ,
       IPerspectiveDescriptor::Pointer oldPerspective,
       IPerspectiveDescriptor::Pointer newPerspective);
 
   /**
    * Returns the workbench advisor. Assumes the workbench has been created
    * already.
    * <p>
    * IMPORTANT This method is declared private to prevent regular plug-ins
    * from downcasting IWorkbenchWindow to WorkbenchWindow and getting hold of
    * the workbench advisor that would allow them to tamper with the workbench.
    * The workbench advisor is internal to the application.
    * </p>
    */
   /* private - DO NOT CHANGE */
   WorkbenchAdvisor* GetAdvisor();
 
   /**
    * Returns the window advisor, creating a new one for this window if needed.
    * <p>
    * IMPORTANT This method is declared private to prevent regular plug-ins
    * from downcasting IWorkbenchWindow to WorkbenchWindow and getting hold of
    * the window advisor that would allow them to tamper with the window. The
    * window advisor is internal to the application.
    * </p>
    */
   /* private - DO NOT CHANGE */
   WorkbenchWindowAdvisor* GetWindowAdvisor();
 
   /**
    * Returns the action bar advisor, creating a new one for this window if
    * needed.
    * <p>
    * IMPORTANT This method is declared private to prevent regular plug-ins
    * from downcasting IWorkbenchWindow to WorkbenchWindow and getting hold of
    * the action bar advisor that would allow them to tamper with the window's
    * action bars. The action bar advisor is internal to the application.
    * </p>
    */
   /* private - DO NOT CHANGE */
   ActionBarAdvisor::Pointer GetActionBarAdvisor();
 
   /*
    * Returns the IWorkbench implementation.
    */
   Workbench* GetWorkbenchImpl();
 
   bool UnableToRestorePage(IMemento::Pointer pageMem);
 
   /**
    * Close the window.
    *
    * Assumes that busy cursor is active.
    */
   bool BusyClose();
 
   /**
    * Unconditionally close this window. Assumes the proper flags have been set
    * correctly (e.i. closing and updateDisabled)
    */
   bool HardClose();
 
   /**
    * Close all of the pages.
    */
   void CloseAllPages();
 
   /**
    * Save all of the pages. Returns true if the operation succeeded.
    */
   bool SaveAllPages(bool bConfirm);
 
   void ShowEmptyWindowContents();
 
   void HideEmptyWindowContents();
 
   struct ShellActivationListener: public IShellListener
   {
     ShellActivationListener(WorkbenchWindow::Pointer window);
 
     void ShellActivated(ShellEvent::Pointer event);
 
     void ShellDeactivated(ShellEvent::Pointer event);
 
   private:
 
     WorkbenchWindow::WeakPtr window;
   };
 
   IShellListener::Pointer shellActivationListener;
 
   /**
    * Hooks a listener to track the activation and deactivation of the window's
    * shell. Notifies the active part and editor of the change
    */
   void TrackShellActivation(Shell::Pointer shell);
 
   struct ControlResizeListener: public GuiTk::IControlListener
   {
     ControlResizeListener(WorkbenchWindow* window);
 
     GuiTk::IControlListener::Events::Types GetEventTypes() const;
 
     void ControlMoved(GuiTk::ControlEvent::Pointer e);
 
     void ControlResized(GuiTk::ControlEvent::Pointer e);
 
   private:
 
     void SaveBounds();
 
     WorkbenchWindow* window;
   };
 
   GuiTk::IControlListener::Pointer controlResizeListener;
 
   /**
    * Hooks a listener to track the resize of the window's shell. Stores the
    * new bounds if in normal state - that is, not in minimized or maximized
    * state)
    */
   void TrackShellResize(Shell::Pointer newShell);
 
 };
 
 }
 
 #endif /*BERRYWORKBENCHWINDOW_H_*/