final String factoryId = ((Workbench) window.getWorkbench())

      // RAP [hs] patched for interactiondesign API

                .getPresentationId();

      String tempId = getBrandingPresentationFactoryId();

      if( tempId == null ) {

        if (factoryId != null && factoryId.length() > 0) {

        tempId = ( ( Workbench ) window.getWorkbench() ).getPresentationId();

            final AbstractPresentationFactory [] factory = new AbstractPresentationFactory[1];

      }

            StartupThreading.runWithoutExceptions(new StartupRunnable() {

      final String factoryId = tempId;

				public void runWithException() throws Throwable {

      if (factoryId != null && factoryId.length() > 0) {

					factory[0] = WorkbenchPlugin.getDefault()

        final AbstractPresentationFactory [] factory = new AbstractPresentationFactory[1];

							.getPresentationFactory(factoryId);

        StartupThreading.runWithoutExceptions(new StartupRunnable() {

				}

			});

            public void runWithException() throws Throwable {

                factory[0] = WorkbenchPlugin.getDefault()

            if (factory[0] != null) {

                        .getPresentationFactory(factoryId);

                return factory[0];

            }

        });

        if (factory[0] != null) {

            return factory[0];

        }

      }

      // presentation ID must be a bogus value, reset it to the default

      PrefUtil.getAPIPreferenceStore().setValue(

            IWorkbenchPreferenceConstants.PRESENTATION_FACTORY_ID,

            IWorkbenchConstants.DEFAULT_PRESENTATION_ID);

      return new WorkbenchPresentationFactory();

    }

    // RAP [hs] method introduced for interactiondesign API

    private String getBrandingPresentationFactoryId() {

      String result = null;

      AbstractBranding branding = BrandingUtil.findBranding();

      if( branding != null ) {

        String brandingId = branding.getId();

        IExtensionRegistry registry = Platform.getExtensionRegistry();

        final String id = "org.eclipse.rap.ui.branding";

        IExtensionPoint brandingPoint = registry.getExtensionPoint( id );

        if( brandingPoint != null ) {

          IConfigurationElement[] elements 

            = brandingPoint.getConfigurationElements();

          boolean found = false;

          for( int i = 0; i < elements.length && !found; i++ ) {

            String tempId = elements[ i ].getAttribute( "id" );

            if( tempId.equals( brandingId ) ) {

              found = true;

              result = loadBrandingPresentationFactoryId( elements[ i ] );

        // presentation ID must be a bogus value, reset it to the default

      }

        PrefUtil.getAPIPreferenceStore().setValue(

      return result;

				IWorkbenchPreferenceConstants.PRESENTATION_FACTORY_ID,

    }

				IWorkbenchConstants.DEFAULT_PRESENTATION_ID);

        return new WorkbenchPresentationFactory();

    // RAP [hs] method introduced for interactiondesign API

    private String loadBrandingPresentationFactoryId( 

      final IConfigurationElement element )

    {

      String result = null;

      IConfigurationElement[] factory 

        = element.getChildren( "presentationFactory" );

      if( factory.length > 0 ) {

        result = factory[ 0 ].getAttribute( "id" );

      }

      return result;

        if (isvMenuMgr == null) {

      if( isvMenuMgr == null ) {

			isvMenuMgr = new PaneMenuManager();

        WorkbenchWindow window = page.window;

		}

        // RAP [hs] patched for interactiondesign API

        return isvMenuMgr;

        if( window.getConfigurablePresentationFactory() != null ) {

          isvMenuMgr = window.createPartMenuManager();

        } else {        

          isvMenuMgr = new PaneMenuManager();

        }

      }

      return isvMenuMgr;

        public String getProperty(String id) {            

        public String getProperty(String id) { 

            return PartStack.this.getProperty(id);

          // RAP [hs] patched for interactiondesign API

          String result = PartStack.this.getProperty(id);

          if( id.equals( "id" ))

            result = PartStack.this.getID();

          return result;

		IWorkbenchWindow {

        IWorkbenchWindow {

	private WorkbenchWindowAdvisor windowAdvisor;

    private WorkbenchWindowAdvisor windowAdvisor;

	private ActionBarAdvisor actionBarAdvisor;

    private ActionBarAdvisor actionBarAdvisor;

	private int number;

    private int number;

	private PageList pageList = new PageList();

    private PageList pageList = new PageList();

	private PageListenerList pageListeners = new PageListenerList();

    private PageListenerList pageListeners = new PageListenerList();

	private PerspectiveListenerList perspectiveListeners = new PerspectiveListenerList();

    private PerspectiveListenerList perspectiveListeners = new PerspectiveListenerList();

	private WWinPartService partService = new WWinPartService(this);

    private WWinPartService partService = new WWinPartService(this);

	private ActionPresentation actionPresentation;

    private ActionPresentation actionPresentation;

	private WWinActionBars actionBars;

    private WWinActionBars actionBars;

	private boolean updateDisabled = true;

    private boolean updateDisabled = true;

	private boolean closing = false;

    private boolean closing = false;

	private boolean shellActivated = false;

    private boolean shellActivated = false;

	private FastViewBar fastViewBar;

    private FastViewBar fastViewBar;

	private PerspectiveSwitcher perspectiveSwitcher = null;

    private PerspectiveSwitcher perspectiveSwitcher = null;

	private TrimLayout defaultLayout;

    private TrimLayout defaultLayout;

	ProgressRegion progressRegion = null;

    ProgressRegion progressRegion = null;

	// Legacy (3.2) contribution handling

    // Legacy (3.2) contribution handling

	private TrimBarManager2 trimMgr2 = null;

    private TrimBarManager2 trimMgr2 = null;

	// 3.3 Trim Contribution handling

    // 3.3 Trim Contribution handling

	private TrimContributionManager trimContributionMgr = null;

    private TrimContributionManager trimContributionMgr = null;

	/**

    /**

	 * The map of services maintained by the workbench window. These services

     * The map of services maintained by the workbench window. These services

	 * are initialized during workbench window during the

     * are initialized during workbench window during the

	 * {@link #configureShell(Shell)}.

     * {@link #configureShell(Shell)}.

	 */

     */

	private final ServiceLocator serviceLocator;

    private final ServiceLocator serviceLocator;

//	private HeapStatus heapStatus;

//  private HeapStatus heapStatus;

//	private WindowTrimProxy heapStatusTrim = null;

//  private WindowTrimProxy heapStatusTrim = null;

	private boolean emptyWindowContentsCreated = false;

    private boolean emptyWindowContentsCreated = false;

	private Control emptyWindowContents;

    private Control emptyWindowContents;

	private Rectangle normalBounds;

    private Rectangle normalBounds;

	private boolean asMaximizedState = false;

	private CBanner topBar;

	private IWindowTrim topBarTrim;

	// Previous shell size. Used to prevent the CBanner from triggering

	// redundant layouts

	private Point lastShellSize = new Point(0, 0);

	/**

	 * The composite under which workbench pages create their controls.

	 */

	private Composite pageComposite;

	/**

	 * Bit flags indication which submenus (New, Show Views, ...) this window

	 * contains. Initially none.

	 */

	private int submenus = 0x00;

	/**

	 * Object for configuring this workbench window. Lazily initialized to an

	 * instance unique to this window.

	 */

	private WorkbenchWindowConfigurer windowConfigurer = null;

	/**

	 * List of generic property listeners.

	 */

	private ListenerList genericPropertyListeners = new ListenerList();

	// RAP [bm]: detached windows

//	private ShellPool detachedWindowShells;

	// RAPEND: [bm] 

	static final String TEXT_DELIMITERS = TextProcessor.getDefaultDelimiters() + "-"; //$NON-NLS-1$

	// constants for shortcut bar group ids

	static final String GRP_PAGES = "pages"; //$NON-NLS-1$

	static final String GRP_PERSPECTIVES = "perspectives"; //$NON-NLS-1$

	static final String GRP_FAST_VIEWS = "fastViews"; //$NON-NLS-1$

	// static fields for inner classes.

	static final int VGAP = 0;

	static final int CLIENT_INSET = 3;

	static final int BAR_SIZE = 23;

	/**

	 * Coolbar visibility change property.

	 */

	public static final String PROP_COOLBAR_VISIBLE = "coolbarVisible"; //$NON-NLS-1$

	/**

	 * Perspective bar visibility change property.

	 */

	public static final String PROP_PERSPECTIVEBAR_VISIBLE = "perspectiveBarVisible"; //$NON-NLS-1$

	/**

	 * Constant (bit mask) indicating which the Show View submenu is probably

	 * present somewhere in this window.

	 * 

	 * @see #addSubmenu

	 */

	public static final int SHOW_VIEW_SUBMENU = 0x01;

	/**

	 * Constant (bit mask) indicating which the Open Perspective submenu is

	 * probably present somewhere in this window.

	 * 

	 * @see #addSubmenu

	 */

	public static final int OPEN_PERSPECTIVE_SUBMENU = 0x02;

	/**

	 * Constant (bit mask) indicating which the New Wizard submenu is probably

	 * present somewhere in this window.

	 * 

	 * @see #addSubmenu

	 */

	public static final int NEW_WIZARD_SUBMENU = 0x04;

	/**

	 * Remembers that this window contains the given submenu.

	 * 

	 * @param type

	 *            the type of submenu, one of:

	 *            {@link #NEW_WIZARD_SUBMENU NEW_WIZARD_SUBMENU},

	 *            {@link #OPEN_PERSPECTIVE_SUBMENU OPEN_PERSPECTIVE_SUBMENU},

	 *            {@link #SHOW_VIEW_SUBMENU SHOW_VIEW_SUBMENU}

	 * @see #containsSubmenu

	 */

	public void addSubmenu(int type) {

		submenus |= type;

	}

	/**

	 * Checks to see if this window contains the given type of submenu.

	 * 

	 * @param type

	 *            the type of submenu, one of:

	 *            {@link #NEW_WIZARD_SUBMENU NEW_WIZARD_SUBMENU},

	 *            {@link #OPEN_PERSPECTIVE_SUBMENU OPEN_PERSPECTIVE_SUBMENU},

	 *            {@link #SHOW_VIEW_SUBMENU SHOW_VIEW_SUBMENU}

	 * @return <code>true</code> if window contains submenu,

	 *         <code>false</code> otherwise

	 * @see #addSubmenu

	 */

	public boolean containsSubmenu(int type) {

		return ((submenus & type) != 0);

	}

	/**

	 * Constant indicating that all the actions bars should be filled.

	 */

	private static final int FILL_ALL_ACTION_BARS = ActionBarAdvisor.FILL_MENU_BAR

			| ActionBarAdvisor.FILL_COOL_BAR

			| ActionBarAdvisor.FILL_STATUS_LINE;

	/**

	 * Creates and initializes a new workbench window.

	 * 

	 * @param number

	 *            the number for the window

	 */

	public WorkbenchWindow(int number) {

		super(null);

		this.number = number;

		// Make sure there is a workbench. This call will throw

		// an exception if workbench not created yet.

		final IWorkbench workbench = PlatformUI.getWorkbench();

		IServiceLocatorCreator slc = (IServiceLocatorCreator) workbench

				.getService(IServiceLocatorCreator.class);

		this.serviceLocator = (ServiceLocator) slc

				.createServiceLocator(workbench, null);

		initializeDefaultServices();

		// Add contribution managers that are exposed to other plugins.

		addMenuBar();

		addCoolBar(SWT.NONE);  // style is unused

		addStatusLine();

		// register with the tracker

		getExtensionTracker()

				.registerHandler(

						actionSetHandler,

						ExtensionTracker

								.createExtensionPointFilter(getActionSetExtensionPoint()));

		fireWindowOpening();

		// set the shell style

		setShellStyle(getWindowConfigurer().getShellStyle());

		// Fill the action bars

		fillActionBars(FILL_ALL_ACTION_BARS);

	}

	/**

	 * Return the action set extension point.

	 * 

	 * @return the action set extension point

	 */

	private IExtensionPoint getActionSetExtensionPoint() {

		// RAP [bm]: 

//		return Platform.getExtensionRegistry().getExtensionPoint(

//				PlatformUI.PLUGIN_ID, IWorkbenchRegistryConstants.PL_ACTION_SETS);

		return Platform.getExtensionRegistry().getExtensionPoint(

				PlatformUI.PLUGIN_EXTENSION_NAME_SPACE, IWorkbenchRegistryConstants.PL_ACTION_SETS);

	}

	/**

	 * Return the style bits for the shortcut bar.

	 * 

	 * @return int

	 */

	protected int perspectiveBarStyle() {

		return SWT.FLAT | SWT.WRAP | SWT.RIGHT | SWT.HORIZONTAL;

	}

	// RAP [bm]: not used

//	private TrimDropTarget trimDropTarget;

	// RAPEND: [bm] 

	private boolean coolBarVisible = true;

	private boolean perspectiveBarVisible = true;

	private boolean fastViewBarVisible = true;

	private boolean statusLineVisible = true;

	private IWindowTrim statusLineTrim = null;

	/**

	 * The handlers for global actions that were last submitted to the workbench

	 * command support. This is a map of command identifiers to

	 * <code>ActionHandler</code>. This map is never <code>null</code>,

	 * and is never empty as long as at least one global action has been

	 * registered.

	 */

	private Map globalActionHandlersByCommandId = new HashMap();

	/**

	 * The list of handler submissions submitted to the workbench command

	 * support. This list may be empty, but it is never <code>null</code>.

	 */

	private List handlerActivations = new ArrayList();

	/**

	 * 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.

	 */

	private int largeUpdates = 0;

	private IExtensionTracker tracker;

	private IExtensionChangeHandler actionSetHandler = new IExtensionChangeHandler() {

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.core.runtime.dynamichelpers.IExtensionChangeHandler#addExtension(org.eclipse.core.runtime.dynamichelpers.IExtensionTracker,

		 *      org.eclipse.core.runtime.IExtension)

		 */

		public void addExtension(IExtensionTracker tracker, IExtension extension) {

			// this assumes that the workbench-level tracker will have already

			// updated the registry

			ArrayList setsToActivate = new ArrayList();

			// look for all new sets that are on by default. Examine the tracker

			// at the workbench level to see what descriptors are registered

			// against this extension

			Object[] registeredObjects = getWorkbench().getExtensionTracker()

					.getObjects(extension);

			for (int i = 0; i < registeredObjects.length; i++) {

				if (registeredObjects[i] instanceof IActionSetDescriptor) {

					IActionSetDescriptor desc = (IActionSetDescriptor) registeredObjects[i];

					if (desc.isInitiallyVisible()) {

						setsToActivate.add(desc);

					}

				}

			}

			// if none of the new sets are marked as initially visible, abort.

			if (setsToActivate.isEmpty()) {

				return;

			}

			IActionSetDescriptor[] descriptors = (IActionSetDescriptor[]) setsToActivate

					.toArray(new IActionSetDescriptor[setsToActivate.size()]);

			WorkbenchPage page = getActiveWorkbenchPage();

			if (page != null) {

				Perspective[] perspectives = page.getOpenInternalPerspectives();

				for (int i = 0; i < perspectives.length; i++) {

					perspectives[i].turnOnActionSets(descriptors);

				}

			}

			updateActionSets();

		}

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.core.runtime.dynamichelpers.IExtensionChangeHandler#removeExtension(org.eclipse.core.runtime.IExtension,

		 *      java.lang.Object[])

		 */

		public void removeExtension(IExtension extension, Object[] objects) {

			// remove the contributions from the window bars and dispose of the

			// actions

			for (int i = 0; i < objects.length; i++) {

				if (objects[i] instanceof PluginActionSetBuilder.Binding) {

					PluginActionSetBuilder.Binding binding = (PluginActionSetBuilder.Binding) objects[i];

					binding.builder.removeActionExtensions(binding.set,

							binding.window);

					binding.set.dispose();

				}

			}

			// update all opened perspectives

			Perspective[] perspectives = getActiveWorkbenchPage()

					.getOpenInternalPerspectives();

			boolean updateNeeded = true;

			IContextService contextService = (IContextService) getService(IContextService.class);

			try {

				contextService.activateContext(ContextAuthority.DEFER_EVENTS);

				for (int i = 0; i < perspectives.length; i++) {

					for (int j = 0; j < objects.length; j++) {

						if (objects[j] instanceof IActionSetDescriptor) {

							perspectives[i]

									.removeActionSet((IActionSetDescriptor) objects[j]);

							getActionPresentation().removeActionSet(

									(IActionSetDescriptor) objects[j]);

						}

					}

				}

			} finally {

				contextService.activateContext(ContextAuthority.SEND_EVENTS);

			}

			if (updateNeeded) {

				// refresh the window

				updateActionSets();

			}

		}

	};

	void registerGlobalAction(IAction globalAction) {

		String commandId = globalAction.getActionDefinitionId();

		if (commandId != null) {

			final Object value = globalActionHandlersByCommandId.get(commandId);

			if (value instanceof ActionHandler) {

				// This handler is about to get clobbered, so dispose it.

				final ActionHandler handler = (ActionHandler) value;

				handler.dispose();

			}

			if (globalAction instanceof CommandAction) {

				final String actionId = globalAction.getId();

				if (actionId != null) {

					final IActionCommandMappingService mappingService = (IActionCommandMappingService) serviceLocator

							.getService(IActionCommandMappingService.class);

					mappingService.map(actionId, commandId);

				}

			} else {

				globalActionHandlersByCommandId.put(commandId,

						new ActionHandler(globalAction));

			}

		}

		submitGlobalActions();

	}

	/**

	 * <p>

	 * Submits the action handlers for action set actions and global actions.

	 * Global actions are given priority, so that if a global action and an

	 * action set action both handle the same command, the global action is

	 * given priority.

	 * </p>

	 * <p>

	 * These submissions are submitted as <code>Priority.LEGACY</code>, which

	 * means that they are the lowest priority. This means that if a higher

	 * priority submission handles the same command under the same conditions,

	 * that that submission will become the handler.

	 * </p>

	 */

	void submitGlobalActions() {

		final IHandlerService handlerService = (IHandlerService) getWorkbench().getService(IHandlerService.class);

		/*

		 * Mash the action sets and global actions together, with global actions

		 * taking priority.

		 */

		Map handlersByCommandId = new HashMap();

		handlersByCommandId.putAll(globalActionHandlersByCommandId);

		List newHandlers = new ArrayList(handlersByCommandId.size());

		Iterator existingIter = handlerActivations.iterator();

		while (existingIter.hasNext()) {

			IHandlerActivation next = (IHandlerActivation) existingIter.next();

			String cmdId = next.getCommandId();

			Object handler = handlersByCommandId.get(cmdId);

			if (handler == next.getHandler()) {

				handlersByCommandId.remove(cmdId);

				newHandlers.add(next);

			} else {

				handlerService.deactivateHandler(next);

			}

		}

		final Shell shell = getShell();

		if (shell != null) {

			final Expression expression = new ActiveShellExpression(shell);

			for (Iterator iterator = handlersByCommandId.entrySet().iterator(); iterator

					.hasNext();) {

				Map.Entry entry = (Map.Entry) iterator.next();

				String commandId = (String) entry.getKey();

				IHandler handler = (IHandler) entry.getValue();

				newHandlers.add(handlerService.activateHandler(commandId,

						handler, expression));

			}

		}

		handlerActivations = newHandlers;

	}

	/**

	 * Add a generic property listener.

	 * 

	 * @param listener the listener to add

	 */

	public void addPropertyChangeListener(IPropertyChangeListener listener) {

		genericPropertyListeners.add(listener);

	}

	/**

	 * Removes a generic property listener.

	 * 

	 * @param listener the listener to remove 

	 */

	public void removePropertyChangeListener(IPropertyChangeListener listener) {

		genericPropertyListeners.remove(listener);

	}

	private void firePropertyChanged(final String property, final Object oldValue, final Object newValue) {

		PropertyChangeEvent event = new PropertyChangeEvent(this, property, oldValue, newValue);

		Object[] listeners = genericPropertyListeners.getListeners();

		for (int i = 0; i < listeners.length; i++) {

			IPropertyChangeListener listener = (IPropertyChangeListener) listeners[i];

			listener.propertyChange(event);

		}

	}

	/*

	 * Adds an listener to the part service.

	 */

	public void addPageListener(IPageListener l) {

		pageListeners.addPageListener(l);

	}

	/**

	 * @see org.eclipse.ui.IPageService

	 */

	public void addPerspectiveListener(org.eclipse.ui.IPerspectiveListener l) {

		perspectiveListeners.addPerspectiveListener(l);

	}

	/**

	 * Configures this window to have a perspecive bar. Does nothing if it

	 * already has one.

	 */

	protected void addPerspectiveBar(int style) {

		Assert.isTrue(perspectiveSwitcher == null);

		perspectiveSwitcher = new PerspectiveSwitcher(this, topBar, style);

	}

	/**

	 * Close the window.

	 * 

	 * Assumes that busy cursor is active.

	 */

	private boolean busyClose() {

		// Whether the window was actually closed or not

		boolean 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 = getWorkbenchImpl();

			int 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 (okToClose()) {

					windowClosed = hardClose();

				}

			}

		} finally {

			if (!windowClosed) {

				// Reset the internal flags if window was not closed.

				closing = false;

				updateDisabled = false;

			}

		}

		if (windowClosed && tracker != null) {

			tracker.close();

		}

		return windowClosed;

	}

	/**

	 * 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>

	 */

	protected IWorkbenchPage busyOpenPage(String perspID, IAdaptable input)

			throws WorkbenchException {

		IWorkbenchPage newPage = null;

		if (pageList.isEmpty()) {

			newPage = ((WorkbenchImplementation) Tweaklets

					.get(WorkbenchImplementation.KEY)).createWorkbenchPage(this, perspID, input);

			pageList.add(newPage);

			firePageOpened(newPage);

			setActivePage(newPage);

		} else {

			IWorkbenchWindow window = getWorkbench().openWorkbenchWindow(

					perspID, input);

			newPage = window.getActivePage();

		}

		return newPage;

	}

	/**

	 * @see Window

	 */

	public int open() {

		if (getPages().length == 0) {

			showEmptyWindowContents();

		}

		fireWindowCreated();

// RAP [rh] Intro mechanism not supported

//		getWindowAdvisor().openIntro();

		int result = super.open();

		// It's time for a layout ... to insure that if TrimLayout

    private boolean asMaximizedState = false;

		// 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();

		fireWindowOpened();

		if (perspectiveSwitcher != null) {

			perspectiveSwitcher.updatePerspectiveBar();

			perspectiveSwitcher.updateBarParent();

		}

		return result;

	}

	/*

	 * (non-Javadoc) Method declared on Window.

	 */

	protected boolean canHandleShellCloseEvent() {

		if (!super.canHandleShellCloseEvent()) {

			return false;

		}

		// let the advisor or other interested parties

		// veto the user's explicit request to close the window

		return fireWindowShellClosing();

	}

	/**

	 * @see IWorkbenchWindow

	 */

	public boolean close() {

		final boolean[] ret = new boolean[1];

		BusyIndicator.showWhile(null, new Runnable() {

			public void run() {

				ret[0] = busyClose();

			}

		});

		return ret[0];

	}

	protected boolean isClosing() {

		return closing || getWorkbenchImpl().isClosing();

	}

	/**

	 * Return whether or not the coolbar layout is locked.

	 */

	protected boolean isCoolBarLocked() {

        ICoolBarManager cbm = getCoolBarManager2(); 

		return cbm != null && cbm.getLockLayout();

	}

	/**

    private CBanner topBar;

	 * Close all of the pages.

	 */

	private void closeAllPages() {

		// Deactivate active page.

		setActivePage(null);

		// Clone and deref all so that calls to getPages() returns

		// empty list (if call by pageClosed event handlers)

		PageList oldList = pageList;

		pageList = new PageList();

		// Close all.

		Iterator itr = oldList.iterator();

		while (itr.hasNext()) {

			WorkbenchPage page = (WorkbenchPage) itr.next();

			firePageClosed(page);

			page.dispose();

		}

		if (!closing) {

			showEmptyWindowContents();

		}

	}

	/**

	 * Save and close all of the pages.

	 */

	public void closeAllPages(boolean save) {

		if (save) {

			boolean ret = saveAllPages(true);

			if (!ret) {

				return;

			}

		}

		closeAllPages();

	}

	/**

	 * closePerspective method comment.

	 */

	protected boolean closePage(IWorkbenchPage in, boolean save) {

		// Validate the input.

		if (!pageList.contains(in)) {

			return false;

		}

		WorkbenchPage oldPage = (WorkbenchPage) in;

		// Save old perspective.

		if (save && oldPage.isSaveNeeded()) {

			if (!oldPage.saveAllEditors(true)) {

				return false;

			}

		}

		// If old page is activate deactivate.

		boolean oldIsActive = (oldPage == getActiveWorkbenchPage());

		if (oldIsActive) {

			setActivePage(null);

		}

		// Close old page.

		pageList.remove(oldPage);

		firePageClosed(oldPage);

		oldPage.dispose();

		// Activate new page.

		if (oldIsActive) {

			IWorkbenchPage newPage = pageList.getNextActive();

			if (newPage != null) {

				setActivePage(newPage);

			}

		}

		if (!closing && pageList.isEmpty()) {

			showEmptyWindowContents();

		}

		return true;

	}

	private void showEmptyWindowContents() {

		if (!emptyWindowContentsCreated) {

			Composite parent = getPageComposite();

			emptyWindowContents = getWindowAdvisor().createEmptyWindowContents(

					parent);

			emptyWindowContentsCreated = true;

			// force the empty window composite to be layed out

			((StackLayout) parent.getLayout()).topControl = emptyWindowContents;

			parent.layout();

		}

	}

	private void hideEmptyWindowContents() {

		if (emptyWindowContentsCreated) {

			if (emptyWindowContents != null) {

				emptyWindowContents.dispose();

				emptyWindowContents = null;

				getPageComposite().layout();

			}

			emptyWindowContentsCreated = false;

		}

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.window.Window#configureShell(org.eclipse.swt.widgets.Shell)

	 */

	protected void configureShell(Shell shell) {

		super.configureShell(shell);

		// RAP [bm]: detached windows

//		detachedWindowShells = new ShellPool(shell, SWT.TOOL | SWT.TITLE

//				| SWT.MAX | SWT.RESIZE | getDefaultOrientation());

		// RAPEND: [bm] 

		String title = getWindowConfigurer().basicGetTitle();

		if (title != null) {

			shell.setText(TextProcessor.process(title, TEXT_DELIMITERS)); 

		}

// RAP [rh] IWorkbench#getHelpSystem() not implemented 

    private IWindowTrim topBarTrim;

//		final IWorkbench workbench = getWorkbench();

//		workbench.getHelpSystem().setHelp(shell,

//				IWorkbenchHelpContextIds.WORKBENCH_WINDOW);

//		initializeDefaultServices();

		final IContextService contextService = (IContextService) getWorkbench().getService(IContextService.class);

		contextService.registerShell(shell, IContextService.TYPE_WINDOW);

		trackShellActivation(shell);

		trackShellResize(shell);

	}

	// RAP [bm]: detached windows

//	/* package */ShellPool getDetachedWindowPool() {

//		return detachedWindowShells;

//	}

	// RAPEND: [bm] 

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.window.ApplicationWindow#createTrimWidgets(org.eclipse.swt.widgets.Shell)

	 */

	protected void createTrimWidgets(Shell shell) {

		// do nothing -- trim widgets are created in createDefaultContents

	}

	/**

	 * Creates and remembers the client composite, under which workbench pages

	 * create their controls.

	 */

	protected Composite createPageComposite(Composite parent) {

		pageComposite = new Composite(parent, SWT.NONE);

		// use a StackLayout instead of a FillLayout (see bug 81460 [Workbench]

		// (regression) Close all perspectives, open Java perspective, layout

		// wrong)

		pageComposite.setLayout(new StackLayout());

		return pageComposite;

	}

	/**

	 * 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>.

	 */

	protected Control createContents(Composite parent) {

		// we know from Window.create that the parent is a Shell.

		getWindowAdvisor().createWindowContents((Shell) parent);

		// the page composite must be set by createWindowContents

		Assert

				.isNotNull(pageComposite,

						"createWindowContents must call configurer.createPageComposite"); //$NON-NLS-1$

		return pageComposite;

	}

	/**

	 * If the perspective bar is drawn on the top right corner of the window,

	 * then this method changes its appearance from curved to square. This

	 * should have its own preference, but for now it piggy-backs on the

	 * SHOW_TRADITIONAL_STYLE_TABS preference.

	 * 

	 * @param square

	 *            true for a square banner and false otherwise

	 */

	public void setBannerCurve(boolean square) {

		if (topBar != null) {

			topBar.setSimple(square);

		}

	}

	/**

	 * Creates the default contents and layout of the shell.

	 * 

	 * @param shell

	 *            the shell

	 */

	protected void createDefaultContents(final Shell shell) {

		defaultLayout = new TrimLayout();

		shell.setLayout(defaultLayout);

		Menu menuBar = getMenuBarManager().createMenuBar(shell);

		if (getWindowConfigurer().getShowMenuBar()) {

			shell.setMenuBar(menuBar);

		}

		// Create the CBanner widget which parents both the Coolbar

		// and the perspective switcher, and supports some configurations

		// on the left right and bottom

		topBar = new CBanner(shell, SWT.NONE);

		topBarTrim = new WindowTrimProxy(topBar,

				"org.eclipse.ui.internal.WorkbenchWindow.topBar", //$NON-NLS-1$  

				WorkbenchMessages.get().TrimCommon_Main_TrimName, SWT.NONE, true);

		// the banner gets a curve along with the new tab style

		// TODO create a dedicated preference for this

		// RAP [bm]: not needed

//		setBannerCurve(PrefUtil.getAPIPreferenceStore().getBoolean(

//				IWorkbenchPreferenceConstants.SHOW_TRADITIONAL_STYLE_TABS));

		setBannerCurve(false);

		// RAPEND: [bm] 

		CacheWrapper coolbarCacheWrapper = new CacheWrapper(topBar);

		final Control coolBar = createCoolBarControl(coolbarCacheWrapper

				.getControl());

		// need to resize the shell, not just the coolbar's immediate

		// parent, if the coolbar wants to grow or shrink

		coolBar.addListener(SWT.Resize, new Listener() {

			public void handleEvent(Event event) {

				// If the user is dragging the sash then we will need to force

				// a resize. However, if the coolbar was resized programatically

				// then everything is already layed out correctly. There is no

				// direct way to tell the difference between these cases,

				// however

				// we take advantage of the fact that dragging the sash does not

				// change the size of the shell, and only force another layout

				// if the shell size is unchanged.

				Rectangle clientArea = shell.getClientArea();

				if (lastShellSize.x == clientArea.width

						&& lastShellSize.y == clientArea.height) {

					LayoutUtil.resize(coolBar);

				}

				lastShellSize.x = clientArea.width;

				lastShellSize.y = clientArea.height;

			}

		});

		if (getWindowConfigurer().getShowCoolBar()) {

			topBar.setLeft(coolbarCacheWrapper.getControl());

		}

		createStatusLine(shell);

		fastViewBar = new FastViewBar(this);

		fastViewBar.createControl(shell);

		if (getWindowConfigurer().getShowPerspectiveBar()) {

			addPerspectiveBar(perspectiveBarStyle());

			perspectiveSwitcher.createControl(shell);

		}

		createProgressIndicator(shell);

    // Previous shell size. Used to prevent the CBanner from triggering

    // redundant layouts

    private Point lastShellSize = new Point(0, 0);

// RAP [rh] HeapStatus not supported  

    /**

//		if (getShowHeapStatus()) {

     * The composite under which workbench pages create their controls.

//			createHeapStatus(shell);

     */

//		}

    private Composite pageComposite;

		// Insert any contributed trim into the layout

		// Legacy (3.2) trim

		trimMgr2 = new TrimBarManager2(this);

		// 3.3 Trim contributions

		trimContributionMgr = new TrimContributionManager(this);

		// RAP [bm]: DnD

//		trimDropTarget = new TrimDropTarget(shell, this);

//		DragUtil.addDragTarget(shell, trimDropTarget);

//		DragUtil.addDragTarget(null, trimDropTarget);

		// RAPEND: [bm] 

		// Create the client composite area (where page content goes).

		createPageComposite(shell);

		setLayoutDataForContents();

		// System.err.println(defaultLayout.displayTrim());

	}

// RAP [rh] HeapStatus not supported 

    /**

//	/**

     * Bit flags indication which submenus (New, Show Views, ...) this window

//	 * Returns whether the heap status indicator should be shown.

     * contains. Initially none.

//	 * 

     */

//	 * @return <code>true</code> to show the heap status indicator,

    private int submenus = 0x00;

//	 *         <code>false</code> otherwise

//	 */

//	private boolean getShowHeapStatus() {

//		return // Show if the preference is set or debug option is on

//		PrefUtil.getAPIPreferenceStore().getBoolean(

//				IWorkbenchPreferenceConstants.SHOW_MEMORY_MONITOR)

//				|| Boolean.valueOf(

//						Platform.getDebugOption(PlatformUI.PLUGIN_ID

//								+ "/perf/showHeapStatus")).booleanValue(); //$NON-NLS-1$

//	}

//

//	/**

//	 * Creates the controls for the heap status indicator.

//	 * 

//	 * @param parent

//	 *            the parent composite

//	 */

//	private void createHeapStatus(Composite parent) {

//		heapStatus = new HeapStatus(parent, PrefUtil

//				.getInternalPreferenceStore());

//

//		// Subclass the trim to allow closing...

//		heapStatusTrim = new WindowTrimProxy(heapStatus,

//				"org.eclipse.ui.internal.HeapStatus", //$NON-NLS-1$

//				WorkbenchMessages.get().TrimCommon_HeapStatus_TrimName, SWT.BOTTOM

//						| SWT.TOP) {

//

//			public void handleClose() {

//				getControl().dispose();

//			}

//

//			public boolean isCloseable() {

//				return true;

//			}

//		};

//	}

    /**

	 * <p>

	 * Returns a new menu manager for this workbench window. This menu manager

	 * will just be a proxy to the new command-based menu service.

	 * </p>

	 * <p>

	 * Subclasses may override this method to customize the menu manager.

	 * </p>

	 * 

	 * @return a menu manager for this workbench window; never <code>null</code>.

	 */

	protected MenuManager createMenuManager() {

		return super.createMenuManager();

	}

	/**

	 * Set the perspective bar location

	 * 

	 * @param location

	 *            the location to place the bar

	 */

	public void setPerspectiveBarLocation(String location) {

		if (perspectiveSwitcher != null) {

			perspectiveSwitcher.setPerspectiveBarLocation(location);

		}

	}

	/**

	 * Notifies interested parties (namely the advisor) that the window is about

	 * to be opened.

	 */

	private void fireWindowOpening() {

		// let the application do further configuration

		getWindowAdvisor().preWindowOpen();

	}

	/**

	 * Notifies interested parties (namely the advisor) that the window has been

	 * restored from a previously saved state.

	 * 

	 * @throws WorkbenchException

	 *             passed through from the advisor

	 */

	void fireWindowRestored() throws WorkbenchException {

		StartupThreading.runWithWorkbenchExceptions(new StartupRunnable() {

			public void runWithException() throws Throwable {

				getWindowAdvisor().postWindowRestore();

			}

		});

	}

	/**

	 * Notifies interested parties (namely the advisor) that the window has been

	 * created.

	 */

	private void fireWindowCreated() {

		getWindowAdvisor().postWindowCreate();

	}

	/**

	 * Notifies interested parties (namely the advisor and the window listeners)

	 * that the window has been opened.

	 */

	private void fireWindowOpened() {

		getWorkbenchImpl().fireWindowOpened(this);

		getWindowAdvisor().postWindowOpen();

	}

	/**

	 * 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

	 */

	private boolean fireWindowShellClosing() {

		return getWindowAdvisor().preWindowShellClose();

	}

	/**

	 * Notifies interested parties (namely the advisor and the window listeners)

	 * that the window has been closed.

	 */

	private void fireWindowClosed() {

		// let the application do further deconfiguration

		getWindowAdvisor().postWindowClose();

		getWorkbenchImpl().fireWindowClosed(this);

	}

	/**

	 * Fires page activated

	 */

	private void firePageActivated(IWorkbenchPage 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);

			pageListeners.firePageActivated(page);

			partService.pageActivated(page);

		} finally {

			UIStats.end(UIStats.NOTIFY_PAGE_LISTENERS, page.getLabel(), label);

		}

	}

	/**

	 * Fires page closed

	 */

	private void firePageClosed(IWorkbenchPage 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

	 */

	private void firePageOpened(IWorkbenchPage 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);

		}

	}

	/**

	 * Fires perspective activated

	 */

	void firePerspectiveActivated(IWorkbenchPage page,

			IPerspectiveDescriptor perspective) {

		UIListenerLogging.logPerspectiveEvent(this, page, perspective,

				UIListenerLogging.PLE_PERSP_ACTIVATED);

		perspectiveListeners.firePerspectiveActivated(page, perspective);

	}

	/**

	 * Fires perspective deactivated.

	 */

	void firePerspectivePreDeactivate(IWorkbenchPage page,

			IPerspectiveDescriptor perspective) {

		UIListenerLogging.logPerspectiveEvent(this, page, perspective,

				UIListenerLogging.PLE_PERSP_PRE_DEACTIVATE);

		perspectiveListeners.firePerspectivePreDeactivate(page, perspective);

	}

	/**

	 * Fires perspective deactivated.

	 */

	void firePerspectiveDeactivated(IWorkbenchPage page,

			IPerspectiveDescriptor perspective) {

		UIListenerLogging.logPerspectiveEvent(this, page, perspective,

				UIListenerLogging.PLE_PERSP_DEACTIVATED);

		perspectiveListeners.firePerspectiveDeactivated(page, perspective);

	}

	/**

	 * Fires perspective changed

	 */

	public void firePerspectiveChanged(IWorkbenchPage page,

			IPerspectiveDescriptor perspective, String changeId) {

		// Some callers call this even when there is no active perspective.

		// Just ignore this case.

		if (perspective != null) {

			UIListenerLogging.logPerspectiveChangedEvent(this, page,

					perspective, null, changeId);

			perspectiveListeners.firePerspectiveChanged(page, perspective,

					changeId);

		}

	}

	/**

	 * Fires perspective changed for an affected part

	 */

	public void firePerspectiveChanged(IWorkbenchPage page,

			IPerspectiveDescriptor perspective,

			IWorkbenchPartReference partRef, String changeId) {

		// Some callers call this even when there is no active perspective.

		// Just ignore this case.

		if (perspective != null) {

			UIListenerLogging.logPerspectiveChangedEvent(this, page,

					perspective, partRef, changeId);

			perspectiveListeners.firePerspectiveChanged(page, perspective,

					partRef, changeId);

		}

	}

	/**

	 * Fires perspective closed

	 */

	void firePerspectiveClosed(IWorkbenchPage page,

			IPerspectiveDescriptor perspective) {

		UIListenerLogging.logPerspectiveEvent(this, page, perspective,

				UIListenerLogging.PLE_PERSP_CLOSED);

		perspectiveListeners.firePerspectiveClosed(page, perspective);

	}

	/**

	 * Fires perspective opened

	 */

	void firePerspectiveOpened(IWorkbenchPage page,

			IPerspectiveDescriptor perspective) {

		UIListenerLogging.logPerspectiveEvent(this, page, perspective,

				UIListenerLogging.PLE_PERSP_OPENED);

		perspectiveListeners.firePerspectiveOpened(page, perspective);

	}

	/**

	 * Fires perspective saved as.

	 */

	void firePerspectiveSavedAs(IWorkbenchPage page,

			IPerspectiveDescriptor oldPerspective,

			IPerspectiveDescriptor newPerspective) {

		UIListenerLogging.logPerspectiveSavedAs(this, page, oldPerspective,

				newPerspective);

		perspectiveListeners.firePerspectiveSavedAs(page, oldPerspective,

				newPerspective);

	}

	/**

	 * Returns the action bars for this window.

	 */

	public WWinActionBars getActionBars() {

		if (actionBars == null) {

			actionBars = new WWinActionBars(this);

		}

		return actionBars;

	}

	/**

	 * Returns the active page.

	 * 

	 * @return the active page

	 */

	public IWorkbenchPage getActivePage() {

		return pageList.getActive();

	}

	/**

	 * Returns the active workbench page.

	 * 

	 * @return the active workbench page

	 */

	/* package */

	WorkbenchPage getActiveWorkbenchPage() {

		return pageList.getActive();

	}

	/**

	 * Returns the page composite, under which the window's pages create their

	 * controls.

	 */

	protected Composite getPageComposite() {

		return pageComposite;

	}

	/**

	 * Answer the menu manager for this window.

	 */

	public MenuManager getMenuManager() {

		return getMenuBarManager();

	}

	/**

	 * Returns the number. This corresponds to a page number in a window or a

	 * window number in the workbench.

	 */

	public int getNumber() {

		return number;

	}

	/**

	 * Returns an array of the pages in the workbench window.

	 * 

	 * @return an array of pages

	 */

	public IWorkbenchPage[] getPages() {

		return pageList.getPages();

	}

	/**

	 * @see IWorkbenchWindow

	 */

	public IPartService getPartService() {

		return partService;

	}

	/**

	 * Returns the layout for the shell.

	 * 

	 * @return the layout for the shell

	 */

	protected Layout getLayout() {

		return null;

	}

	/**

	 * @see IWorkbenchWindow

	 */

	public ISelectionService getSelectionService() {

		return partService.getSelectionService();

	}

	/**

	 * Returns <code>true</code> when the window's shell is activated,

	 * <code>false</code> when it's shell is deactivated

	 * 

	 * @return boolean <code>true</code> when shell activated,

	 *         <code>false</code> when shell deactivated

	 */

	public boolean getShellActivated() {

		return shellActivated;

	}

	/**

	 * Returns the status line manager for this window (if it has one).

	 * 

	 * @return the status line manager, or <code>null</code> if this window

	 *         does not have a status line

	 * @see ApplicationWindow#addStatusLine

	 */

	public StatusLineManager getStatusLineManager() {

		return super.getStatusLineManager();

	}

	private IWindowTrim getStatusLineTrim() {

		if (statusLineTrim == null) {

			statusLineTrim = new WindowTrimProxy(

					getStatusLineManager().getControl(),

					"org.eclipse.jface.action.StatusLineManager", //$NON-NLS-1$

					WorkbenchMessages.get().TrimCommon_StatusLine_TrimName, SWT.NONE,

					true);

		}

		return statusLineTrim;

	}

	/**

	 * @see IWorkbenchWindow

	 */

	public IWorkbench getWorkbench() {

		return PlatformUI.getWorkbench();

	}

	public String getToolbarLabel(String actionSetId) {

		ActionSetRegistry registry = WorkbenchPlugin.getDefault()

				.getActionSetRegistry();

		IActionSetDescriptor actionSet = registry.findActionSet(actionSetId);

		if (actionSet != null) {

			return actionSet.getLabel();

		}

		if (IWorkbenchActionConstants.TOOLBAR_FILE

				.equalsIgnoreCase(actionSetId)) {

			return WorkbenchMessages.get().WorkbenchWindow_FileToolbar;

		}

		if (IWorkbenchActionConstants.TOOLBAR_NAVIGATE

				.equalsIgnoreCase(actionSetId)) {

			return WorkbenchMessages.get().WorkbenchWindow_NavigateToolbar;

		}

		return null;

	}

	/**

	 * Unconditionally close this window. Assumes the proper flags have been set

	 * correctly (e.i. closing and updateDisabled)

	 */

	private boolean hardClose() {

		boolean result;

		try {

			// Clear the action sets, fix for bug 27416.

            getActionPresentation().clearActionSets();

			// Remove the handler submissions. Bug 64024.

    /**

			final IWorkbench workbench = getWorkbench();

     * Object for configuring this workbench window. Lazily initialized to an

			final IHandlerService handlerService = (IHandlerService) workbench.getService(IHandlerService.class);

     * instance unique to this window.

			handlerService.deactivateHandlers(handlerActivations);

     */

			final Iterator activationItr = handlerActivations.iterator();

    private WorkbenchWindowConfigurer windowConfigurer = null;

			while (activationItr.hasNext()) {

				final IHandlerActivation activation = (IHandlerActivation) activationItr

    /**

						.next();

     * List of generic property listeners.

				activation.getHandler().dispose();

     */

			}

    private ListenerList genericPropertyListeners = new ListenerList();

			handlerActivations.clear();

			globalActionHandlersByCommandId.clear();

			// Remove the enabled submissions. Bug 64024.

			final IContextService contextService = (IContextService) workbench.getService(IContextService.class);

			contextService.unregisterShell(getShell());

			closeAllPages();

			fireWindowClosed();

			// time to wipe our 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();

			// RAP [bm]: detached windows

//			detachedWindowShells.dispose();

			// RAPEND: [bm] 

			// Bring down all of the services.

			serviceLocator.dispose();

			// Null out the progress region. Bug 64024.

			progressRegion = null;

			// RAP [bm]: 

//			// Remove drop targets

//			DragUtil.removeDragTarget(null, trimDropTarget);

//			DragUtil.removeDragTarget(getShell(), trimDropTarget);

//			trimDropTarget = null;

			// RAPEND: [bm] 

			if (trimMgr2 != null) {

				trimMgr2.dispose();

				trimMgr2 = null;

			}

			if (trimContributionMgr != null) {

				trimContributionMgr.dispose();

				trimContributionMgr = null;

			}

		} finally {

			result = super.close();

		}

		return result;

	}

	/**

	 * @see IWorkbenchWindow

	 */

	public boolean isApplicationMenu(String menuID) {

		// delegate this question to the action bar advisor

		return getActionBarAdvisor().isApplicationMenu(menuID);

	}

	/**

	 * Return whether or not the given id matches the id of the coolitems that

	 * the application creates.

	 */

	/* package */

	boolean isWorkbenchCoolItemId(String id) {

		return windowConfigurer.containsCoolItem(id);

	}

	/**

	 * Locks/unlocks the CoolBar for the workbench.

	 * 

	 * @param lock

	 *            whether the CoolBar should be locked or unlocked

	 */

	/* package */

	void lockCoolBar(boolean lock) {

        getCoolBarManager2().setLockLayout(lock);

	}

	/**

    // RAP [bm]: detached windows

	 * Makes the window visible and frontmost.

//  private ShellPool detachedWindowShells;

	 */

    // RAPEND: [bm] 

	void makeVisible() {

		Shell shell = getShell();

    static final String TEXT_DELIMITERS = TextProcessor.getDefaultDelimiters() + "-"; //$NON-NLS-1$

		if (shell != null && !shell.isDisposed()) {

			// see bug 96700 and bug 4414 for a discussion on the use of open()

			// here

			shell.open();

		}

	}

	/**

	 * 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.

	 */

	public boolean okToClose() {

		// Save all of the editors.

		if (!getWorkbenchImpl().isClosing()) {

			if (!saveAllPages(true)) {

				return false;

			}

		}

		return true;

	}

	/**

	 * Opens a new page.

	 * <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>

	 */

	public IWorkbenchPage openPage(final String perspId, final IAdaptable input)

			throws WorkbenchException {

		Assert.isNotNull(perspId);

		// Run op in busy cursor.

		final Object[] result = new Object[1];

		BusyIndicator.showWhile(null, new Runnable() {

			public void run() {

				try {

					result[0] = busyOpenPage(perspId, input);

				} catch (WorkbenchException e) {

					result[0] = e;

				}

			}

		});

		if (result[0] instanceof IWorkbenchPage) {

			return (IWorkbenchPage) result[0];

		} else if (result[0] instanceof WorkbenchException) {

			throw (WorkbenchException) result[0];

		} else {

			throw new WorkbenchException(

					WorkbenchMessages.get().WorkbenchWindow_exceptionMessage);

		}

	}

	/**

	 * Opens a new page.

	 * <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.