Attachment 14813 Details for Bug 75130 – Modified WorkbenchActionBuilder

Modified WorkbenchActionBuilder

(text/plain), 53.29 KB, created by Dan Kehn

on 2004-09-27 17:29:19 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Dan Kehn

Created: 2004-09-27 17:29:19 EDT

Size: 53.29 KB

patch

obsolete

>/*******************************************************************************
> * Copyright (c) 2000, 2004 IBM Corporation and others.
> * All rights reserved. This program and the accompanying materials 
> * are made available under the terms of the Common Public License v1.0
> * which accompanies this distribution, and is available at
> * http://www.eclipse.org/legal/cpl-v10.html
> * 
> * Contributors:
> *     IBM Corporation - initial API and implementation
> *******************************************************************************/
>package org.eclipse.ui.internal.ide;
>
>import org.eclipse.core.resources.ResourcesPlugin;
>import org.eclipse.core.runtime.Preferences;
>import org.eclipse.jface.action.ActionContributionItem;
>import org.eclipse.jface.action.GroupMarker;
>import org.eclipse.jface.action.IAction;
>import org.eclipse.jface.action.IContributionItem;
>import org.eclipse.jface.action.ICoolBarManager;
>import org.eclipse.jface.action.IMenuManager;
>import org.eclipse.jface.action.IStatusLineManager;
>import org.eclipse.jface.action.IToolBarManager;
>import org.eclipse.jface.action.MenuManager;
>import org.eclipse.jface.action.Separator;
>import org.eclipse.jface.action.ToolBarContributionItem;
>import org.eclipse.jface.action.ToolBarManager;
>import org.eclipse.jface.preference.IPreferenceStore;
>import org.eclipse.jface.util.IPropertyChangeListener;
>import org.eclipse.jface.util.PropertyChangeEvent;
>import org.eclipse.ui.IPageListener;
>import org.eclipse.ui.IPerspectiveDescriptor;
>import org.eclipse.ui.IPerspectiveListener;
>import org.eclipse.ui.IWorkbenchActionConstants;
>import org.eclipse.ui.IWorkbenchPage;
>import org.eclipse.ui.IWorkbenchWindow;
>import org.eclipse.ui.actions.ActionFactory;
>import org.eclipse.ui.actions.ContributionItemFactory;
>import org.eclipse.ui.actions.NewWizardMenu;
>import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;
>import org.eclipse.ui.application.IActionBarConfigurer;
>import org.eclipse.ui.application.IWorkbenchConfigurer;
>import org.eclipse.ui.ide.IDEActionFactory;
>import org.eclipse.ui.ide.IIDEActionConstants;
>import org.eclipse.ui.internal.IPreferenceConstants;
>import org.eclipse.ui.internal.WorkbenchPlugin;
>import org.eclipse.ui.internal.ide.actions.BuildSetMenu;
>import org.eclipse.ui.internal.ide.actions.QuickMenuAction;
>import org.eclipse.ui.internal.util.StatusLineContributionItem;
>
>/**
> * Adds actions to a workbench window.
> */
>public final class WorkbenchActionBuilder {
>	private IWorkbenchWindow window;
>
>	/** 
>	 * A convience variable and method so that the actionConfigurer doesn't need to
>	 * get passed into registerGlobalAction every time it's called.
>	 */
>	private IActionBarConfigurer actionBarConfigurer;
>	
>	
>	// generic actions
>	private IWorkbenchAction closeAction;
>	private IWorkbenchAction closeAllAction;
>	private IWorkbenchAction closeAllSavedAction;
>	private IWorkbenchAction saveAction;
>	private IWorkbenchAction saveAllAction;
>	private IWorkbenchAction helpContentsAction;
>	private IWorkbenchAction aboutAction;
>	private IWorkbenchAction openPreferencesAction;
>	private IWorkbenchAction saveAsAction;
>	private IWorkbenchAction hideShowEditorAction;
>	private IWorkbenchAction savePerspectiveAction;
>	private IWorkbenchAction resetPerspectiveAction;
>	private IWorkbenchAction editActionSetAction;
>	private IWorkbenchAction closePerspAction;
>	private IWorkbenchAction lockToolBarAction;
>	private IWorkbenchAction closeAllPerspsAction;
>	private IWorkbenchAction showViewMenuAction;
>	private IWorkbenchAction showPartPaneMenuAction;
>	private IWorkbenchAction nextPartAction;
>	private IWorkbenchAction prevPartAction;
>	private IWorkbenchAction nextEditorAction;
>	private IWorkbenchAction prevEditorAction;
>	private IWorkbenchAction nextPerspectiveAction;
>	private IWorkbenchAction prevPerspectiveAction;
>	private IWorkbenchAction activateEditorAction;
>	private IWorkbenchAction maximizePartAction;
>	private IWorkbenchAction workbenchEditorsAction;
>	private IWorkbenchAction workbookEditorsAction;
>	private IWorkbenchAction backwardHistoryAction;
>	private IWorkbenchAction forwardHistoryAction;
>
>	// generic retarget actions
>	private IWorkbenchAction undoAction;
>	private IWorkbenchAction redoAction;
>	private IWorkbenchAction cutAction;
>	private IWorkbenchAction copyAction;
>	private IWorkbenchAction pasteAction;
>	private IWorkbenchAction deleteAction;
>	private IWorkbenchAction selectAllAction;
>	private IWorkbenchAction findAction;
>	private IWorkbenchAction printAction;
>	private IWorkbenchAction revertAction;
>	private IWorkbenchAction refreshAction;
>	private IWorkbenchAction propertiesAction;
>	private IWorkbenchAction quitAction;
>	private IWorkbenchAction moveAction;
>	private IWorkbenchAction renameAction;
>	private IWorkbenchAction goIntoAction;
>	private IWorkbenchAction backAction;
>	private IWorkbenchAction forwardAction;
>	private IWorkbenchAction upAction;
>	private IWorkbenchAction nextAction;
>	private IWorkbenchAction previousAction;
>
>	// IDE-specific actions
>	private IWorkbenchAction openWorkspaceAction;
>	private IWorkbenchAction projectPropertyDialogAction;
>	private IWorkbenchAction newWizardAction;
>	private IWorkbenchAction newWizardDropDownAction;
>	private IWorkbenchAction importResourcesAction;
>	private IWorkbenchAction exportResourcesAction;
>
>	IWorkbenchAction buildAllAction; // Incremental workspace build
>	private IWorkbenchAction cleanAction;
>	private IWorkbenchAction toggleAutoBuildAction;
>	MenuManager buildWorkingSetMenu;
>	private IWorkbenchAction quickStartAction;
>	private IWorkbenchAction tipsAndTricksAction;
>	private QuickMenuAction showInQuickMenu;
>	private QuickMenuAction newQuickMenu;
>	private IWorkbenchAction introAction;
>
>	
>	// IDE-specific retarget actions
>	private IWorkbenchAction addBookmarkAction;
>	private IWorkbenchAction addTaskAction;
>	IWorkbenchAction buildProjectAction;
>	private IWorkbenchAction openProjectAction;
>	private IWorkbenchAction closeProjectAction;
>
>	// contribution items
>	// @issue should obtain from ContributionItemFactory
>	private NewWizardMenu newWizardMenu;
>	private IContributionItem pinEditorContributionItem;
>	
>	// @issue class is workbench internal
>	private StatusLineContributionItem statusLineItem;
>	
>	private Preferences.IPropertyChangeListener prefListener;
>	// listener for the "close editors automatically"
>	// preference change
>	private IPropertyChangeListener propPrefListener;
>
>    private IPageListener pageListener;
>
>    private IPerspectiveListener perspectiveListener;
>
>	
>	/**
>	 * Constructs a new action builder which contributes actions
>	 * to the given window.
>	 * 
>	 * @param window the window
>	 */
>	public WorkbenchActionBuilder(IWorkbenchWindow window) {
>		this.window = window;
>	}
>
>	/**
>	 * Returns the window to which this action builder is contributing.
>	 */
>	private IWorkbenchWindow getWindow() {
>		return window;
>	}
>	
>	/**
>	 * Hooks listeners on the preference store and the window's page, perspective and selection services.
>	 */
>	private void hookListeners() {
>
>		pageListener = new IPageListener() {
>			public void pageActivated(IWorkbenchPage page) {
>				enableActions(page.getPerspective() != null);
>			}
>			public void pageClosed(IWorkbenchPage page) {
>				IWorkbenchPage pg = getWindow().getActivePage();
>				enableActions(pg != null && pg.getPerspective() != null);
>			}
>			public void pageOpened(IWorkbenchPage page) {
>				// do nothing
>			}
>		};
>        getWindow().addPageListener(pageListener);
>
>		perspectiveListener = new IPerspectiveListener() {
>			public void perspectiveActivated(IWorkbenchPage page, IPerspectiveDescriptor perspective) {
>				enableActions(true);
>			}
>			public void perspectiveChanged(IWorkbenchPage page, IPerspectiveDescriptor perspective, String changeId) {
>				// do nothing
>			}
>		};
>        getWindow().addPerspectiveListener(perspectiveListener);
>		
>		prefListener = new Preferences.IPropertyChangeListener() {
>			public void propertyChange(Preferences.PropertyChangeEvent event) {
>				if (event.getProperty().equals(ResourcesPlugin.PREF_AUTO_BUILDING)) {
>					final boolean autoBuild = ResourcesPlugin.getWorkspace().isAutoBuilding();
>					if (window.getShell() != null && !window.getShell().isDisposed()) {
>						// this property change notification could be from a non-ui thread
>						window.getShell().getDisplay().syncExec(new Runnable() {
>							public void run() {
>								updateBuildActions(autoBuild);
>							}
>						});
>					}
>				}
>			}
>		};
>		ResourcesPlugin.getPlugin().getPluginPreferences().addPropertyChangeListener(prefListener);
>		
>		// listener for the "close editors automatically"
>		// preference change
>		propPrefListener = new IPropertyChangeListener() {
>			public void propertyChange(PropertyChangeEvent event) {
>				if (event.getProperty().equals(IPreferenceConstants.REUSE_EDITORS_BOOLEAN)) {
>					if (window.getShell() != null && !window.getShell().isDisposed()) {
>						// this property change notification could be from a non-ui thread
>						window.getShell().getDisplay().syncExec(new Runnable() {
>							public void run() {
>								updatePinActionToolbar();
>							}
>						});
>					}
>				}
>			}
>		};
>		/*
>		 * In order to ensure that the pin action toolbar sets its size 
>		 * correctly, the pin action should set its visiblity before we call updatePinActionToolbar().
>		 * 
>		 * In other words we always want the PinActionContributionItem to be notified before the 
>		 * WorkbenchActionBuilder.
>		 */
>		WorkbenchPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(propPrefListener);
>	}
>
>	/**
>	 * Enables the menu items dependent on an active
>	 * page and perspective.
>	 * Note, the show view action already does its own 
>	 * listening so no need to do it here.
>	 */
>	private void enableActions(boolean value) {
>		hideShowEditorAction.setEnabled(value);
>		savePerspectiveAction.setEnabled(value);
>		lockToolBarAction.setEnabled(value);
>		resetPerspectiveAction.setEnabled(value);
>		editActionSetAction.setEnabled(value);
>		closePerspAction.setEnabled(value);
>		closeAllPerspsAction.setEnabled(value);
>		newWizardMenu.setEnabled(value);
>		newWizardDropDownAction.setEnabled(value);
>		// Bug 53560.  "Ctrl+N" shouldn't work if the menus are all disabled.
>		newWizardAction.setEnabled(value);
>		importResourcesAction.setEnabled(value);
>		exportResourcesAction.setEnabled(value);
>	}
>	
>	/**
>	 * Builds the actions and contributes them to the given window.
>	 */
>	public void makeAndPopulateActions(IWorkbenchConfigurer windowConfigurer, IActionBarConfigurer actionBarConfigurer) {
>		makeActions(windowConfigurer, actionBarConfigurer);
>		populateMenuBar(actionBarConfigurer);
>		populateCoolBar(actionBarConfigurer);
>		updateBuildActions(ResourcesPlugin.getWorkspace().isAutoBuilding());
>		populateStatusLine(actionBarConfigurer);
>		hookListeners();
>	}
>	
>	
>	/**
>	 * Fills the coolbar with the workbench actions.
>	 */
>	public void populateCoolBar(IActionBarConfigurer configurer) {
>		ICoolBarManager cbManager = configurer.getCoolBarManager();
>		
>		{ // Set up the context Menu
>			IMenuManager popUpMenu = new MenuManager();
>			popUpMenu.add(new ActionContributionItem(lockToolBarAction));
>			popUpMenu.add(new ActionContributionItem(editActionSetAction));
>			cbManager.setContextMenuManager(popUpMenu);
>		}
>		cbManager.add(new GroupMarker(IIDEActionConstants.GROUP_FILE));
>		{ // File Group
>			IToolBarManager fileToolBar = new ToolBarManager(cbManager.getStyle());
>			fileToolBar.add(new Separator(IWorkbenchActionConstants.NEW_GROUP));
>			fileToolBar.add(newWizardDropDownAction);
>			fileToolBar.add(new GroupMarker(IWorkbenchActionConstants.NEW_EXT));
>			fileToolBar.add(new GroupMarker(IWorkbenchActionConstants.SAVE_GROUP));
>			fileToolBar.add(saveAction);
>			fileToolBar.add(new GroupMarker(IWorkbenchActionConstants.SAVE_EXT));
>			fileToolBar.add(printAction);
>			fileToolBar.add(new GroupMarker(IWorkbenchActionConstants.PRINT_EXT));
>			
>			fileToolBar.add(new Separator(IWorkbenchActionConstants.BUILD_GROUP));	
>			fileToolBar.add(new GroupMarker(IWorkbenchActionConstants.BUILD_EXT));
>			fileToolBar.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
>			
>			// Add to the cool bar manager
>			cbManager.add(new ToolBarContributionItem(fileToolBar,IWorkbenchActionConstants.TOOLBAR_FILE));
>		}
>		
>		cbManager.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
>		
>		cbManager.add(new GroupMarker(IIDEActionConstants.GROUP_NAV));
>		{ // Navigate group
>			IToolBarManager navToolBar = new ToolBarManager(cbManager.getStyle());
>			navToolBar.add(new Separator(IWorkbenchActionConstants.HISTORY_GROUP));
>			navToolBar.add(new GroupMarker(IWorkbenchActionConstants.GROUP_APP));
>			navToolBar.add(backwardHistoryAction);
>			navToolBar.add(forwardHistoryAction);
>			navToolBar.add(new Separator(IWorkbenchActionConstants.PIN_GROUP));
>			navToolBar.add(pinEditorContributionItem);
>			
>			// Add to the cool bar manager
>			cbManager.add(new ToolBarContributionItem(navToolBar,IWorkbenchActionConstants.TOOLBAR_NAVIGATE));
>		}
>		
>		cbManager.add(new GroupMarker(IWorkbenchActionConstants.GROUP_EDITOR));
>		
>	}
>	
>	
>	
>	/**
>	 * Fills the menu bar with the workbench actions.
>	 */
>	public void populateMenuBar(IActionBarConfigurer configurer) {		
>		IMenuManager menubar = configurer.getMenuManager();
>		menubar.add(createFileMenu());
>		menubar.add(createEditMenu());
>		menubar.add(createNavigateMenu());
>		menubar.add(createProjectMenu());
>		menubar.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
>		menubar.add(createWindowMenu());
>		menubar.add(createHelpMenu());
>	}
>	
>	/**
>	 * Creates and returns the File menu.
>	 */
>	private MenuManager createFileMenu() {
>		MenuManager menu = new MenuManager(IDEWorkbenchMessages.getString("Workbench.file"), IWorkbenchActionConstants.M_FILE); //$NON-NLS-1$
>		menu.add(new GroupMarker(IWorkbenchActionConstants.FILE_START));
>		{
>			// create the New submenu, using the same id for it as the New action
>		    String newText = IDEWorkbenchMessages.getString("Workbench.new"); //$NON-NLS-1$
>		    String newId = ActionFactory.NEW.getId();
>			MenuManager newMenu = new MenuManager(newText, newId) {
>				public String getMenuText() {
>					String result= super.getMenuText();
>					if (newQuickMenu == null)
>					    return result;
>					String shortCut = newQuickMenu.getShortCutString();
>					if (shortCut == null)
>						return result;
>					return result + "\t" + shortCut; //$NON-NLS-1$
>				}
>			};
>			newMenu.add(new Separator(newId));
>			this.newWizardMenu = new NewWizardMenu(getWindow());
>			newMenu.add(this.newWizardMenu);
>			newMenu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
>			menu.add(newMenu);
>		}
>
>		menu.add(new GroupMarker(IWorkbenchActionConstants.NEW_EXT));
>		menu.add(new Separator());
>
>		menu.add(closeAction);
>		menu.add(closeAllAction);
>		//		menu.add(closeAllSavedAction);
>		menu.add(new GroupMarker(IWorkbenchActionConstants.CLOSE_EXT));
>		menu.add(new Separator());
>		menu.add(saveAction);
>		menu.add(saveAsAction);
>		menu.add(saveAllAction);
>
>		menu.add(revertAction);
>		menu.add(new Separator());
>		menu.add(moveAction);
>		menu.add(renameAction);
>		menu.add(refreshAction);
>
>		menu.add(new GroupMarker(IWorkbenchActionConstants.SAVE_EXT));
>		menu.add(new Separator());
>		menu.add(printAction);
>		menu.add(new GroupMarker(IWorkbenchActionConstants.PRINT_EXT));
>		menu.add(new Separator());
>		menu.add(openWorkspaceAction);
>		menu.add(new GroupMarker(IWorkbenchActionConstants.OPEN_EXT));
>		menu.add(new Separator());
>		menu.add(importResourcesAction);
>		menu.add(exportResourcesAction);
>		menu.add(new GroupMarker(IWorkbenchActionConstants.IMPORT_EXT));
>		menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
>
>		menu.add(new Separator());
>		menu.add(propertiesAction);
>
>		menu.add(ContributionItemFactory.REOPEN_EDITORS.create(getWindow()));
>		menu.add(new GroupMarker(IWorkbenchActionConstants.MRU));
>		menu.add(new Separator());
>		menu.add(quitAction);
>		menu.add(new GroupMarker(IWorkbenchActionConstants.FILE_END));
>		return menu;
>	}
>
>	/**
>	 * Creates and returns the Edit menu.
>	 */
>	private MenuManager createEditMenu() {
>		MenuManager menu = new MenuManager(IDEWorkbenchMessages.getString("Workbench.edit"), IWorkbenchActionConstants.M_EDIT); //$NON-NLS-1$
>		menu.add(new GroupMarker(IWorkbenchActionConstants.EDIT_START));
>
>		menu.add(undoAction);
>		menu.add(redoAction);
>		menu.add(new GroupMarker(IWorkbenchActionConstants.UNDO_EXT));
>		menu.add(new Separator());
>
>		menu.add(cutAction);
>		menu.add(copyAction);
>		menu.add(pasteAction);
>		menu.add(new GroupMarker(IWorkbenchActionConstants.CUT_EXT));
>		menu.add(new Separator());
>
>		menu.add(deleteAction);
>		menu.add(selectAllAction);
>		menu.add(new Separator());
>
>		menu.add(findAction);
>		menu.add(new GroupMarker(IWorkbenchActionConstants.FIND_EXT));
>		menu.add(new Separator());
>
>		menu.add(addBookmarkAction);
>		menu.add(addTaskAction);
>		menu.add(new GroupMarker(IWorkbenchActionConstants.ADD_EXT));
>
>		menu.add(new GroupMarker(IWorkbenchActionConstants.EDIT_END));
>		menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
>		return menu;
>	}
>
>	/**
>	 * Creates and returns the Navigate menu.
>	 */
>	private MenuManager createNavigateMenu() {
>		MenuManager menu = new MenuManager(IDEWorkbenchMessages.getString("Workbench.navigate"), IWorkbenchActionConstants.M_NAVIGATE); //$NON-NLS-1$
>		menu.add(new GroupMarker(IWorkbenchActionConstants.NAV_START));
>		menu.add(goIntoAction);
>
>		MenuManager goToSubMenu = new MenuManager(IDEWorkbenchMessages.getString("Workbench.goTo"), IWorkbenchActionConstants.GO_TO); //$NON-NLS-1$
>		menu.add(goToSubMenu);
>		goToSubMenu.add(backAction);
>		goToSubMenu.add(forwardAction);
>		goToSubMenu.add(upAction);
>		goToSubMenu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
>
>		menu.add(new Separator(IWorkbenchActionConstants.OPEN_EXT));
>		for (int i = 2; i < 5; ++i) {
>			menu.add(new Separator(IWorkbenchActionConstants.OPEN_EXT + i));
>		}
>		menu.add(new Separator(IWorkbenchActionConstants.SHOW_EXT));
>		{
>		
>			MenuManager showInSubMenu = new MenuManager(IDEWorkbenchMessages.getString("Workbench.showIn"), "showIn") {  //$NON-NLS-1$ //$NON-NLS-2$
>				public String getMenuText() {
>					String result= super.getMenuText();
>					if (showInQuickMenu == null)
>					    return null;
>					String shortCut= showInQuickMenu.getShortCutString();
>					if (shortCut == null)
>						return result;
>					return result + "\t" + shortCut; //$NON-NLS-1$
>				}
>			};
>			showInSubMenu.add(ContributionItemFactory.VIEWS_SHOW_IN.create(getWindow()));
>			menu.add(showInSubMenu);
>		}
>		for (int i = 2; i < 5; ++i) {
>			menu.add(new Separator(IWorkbenchActionConstants.SHOW_EXT + i));
>		}
>		menu.add(new Separator());
>		menu.add(nextAction);
>		menu.add(previousAction);
>		menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
>		menu.add(new GroupMarker(IWorkbenchActionConstants.NAV_END));
>
>		//TBD: Location of this actions
>		menu.add(new Separator());
>		menu.add(backwardHistoryAction);
>		menu.add(forwardHistoryAction);
>		return menu;
>	}
>
>	/**
>	 * Creates and returns the Project menu.
>	 */
>	private MenuManager createProjectMenu() {
>		MenuManager menu = new MenuManager(IDEWorkbenchMessages.getString("Workbench.project"), IWorkbenchActionConstants.M_PROJECT); //$NON-NLS-1$
>		menu.add(new Separator(IWorkbenchActionConstants.PROJ_START));
>
>		menu.add(openProjectAction);
>		menu.add(closeProjectAction);
>		menu.add(new GroupMarker(IWorkbenchActionConstants.OPEN_EXT));
>		menu.add(new Separator());
>		menu.add(buildAllAction);
>		menu.add(buildProjectAction);
>		addWorkingSetBuildActions(menu);
>		menu.add(cleanAction);
>		menu.add(toggleAutoBuildAction);
>		menu.add(new GroupMarker(IWorkbenchActionConstants.BUILD_EXT));
>		menu.add(new Separator());
>
>		menu.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
>		menu.add(new GroupMarker(IWorkbenchActionConstants.PROJ_END));
>		menu.add(new Separator());
>		menu.add(projectPropertyDialogAction);
>		return menu;
>	}
>
>	/**
>	 * Creates and returns the Window menu.
>	 */
>	private MenuManager createWindowMenu() {
>		MenuManager menu = new MenuManager(IDEWorkbenchMessages.getString("Workbench.window"), IWorkbenchActionConstants.M_WINDOW); //$NON-NLS-1$
>
>		IWorkbenchAction action = ActionFactory.OPEN_NEW_WINDOW.create(getWindow());
>		action.setText(IDEWorkbenchMessages.getString("Workbench.openNewWindow")); //$NON-NLS-1$
>		menu.add(action);
>		menu.add(new Separator());
>		addPerspectiveActions(menu);
>		menu.add(new Separator());
>		addKeyboardShortcuts(menu);
>		menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
>		menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS + "end")); //$NON-NLS-1$
>        menu.add(openPreferencesAction);
>                
>		menu.add(ContributionItemFactory.OPEN_WINDOWS.create(getWindow()));
>		return menu;
>	}
>
>	/**
>	 * Adds the perspective actions to the specified menu.
>	 */
>	private void addPerspectiveActions(MenuManager menu) {
>		{
>			String openText = IDEWorkbenchMessages.getString("Workbench.openPerspective"); //$NON-NLS-1$
>			MenuManager changePerspMenuMgr = new MenuManager(openText, "openPerspective"); //$NON-NLS-1$
>			IContributionItem changePerspMenuItem = 
>				ContributionItemFactory.PERSPECTIVES_SHORTLIST.create(getWindow());
>			changePerspMenuMgr.add(changePerspMenuItem);
>			menu.add(changePerspMenuMgr);
>		}
>		{
>			MenuManager showViewMenuMgr = new MenuManager(IDEWorkbenchMessages.getString("Workbench.showView"), "showView"); //$NON-NLS-1$ //$NON-NLS-2$
>			IContributionItem showViewMenu = ContributionItemFactory.VIEWS_SHORTLIST.create(getWindow());
>			showViewMenuMgr.add(showViewMenu);
>			menu.add(showViewMenuMgr);
>		}
>		menu.add(new Separator());
>		menu.add(editActionSetAction);
>		menu.add(savePerspectiveAction);
>		menu.add(resetPerspectiveAction);
>		menu.add(closePerspAction);
>		menu.add(closeAllPerspsAction);
>	}
>
>	/**
>	 * Adds the keyboard navigation submenu to the specified menu.
>	 */
>	private void addWorkingSetBuildActions(MenuManager menu) {
>		buildWorkingSetMenu= new MenuManager(IDEWorkbenchMessages.getString("Workbench.buildSet")); //$NON-NLS-1$
>		IContributionItem workingSetBuilds = new BuildSetMenu(window, actionBarConfigurer);
>		buildWorkingSetMenu.add(workingSetBuilds);
>		menu.add(buildWorkingSetMenu);
>	}
>	
>	/**
>	 * Adds the keyboard navigation submenu to the specified menu.
>	 */
>	private void addKeyboardShortcuts(MenuManager menu) {
>		MenuManager subMenu = new MenuManager(IDEWorkbenchMessages.getString("Workbench.shortcuts"), "shortcuts"); //$NON-NLS-1$ //$NON-NLS-2$
>		menu.add(subMenu);
>		subMenu.add(showPartPaneMenuAction);
>		subMenu.add(showViewMenuAction);
>		subMenu.add(new Separator());
>		subMenu.add(maximizePartAction);
>		subMenu.add(new Separator());
>		subMenu.add(activateEditorAction);
>		subMenu.add(nextEditorAction);
>		subMenu.add(prevEditorAction);
>		subMenu.add(workbookEditorsAction);
>		subMenu.add(new Separator());
>		subMenu.add(nextPartAction);
>		subMenu.add(prevPartAction);
>		subMenu.add(new Separator());
>		subMenu.add(nextPerspectiveAction);
>		subMenu.add(prevPerspectiveAction);
>	}
>	/**
>	 * Creates and returns the Help menu.
>	 */
>	private MenuManager createHelpMenu() {
>
>		MenuManager menu = new MenuManager(IDEWorkbenchMessages.getString("Workbench.help"), IWorkbenchActionConstants.M_HELP); //$NON-NLS-1$
>	    addSeparatorOrGroupMarker(menu, "group.intro"); //$NON-NLS-1$
>		// See if a welcome or intro page is specified
>		if (introAction != null)
>			menu.add(introAction);
>		else if (quickStartAction != null)
>			menu.add(quickStartAction);
>		menu.add(new GroupMarker("group.intro.ext")); //$NON-NLS-1$
>	    addSeparatorOrGroupMarker(menu, "group.main"); //$NON-NLS-1$
>		menu.add(helpContentsAction);
>		
>        // See if a tips and tricks page is specified
>		if (tipsAndTricksAction != null)
>			menu.add(tipsAndTricksAction);
>		// HELP_START should really be the first item, but it was after quickStartAction and tipsAndTricksAction in 2.1.
>		menu.add(new GroupMarker(IWorkbenchActionConstants.HELP_START));
>		menu.add(new GroupMarker("group.main.ext")); //$NON-NLS-1$
>	    addSeparatorOrGroupMarker(menu, "group.tutorials"); //$NON-NLS-1$
>	    addSeparatorOrGroupMarker(menu, "group.tools"); //$NON-NLS-1$
>	    addSeparatorOrGroupMarker(menu, "group.updates"); //$NON-NLS-1$
>		menu.add(new GroupMarker(IWorkbenchActionConstants.HELP_END));
>		addSeparatorOrGroupMarker(menu, IWorkbenchActionConstants.MB_ADDITIONS);
>		// about should always be at the bottom				
>		menu.add(new Separator("group.about")); //$NON-NLS-1$
>		menu.add(aboutAction);
>		menu.add(new GroupMarker("group.about.ext")); //$NON-NLS-1$
>		
>		/*		
>		final IMutableContextActivationService contextActivationServiceA = ContextActivationServiceFactory.getMutableContextActivationService();
>		contextActivationServiceA.setActiveContextIds(new HashSet(Collections.singletonList("A")));
>
>		final IMutableContextActivationService contextActivationServiceB = ContextActivationServiceFactory.getMutableContextActivationService();
>		contextActivationServiceB.setActiveContextIds(new HashSet(Collections.singletonList("B")));				
>		
>		menu.add(new Separator());
>		
>		menu.add(new Action("Add context A to the workbench") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchContextSupport workbenchContextSupport = (IWorkbenchContextSupport) workbench.getContextSupport();
>				workbenchContextSupport.getCompoundContextActivationService().addContextActivationService(contextActivationServiceA);
>			}
>		});
>
>		menu.add(new Action("Remove context A from the workbench") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchContextSupport workbenchContextSupport = (IWorkbenchContextSupport) workbench.getContextSupport();
>				workbenchContextSupport.getCompoundContextActivationService().removeContextActivationService(contextActivationServiceA);
>			}
>		});
>		
>		menu.add(new Action("Add context B to the workbench") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchContextSupport workbenchContextSupport = (IWorkbenchContextSupport) workbench.getContextSupport();
>				workbenchContextSupport.getCompoundContextActivationService().addContextActivationService(contextActivationServiceB);
>			}
>		});
>
>		menu.add(new Action("Remove context B from the workbench") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchContextSupport workbenchContextSupport = (IWorkbenchContextSupport) workbench.getContextSupport();
>				workbenchContextSupport.getCompoundContextActivationService().removeContextActivationService(contextActivationServiceB);
>			}
>		});
>		
>		menu.add(new Separator());
>		
>		menu.add(new Action("Add context A to the workbench page") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();
>
>				if (workbenchWindow != null) {
>					IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();
>					
>					if (workbenchPage != null) {					
>						IWorkbenchPageContextSupport workbenchPageContextSupport = (IWorkbenchPageContextSupport) workbenchPage.getContextSupport();
>						workbenchPageContextSupport.getCompoundContextActivationService().addContextActivationService(contextActivationServiceA);
>					}
>				}
>			}
>		});
>		
>		menu.add(new Action("Remove context A from the workbench page") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();
>
>				if (workbenchWindow != null) {
>					IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();
>					
>					if (workbenchPage != null) {					
>						IWorkbenchPageContextSupport workbenchPageContextSupport = (IWorkbenchPageContextSupport) workbenchPage.getContextSupport();
>						workbenchPageContextSupport.getCompoundContextActivationService().removeContextActivationService(contextActivationServiceA);
>					}
>				}
>			}
>		});		
>		
>		menu.add(new Action("Add context B to the workbench page") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();
>
>				if (workbenchWindow != null) {
>					IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();
>					
>					if (workbenchPage != null) {					
>						IWorkbenchPageContextSupport workbenchPageContextSupport = (IWorkbenchPageContextSupport) workbenchPage.getContextSupport();
>						workbenchPageContextSupport.getCompoundContextActivationService().addContextActivationService(contextActivationServiceB);
>					}
>				}
>			}
>		});
>
>		menu.add(new Action("Remove context B from the workbench page") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();
>
>				if (workbenchWindow != null) {
>					IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();
>					
>					if (workbenchPage != null) {					
>						IWorkbenchPageContextSupport workbenchPageContextSupport = (IWorkbenchPageContextSupport) workbenchPage.getContextSupport();
>						workbenchPageContextSupport.getCompoundContextActivationService().removeContextActivationService(contextActivationServiceB);
>					}
>				}
>			}
>		});
>		
>		IHandler handlerA = new IHandler() {
>			public void execute() {
>			}
>			
>			public void execute(Event event) {
>			}
>			
>			public boolean isEnabled() {
>				return false;
>			}
>		};
>		
>		IHandler handlerB = new IHandler() {
>			public void execute() {
>			}
>			
>			public void execute(Event event) {
>			}
>			
>			public boolean isEnabled() {
>				return false;
>			}
>		};		
>		
>		final IMutableCommandHandlerService commandHandlerServiceA = CommandHandlerServiceFactory.getMutableCommandHandlerService();
>		commandHandlerServiceA.setHandlersByCommandId(new HashMap(Collections.singletonMap("command", handlerA)));
>
>		final IMutableCommandHandlerService commandHandlerServiceB = CommandHandlerServiceFactory.getMutableCommandHandlerService();
>		commandHandlerServiceB.setHandlersByCommandId(new HashMap(Collections.singletonMap("command", handlerB)));				
>				
>		menu.add(new Separator());
>		
>		menu.add(new Action("Add handler A to the workbench") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchCommandSupport workbenchCommandSupport = (IWorkbenchCommandSupport) workbench.getCommandSupport();
>				workbenchCommandSupport.getCompoundCommandHandlerService().addCommandHandlerService(commandHandlerServiceA);
>			}
>		});
>
>		menu.add(new Action("Remove handler A from the workbench") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchCommandSupport workbenchCommandSupport = (IWorkbenchCommandSupport) workbench.getCommandSupport();
>				workbenchCommandSupport.getCompoundCommandHandlerService().removeCommandHandlerService(commandHandlerServiceA);
>			}
>		});
>		
>		menu.add(new Action("Add handler B to the workbench") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchCommandSupport workbenchCommandSupport = (IWorkbenchCommandSupport) workbench.getCommandSupport();
>				workbenchCommandSupport.getCompoundCommandHandlerService().addCommandHandlerService(commandHandlerServiceB);
>			}
>		});
>
>		menu.add(new Action("Remove handler B from the workbench") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchCommandSupport workbenchCommandSupport = (IWorkbenchCommandSupport) workbench.getCommandSupport();
>				workbenchCommandSupport.getCompoundCommandHandlerService().removeCommandHandlerService(commandHandlerServiceB);
>			}
>		});
>
>		menu.add(new Separator());
>		
>		menu.add(new Action("Add handler A to the workbench page") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();
>
>				if (workbenchWindow != null) {
>					IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();
>					
>					if (workbenchPage != null) {					
>						IWorkbenchPageCommandSupport workbenchPageCommandSupport = (IWorkbenchPageCommandSupport) workbenchPage.getCommandSupport();
>						workbenchPageCommandSupport.getCompoundCommandHandlerService().addCommandHandlerService(commandHandlerServiceA);
>					}
>				}
>			}
>		});
>
>		menu.add(new Action("Remove handler A from the workbench page") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();
>
>				if (workbenchWindow != null) {
>					IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();
>					
>					if (workbenchPage != null) {					
>						IWorkbenchPageCommandSupport workbenchPageCommandSupport = (IWorkbenchPageCommandSupport) workbenchPage.getCommandSupport();
>						workbenchPageCommandSupport.getCompoundCommandHandlerService().removeCommandHandlerService(commandHandlerServiceA);
>					}
>				}
>			}
>		});
>		
>		menu.add(new Action("Add handler B to the workbench page") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();
>
>				if (workbenchWindow != null) {
>					IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();
>					
>					if (workbenchPage != null) {					
>						IWorkbenchPageCommandSupport workbenchPageCommandSupport = (IWorkbenchPageCommandSupport) workbenchPage.getCommandSupport();
>						workbenchPageCommandSupport.getCompoundCommandHandlerService().addCommandHandlerService(commandHandlerServiceB);
>					}
>				}
>			}
>		});
>
>		menu.add(new Action("Remove handler B from the workbench page") {
>			public void run() {
>				IWorkbench workbench = PlatformUI.getWorkbench();
>				IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();
>
>				if (workbenchWindow != null) {
>					IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();
>					
>					if (workbenchPage != null) {					
>						IWorkbenchPageCommandSupport workbenchPageCommandSupport = (IWorkbenchPageCommandSupport) workbenchPage.getCommandSupport();
>						workbenchPageCommandSupport.getCompoundCommandHandlerService().removeCommandHandlerService(commandHandlerServiceB);
>					}
>				}
>			}
>		});
>		*/
>		
>		return menu;
>	}
>
>	/**
>	 * Adds a <code>GroupMarker</code> or <code>Separator</code> to a menu.  The 
>	 * test for whether a separator should be added is done by checking for the existence
>	 * of a preference matching the string useSeparator.MENUID.GROUPID that is set
>	 * to <code>true</code>.
>	 * 
>     * @param menu  the menu to add to
>     * @param string  the group id for the added separator or group marker
>     */
>    private void addSeparatorOrGroupMarker(MenuManager menu, String groupId) {
>        String prefId = "useSeparator." + menu.getId() + "." + groupId; //$NON-NLS-1$ //$NON-NLS-2$
>	    boolean addExtraSeparators = IDEWorkbenchPlugin.getDefault().getPreferenceStore().getBoolean(prefId);
>        if (addExtraSeparators) {
>            menu.add(new Separator(groupId));
>        }
>        else {
>            menu.add(new GroupMarker(groupId));
>        }
>    }
>
>    /**
>	 * Disposes any resources and unhooks any listeners that are no longer needed.
>	 * Called when the window is closed.
>	 */
>	public void dispose() {
>		actionBarConfigurer.getStatusLineManager().remove(statusLineItem);
>		if (pageListener != null) {
>		    window.removePageListener(pageListener);
>		    pageListener = null;
>		}
>		if (perspectiveListener == null) {
>		    window.removePerspectiveListener(perspectiveListener);
>		    perspectiveListener = null;
>		}
>		if (prefListener != null) {
>			ResourcesPlugin.getPlugin().getPluginPreferences().removePropertyChangeListener(
>				prefListener);
>			prefListener = null;
>		}
>		if (propPrefListener != null) {
>			WorkbenchPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(propPrefListener);
>			propPrefListener = null;
>		}
>		closeAction.dispose();
>		closeAllAction.dispose();
>		closeAllSavedAction.dispose();
>		saveAction.dispose();
>		saveAllAction.dispose();
>		aboutAction.dispose();
>		openPreferencesAction.dispose();
>		saveAsAction.dispose();
>		hideShowEditorAction.dispose();
>		savePerspectiveAction.dispose();
>		resetPerspectiveAction.dispose();
>		editActionSetAction.dispose();
>		closePerspAction.dispose();
>		lockToolBarAction.dispose();
>		closeAllPerspsAction.dispose();
>		showViewMenuAction.dispose();
>		showPartPaneMenuAction.dispose();
>		nextPartAction.dispose();
>		prevPartAction.dispose();
>		nextEditorAction.dispose();
>		prevEditorAction.dispose();
>		nextPerspectiveAction.dispose();
>		prevPerspectiveAction.dispose();
>		activateEditorAction.dispose();
>		maximizePartAction.dispose();
>		workbenchEditorsAction.dispose();
>		workbookEditorsAction.dispose();
>		backwardHistoryAction.dispose();
>		forwardHistoryAction.dispose();
>		undoAction.dispose();
>		redoAction.dispose();
>		cutAction.dispose();
>		copyAction.dispose();
>		pasteAction.dispose();
>		deleteAction.dispose();
>		selectAllAction.dispose();
>		findAction.dispose();
>		printAction.dispose();
>		revertAction.dispose();
>		refreshAction.dispose();
>		propertiesAction.dispose();
>		quitAction.dispose();
>		moveAction.dispose();
>		renameAction.dispose();
>		goIntoAction.dispose();
>		backAction.dispose();
>		forwardAction.dispose();
>		upAction.dispose();
>		nextAction.dispose();
>		previousAction.dispose();
>
>		// editorsDropDownAction is not currently an IWorkbenchAction		
>		// editorsDropDownAction.dispose();
>		openWorkspaceAction.dispose();
>		projectPropertyDialogAction.dispose();
>		newWizardAction.dispose();
>		newWizardDropDownAction.dispose();
>		importResourcesAction.dispose();
>		exportResourcesAction.dispose();
>		cleanAction.dispose();
>		toggleAutoBuildAction.dispose();
>		buildAllAction.dispose();
>		if (quickStartAction != null) {
>			quickStartAction.dispose();
>		}
>		if (tipsAndTricksAction != null) {
>			tipsAndTricksAction.dispose();
>		}
>		addBookmarkAction.dispose();
>		addTaskAction.dispose();
>		buildProjectAction.dispose();
>		openProjectAction.dispose();
>		closeProjectAction.dispose();
>		pinEditorContributionItem.dispose();
>		if (introAction != null) {
>		    introAction.dispose();
>		}
>		
>		showInQuickMenu.dispose();
>		newQuickMenu.dispose();
>		
>		// null out actions to make leak debugging easier
>		closeAction = null;
>		closeAllAction = null;
>		closeAllSavedAction = null;
>		saveAction = null;
>		saveAllAction = null;
>		helpContentsAction = null;
>		aboutAction = null;
>		openPreferencesAction = null;
>		saveAsAction = null;
>		hideShowEditorAction = null;
>		savePerspectiveAction = null;
>		resetPerspectiveAction = null;
>		editActionSetAction = null;
>		closePerspAction = null;
>		lockToolBarAction = null;
>		closeAllPerspsAction = null;
>		showViewMenuAction = null;
>		showPartPaneMenuAction = null;
>		nextPartAction = null;
>		prevPartAction = null;
>		nextEditorAction = null;
>		prevEditorAction = null;
>		nextPerspectiveAction = null;
>		prevPerspectiveAction = null;
>		activateEditorAction = null;
>		maximizePartAction = null;
>		workbenchEditorsAction = null;
>		workbookEditorsAction = null;
>		backwardHistoryAction = null;
>		forwardHistoryAction = null;
>		undoAction = null;
>		redoAction = null;
>		cutAction = null;
>		copyAction = null;
>		pasteAction = null;
>		deleteAction = null;
>		selectAllAction = null;
>		findAction = null;
>		printAction = null;
>		revertAction = null;
>		refreshAction = null;
>		propertiesAction = null;
>		quitAction = null;
>		moveAction = null;
>		renameAction = null;
>		goIntoAction = null;
>		backAction = null;
>		forwardAction = null;
>		upAction = null;
>		nextAction = null;
>		previousAction = null;
>		openWorkspaceAction = null;
>		projectPropertyDialogAction = null;
>		newWizardAction = null;
>		newWizardDropDownAction = null;
>		importResourcesAction = null;
>		exportResourcesAction = null;
>		buildAllAction = null;
>		cleanAction = null;
>		toggleAutoBuildAction = null;
>		buildWorkingSetMenu = null;
>		quickStartAction = null;
>		tipsAndTricksAction = null;
>		showInQuickMenu = null;
>		newQuickMenu = null;
>		addBookmarkAction = null;
>		addTaskAction = null;
>		buildProjectAction = null;
>		openProjectAction = null;
>		closeProjectAction = null;
>		newWizardMenu = null;
>		pinEditorContributionItem = null;
>		statusLineItem = null;
>		prefListener = null;
>		propPrefListener = null;
>		introAction = null;
>	}
>
>	void updateModeLine(final String text) {
>		statusLineItem.setText(text);
>	}
>
>	/**
>	 * Returns true if the menu with the given ID should
>	 * be considered as an OLE container menu. Container menus
>	 * are preserved in OLE menu merging.
>	 */
>	public boolean isContainerMenu(String menuId) {
>		if (menuId.equals(IWorkbenchActionConstants.M_FILE))
>			return true;
>		if (menuId.equals(IWorkbenchActionConstants.M_WINDOW))
>			return true;
>		return false;
>	}
>	/**
>	 * Return whether or not given id matches the id of the coolitems that
>	 * the workbench creates.
>	 */
>	public boolean isWorkbenchCoolItemId(String id) {
>		if (IWorkbenchActionConstants.TOOLBAR_FILE.equalsIgnoreCase(id)) return true;
>		if (IWorkbenchActionConstants.TOOLBAR_NAVIGATE.equalsIgnoreCase(id)) return true;
>		return false;
>	}
>
>	/**
>	 * Fills the status line with the workbench contribution items.
>	 */
>	public void populateStatusLine(IActionBarConfigurer configurer) {
>		IStatusLineManager statusLine = configurer.getStatusLineManager();
>		statusLine.add(statusLineItem);
>	}
>	
>	/**
>	 * Creates actions (and contribution items) for the menu bar, toolbar and status line.
>	 */
>	private void makeActions(IWorkbenchConfigurer workbenchConfigurer, IActionBarConfigurer actionBarConfigurer) {
>
>		// The actions in jface do not have menu vs. enable, vs. disable vs. color
>		// There are actions in here being passed the workbench - problem 
>		setCurrentActionBarConfigurer(actionBarConfigurer);
>		
>		// @issue should obtain from ConfigurationItemFactory
>		statusLineItem = new StatusLineContributionItem("ModeContributionItem"); //$NON-NLS-1$
>		
>		newWizardAction = ActionFactory.NEW.create(getWindow());
>		registerGlobalAction(newWizardAction);
>
>		newWizardDropDownAction = IDEActionFactory.NEW_WIZARD_DROP_DOWN.create(getWindow());
>
>		importResourcesAction = ActionFactory.IMPORT.create(getWindow());
>		registerGlobalAction(importResourcesAction);
>
>		exportResourcesAction = ActionFactory.EXPORT.create(getWindow());
>		registerGlobalAction(exportResourcesAction);
>		
>		buildAllAction = IDEActionFactory.BUILD.create(getWindow());
>		registerGlobalAction(buildAllAction);
>
>		cleanAction = IDEActionFactory.BUILD_CLEAN.create(getWindow());
>		registerGlobalAction(cleanAction);
>
>		toggleAutoBuildAction = IDEActionFactory.BUILD_AUTOMATICALLY.create(getWindow());
>		registerGlobalAction(toggleAutoBuildAction);
>
>		saveAction = ActionFactory.SAVE.create(getWindow());
>		registerGlobalAction(saveAction);
>
>		saveAsAction = ActionFactory.SAVE_AS.create(getWindow());
>		registerGlobalAction(saveAsAction);
>
>		saveAllAction = ActionFactory.SAVE_ALL.create(getWindow());
>		registerGlobalAction(saveAllAction);
>		
>		undoAction = ActionFactory.UNDO.create(getWindow());
>		registerGlobalAction(undoAction);
>
>		redoAction = ActionFactory.REDO.create(getWindow());
>		registerGlobalAction(redoAction);
>
>		cutAction = ActionFactory.CUT.create(getWindow());
>		registerGlobalAction(cutAction);
>
>		copyAction = ActionFactory.COPY.create(getWindow());
>		registerGlobalAction(copyAction);
>
>		pasteAction = ActionFactory.PASTE.create(getWindow());
>		registerGlobalAction(pasteAction);
>
>		printAction = ActionFactory.PRINT.create(getWindow());
>		registerGlobalAction(printAction);
>
>		selectAllAction = ActionFactory.SELECT_ALL.create(getWindow());
>		registerGlobalAction(selectAllAction);
>		
>		findAction = ActionFactory.FIND.create(getWindow());
>		registerGlobalAction(findAction);
>
>		closeAction = ActionFactory.CLOSE.create(getWindow());
>		registerGlobalAction(closeAction);
>
>		closeAllAction = ActionFactory.CLOSE_ALL.create(getWindow());
>		registerGlobalAction(closeAllAction);
>
>		closeAllSavedAction = ActionFactory.CLOSE_ALL_SAVED.create(getWindow());
>		registerGlobalAction(closeAllSavedAction);
>
>		helpContentsAction = ActionFactory.HELP_CONTENTS.create(getWindow());
>		registerGlobalAction(helpContentsAction);
>
>		aboutAction = ActionFactory.ABOUT.create(getWindow());
>		aboutAction
>				.setImageDescriptor(IDEInternalWorkbenchImages
>				        .getImageDescriptor(IDEInternalWorkbenchImages.IMG_OBJS_DEFAULT_PROD));
>		registerGlobalAction(aboutAction);
>
>		openPreferencesAction = ActionFactory.PREFERENCES.create(getWindow());
>		registerGlobalAction(openPreferencesAction);
>
>		addBookmarkAction = IDEActionFactory.BOOKMARK.create(getWindow());
>		registerGlobalAction(addBookmarkAction);
>
>		addTaskAction = IDEActionFactory.ADD_TASK.create(getWindow());
>		registerGlobalAction(addTaskAction);
>
>		deleteAction = ActionFactory.DELETE.create(getWindow());
>		registerGlobalAction(deleteAction);
>
>		//FIXME dbk performance optimization - don't read ini files for about info
>		IPreferenceStore ps = IDEWorkbenchPlugin.getDefault().getPreferenceStore();
>		AboutInfo[] infos = null;		
>		if (ps.getBoolean(IDEActionFactory.QUICK_START.getId())) {
>			quickStartAction = IDEActionFactory.QUICK_START.create(getWindow());			
>		} else {
>			infos = IDEWorkbenchPlugin.getDefault().getFeatureInfos();			
>			// See if a welcome page is specified
>			for (int i = 0; i < infos.length; i++) {
>				if (infos[i].getWelcomePageURL() != null) {
>					quickStartAction = IDEActionFactory.QUICK_START.create(getWindow());
>					registerGlobalAction(quickStartAction);
>					ps.setValue(IDEActionFactory.QUICK_START.getId(), true);					
>					break;
>				}
>			}
>		}
>
>		if (ps.getBoolean(IDEActionFactory.TIPS_AND_TRICKS.getId())) {
>			tipsAndTricksAction = IDEActionFactory.TIPS_AND_TRICKS.create(getWindow());			
>		} else {
>			if (infos == null)
>				infos = IDEWorkbenchPlugin.getDefault().getFeatureInfos();
>			// See if a tips and tricks page is specified
>			for (int i = 0; i < infos.length; i++) {
>				if (infos[i].getTipsAndTricksHref() != null) {
>					tipsAndTricksAction = IDEActionFactory.TIPS_AND_TRICKS.create(getWindow());
>					registerGlobalAction(tipsAndTricksAction);
>					ps.setValue(IDEActionFactory.TIPS_AND_TRICKS.getId(), true);					
>					break;
>				}
>			}
>		}
>
>		// Actions for invisible accelerators
>		showViewMenuAction = ActionFactory.SHOW_VIEW_MENU.create(getWindow());
>		registerGlobalAction(showViewMenuAction);
>
>		showPartPaneMenuAction = ActionFactory.SHOW_PART_PANE_MENU.create(getWindow());
>		registerGlobalAction(showPartPaneMenuAction);
>
>		nextEditorAction = ActionFactory.NEXT_EDITOR.create(getWindow());
>		prevEditorAction = ActionFactory.PREVIOUS_EDITOR.create(getWindow());
>		ActionFactory.linkCycleActionPair(nextEditorAction, prevEditorAction);
>		registerGlobalAction(nextEditorAction);
>		registerGlobalAction(prevEditorAction);
>
>		nextPartAction = ActionFactory.NEXT_PART.create(getWindow());
>		prevPartAction = ActionFactory.PREVIOUS_PART.create(getWindow());
>		ActionFactory.linkCycleActionPair(nextPartAction, prevPartAction);
>		registerGlobalAction(nextPartAction);
>		registerGlobalAction(prevPartAction);
>
>		nextPerspectiveAction = ActionFactory.NEXT_PERSPECTIVE.create(getWindow());
>		prevPerspectiveAction = ActionFactory.PREVIOUS_PERSPECTIVE.create(getWindow());
>		ActionFactory.linkCycleActionPair(nextPerspectiveAction, prevPerspectiveAction);
>		registerGlobalAction(nextPerspectiveAction);
>		registerGlobalAction(prevPerspectiveAction);
>
>		activateEditorAction = ActionFactory.ACTIVATE_EDITOR.create(getWindow());
>		registerGlobalAction(activateEditorAction);
>
>		maximizePartAction = ActionFactory.MAXIMIZE.create(getWindow());
>		registerGlobalAction(maximizePartAction);
>		
>		workbenchEditorsAction = ActionFactory.SHOW_OPEN_EDITORS.create(getWindow());
>		registerGlobalAction(workbenchEditorsAction);
>		
>		workbookEditorsAction = ActionFactory.SHOW_WORKBOOK_EDITORS.create(getWindow());
>		registerGlobalAction(workbookEditorsAction);
>
>		hideShowEditorAction = ActionFactory.SHOW_EDITOR.create(getWindow());
>		registerGlobalAction(hideShowEditorAction);
>		savePerspectiveAction = ActionFactory.SAVE_PERSPECTIVE.create(getWindow());
>		registerGlobalAction(savePerspectiveAction);
>		editActionSetAction = ActionFactory.EDIT_ACTION_SETS.create(getWindow());
>		registerGlobalAction(editActionSetAction);
>		lockToolBarAction = ActionFactory.LOCK_TOOL_BAR.create(getWindow());
>		registerGlobalAction(lockToolBarAction);
>		resetPerspectiveAction = ActionFactory.RESET_PERSPECTIVE.create(getWindow());
>		registerGlobalAction(resetPerspectiveAction);
>		closePerspAction = ActionFactory.CLOSE_PERSPECTIVE.create(getWindow());
>		registerGlobalAction(closePerspAction);
>		closeAllPerspsAction = ActionFactory.CLOSE_ALL_PERSPECTIVES.create(getWindow());
>		registerGlobalAction(closeAllPerspsAction);
>
>		forwardHistoryAction = ActionFactory.FORWARD_HISTORY.create(getWindow());
>		registerGlobalAction(forwardHistoryAction);
>
>		backwardHistoryAction = ActionFactory.BACKWARD_HISTORY.create(getWindow());
>		registerGlobalAction(backwardHistoryAction);
>
>		revertAction = ActionFactory.REVERT.create(getWindow());
>		registerGlobalAction(revertAction);
>
>		refreshAction = ActionFactory.REFRESH.create(getWindow());
>		registerGlobalAction(refreshAction);
>
>		propertiesAction = ActionFactory.PROPERTIES.create(getWindow());
>		registerGlobalAction(propertiesAction);
>
>		quitAction = ActionFactory.QUIT.create(getWindow());
>		registerGlobalAction(quitAction);
>
>		moveAction = ActionFactory.MOVE.create(getWindow());
>		registerGlobalAction(moveAction);
>
>		renameAction = ActionFactory.RENAME.create(getWindow());
>		registerGlobalAction(renameAction);
>
>		goIntoAction = ActionFactory.GO_INTO.create(getWindow());
>		registerGlobalAction(goIntoAction);
>
>		backAction = ActionFactory.BACK.create(getWindow());
>		registerGlobalAction(backAction);
>
>		forwardAction = ActionFactory.FORWARD.create(getWindow());
>		registerGlobalAction(forwardAction);
>
>		upAction = ActionFactory.UP.create(getWindow());
>		registerGlobalAction(upAction);
>
>		nextAction = ActionFactory.NEXT.create(getWindow());
>		nextAction.setImageDescriptor(
>			IDEInternalWorkbenchImages.getImageDescriptor(
>				IDEInternalWorkbenchImages.IMG_ETOOL_NEXT_NAV));
>		registerGlobalAction(nextAction);
>
>		previousAction = ActionFactory.PREVIOUS.create(getWindow());
>		previousAction.setImageDescriptor(
>			IDEInternalWorkbenchImages.getImageDescriptor(
>				IDEInternalWorkbenchImages.IMG_ETOOL_PREVIOUS_NAV));
>		registerGlobalAction(previousAction);
>
>		buildProjectAction = IDEActionFactory.BUILD_PROJECT.create(getWindow());
>		registerGlobalAction(buildProjectAction);
>		
>		openProjectAction = IDEActionFactory.OPEN_PROJECT.create(getWindow());
>		registerGlobalAction(openProjectAction);
>
>		closeProjectAction = IDEActionFactory.CLOSE_PROJECT.create(getWindow());
>		registerGlobalAction(closeProjectAction);
>
>		openWorkspaceAction = IDEActionFactory.OPEN_WORKSPACE.create(getWindow());
>		registerGlobalAction(openWorkspaceAction);
>
>		projectPropertyDialogAction = IDEActionFactory.OPEN_PROJECT_PROPERTIES.create(getWindow());
>		registerGlobalAction(projectPropertyDialogAction);	
>		
>		if (getWindow().getWorkbench().getIntroManager().hasIntro()) {
>			introAction = ActionFactory.INTRO.create(window);
>			registerGlobalAction(introAction);
>		}
>		
>		final String showInQuickMenuId= "org.eclipse.ui.navigate.showInQuickMenu"; //$NON-NLS-1$
>		showInQuickMenu= new QuickMenuAction(showInQuickMenuId) { 
>			protected void fillMenu(IMenuManager menu) {
>				menu.add(ContributionItemFactory.VIEWS_SHOW_IN.create(getWindow()));
>			}
>		};
>		registerGlobalAction(showInQuickMenu);
>		
>		final String newQuickMenuId= "org.eclipse.ui.file.newQuickMenu"; //$NON-NLS-1$
>		newQuickMenu= new QuickMenuAction(newQuickMenuId) { 
>			protected void fillMenu(IMenuManager menu) {
>				menu.add(new NewWizardMenu(getWindow()));
>			}
>		};
>		registerGlobalAction(newQuickMenu);
>	
>		pinEditorContributionItem = ContributionItemFactory.PIN_EDITOR.create(getWindow());
>	}
>
>	private void setCurrentActionBarConfigurer(IActionBarConfigurer actionBarConfigurer)
>	{
>		this.actionBarConfigurer = actionBarConfigurer;
>	}
>	
>	private void registerGlobalAction(IAction action) {
>		actionBarConfigurer.registerGlobalAction(action);
>	}
>	
>	/**
>	 * Update the build actions on the toolbar and menu bar based on the 
>	 * current state of autobuild
>	 */
>	void updateBuildActions(boolean autoBuilding) {
>		//update menu bar actions in project menu
>		buildAllAction.setEnabled(!autoBuilding);
>		buildProjectAction.setEnabled(!autoBuilding);
>		toggleAutoBuildAction.setChecked(autoBuilding);
>
>		//update the cool bar build button
>		ICoolBarManager coolBarManager = actionBarConfigurer.getCoolBarManager();
>		IContributionItem cbItem = coolBarManager.find(IWorkbenchActionConstants.TOOLBAR_FILE);
>		if (!(cbItem instanceof ToolBarContributionItem)) {
>			// This should not happen
>			IDEWorkbenchPlugin.log("File toolbar contribution item is missing"); //$NON-NLS-1$
>			return;
>		}
>		ToolBarContributionItem toolBarItem = (ToolBarContributionItem)cbItem;
>		IToolBarManager toolBarManager = toolBarItem.getToolBarManager();
>		if (toolBarManager == null) {
>			// error if this happens, file toolbar assumed to always exist
>			IDEWorkbenchPlugin.log("File toolbar is missing"); //$NON-NLS-1$
>			return;
>		}
>		//add the build button if autobuild is on, and remove it otherwise
>		if (!autoBuilding) {
>			toolBarManager.appendToGroup(IWorkbenchActionConstants.BUILD_GROUP, buildAllAction);
>			toolBarManager.update(false);
>			toolBarItem.update(ICoolBarManager.SIZE);
>		} else if (buildAllAction != null) {
>			toolBarManager.remove(buildAllAction.getId());
>			toolBarManager.update(false);
>			toolBarItem.update(ICoolBarManager.SIZE);
>		}
>	}
>	
>	/**
>	 * Update the pin action's tool bar
>	 */
>	void updatePinActionToolbar() {
>		
>		ICoolBarManager coolBarManager = actionBarConfigurer.getCoolBarManager();
>		IContributionItem cbItem = coolBarManager.find(IWorkbenchActionConstants.TOOLBAR_NAVIGATE);
>		if (!(cbItem instanceof ToolBarContributionItem)) {
>			// This should not happen
>			IDEWorkbenchPlugin.log("Navigation toolbar contribution item is missing"); //$NON-NLS-1$
>			return;
>		}
>		ToolBarContributionItem toolBarItem = (ToolBarContributionItem)cbItem;
>		IToolBarManager toolBarManager = toolBarItem.getToolBarManager();
>		if (toolBarManager == null) {
>			// error if this happens, navigation toolbar assumed to always exist
>			IDEWorkbenchPlugin.log("Navigate toolbar is missing"); //$NON-NLS-1$
>			return;
>		}
>
>		toolBarManager.update(false);
>		toolBarItem.update(ICoolBarManager.SIZE);
>	}
>}

Actions: View

Attachments on bug 75130: 14813 | 14814 | 14815 | 20471 | 164820