Attachment #54208 for bug #162006




package org.eclipse.ui.internal.incubator;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.Command;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.NotEnabledException;
import org.eclipse.core.commands.NotHandledException;
import org.eclipse.core.commands.ParameterizedCommand;
import org.eclipse.core.commands.common.NotDefinedException;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.LegacyActionTools;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.SubContributionItem;
import org.eclipse.jface.bindings.Binding;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.preference.IPreferenceNode;
import org.eclipse.jface.preference.IPreferencePage;
import org.eclipse.jface.preference.PreferenceManager;
import org.eclipse.jface.preference.PreferenceNode;
import org.eclipse.jface.resource.DeviceResourceException;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.resource.LocalResourceManager;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
import org.eclipse.ui.internal.WorkbenchImages;
import org.eclipse.ui.internal.WorkbenchPlugin;
import org.eclipse.ui.internal.WorkbenchWindow;
import org.eclipse.ui.internal.actions.NewWizardShortcutAction;
import org.eclipse.ui.internal.dialogs.WorkbenchPreferenceDialog;
import org.eclipse.ui.internal.keys.BindingService;
import org.eclipse.ui.internal.progress.ProgressManagerUtil;
import org.eclipse.ui.keys.IBindingService;
import org.eclipse.ui.views.IViewDescriptor;
import org.eclipse.ui.wizards.IWizardCategory;
import org.eclipse.ui.wizards.IWizardDescriptor;

/**
 * Experimental Action for search-based navigation to UI elements such as

 */
public class CtrlEAction extends AbstractHandler {

	private static final String DIRTY_MARK = "*"; //$NON-NLS-1$

	private IWorkbenchWindow window;

	protected String rememberedText;

	protected Map previousPicksMap = new HashMap();

	private LinkedList previousPicksList = new LinkedList();

	public Object execute(ExecutionEvent executionEvent) {
		// need to get commands here because opening the popup changes which
		// commands are "handled"

		AbstractProvider[] providers = { new PreviousPicksProvider(),
				new EditorProvider(), new ViewProvider(),
				new PerspectiveProvider(), new CommandProvider(),
				new ActionProvider(), new WizardProvider(),
				new PreferenceProvider() };
			ParameterizedCommand command = binding.getParameterizedCommand();
			if (command != null && command.getCommand().isHandled()) {
				commands.add(command);
			}
		}

		window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		if (window == null) {
			return null;
		}
		FilteringInfoPopup popup = new MyInfoPopup(ProgressManagerUtil
				.getDefaultParent(), providers);
		popup.setInput(new Object());
		TreeItem[] rootItems = ((Tree) popup.getTreeViewer().getControl())
				.getItems();

	private final static class QuickAccessTreeSorter extends
			TreePathViewerSorter {
		public int compare(Viewer viewer, Object e1, Object e2) {
			AbstractElement element1 = (AbstractElement) e1;
			AbstractElement element2 = (AbstractElement) e2;
			String name1 = element1.getSortLabel();
			String name2 = element2.getSortLabel();
			return getComparator().compare(name1, name2);
		}


				return;
			}
			Object parent = parentPath.getLastSegment();
			if (parent instanceof AbstractProvider) {
				AbstractProvider provider = (AbstractProvider) parent;
				if (provider instanceof PreviousPicksProvider) {
				if (node.name.equals(IncubatorMessages.CtrlEAction_Previous)) {
					return;
				}
			}

	 * 
	 */
	private final class MyInfoPopup extends FilteringInfoPopup {
		private SortedSet commands;

		/**
		 * @param shell
		 * @param providers
		 */
		public MyInfoPopup(Shell shell, AbstractProvider[] providers) {
			super(shell, SWT.RESIZE, SWT.H_SCROLL | SWT.V_SCROLL | SWT.SINGLE,
					false);
			getTreeViewer()
					.setContentProvider(new MyContentProvider(providers));
					new MyContentProvider(MyInfoPopup.this.commands));
		}

		protected TreeViewer createTreeViewer(Composite parent, int style) {

			viewer.setComparator(new QuickAccessTreeSorter());
			return viewer;
		}

		protected void selectFirstMatch() {
			String text = getFilterText().getText();
			Object element = previousPicksMap.get(text);

			}
			super.selectFirstMatch();
		}

		protected String getMatchName(Object element) {
			if (element instanceof AbstractProvider) {
				AbstractProvider provider = (AbstractProvider) element;
				return provider.getName();
			} else if (element instanceof AbstractElement) {
				AbstractElement abstractElement = (AbstractElement) element;
				return abstractElement.getSortLabel();
			}
			return ""; //$NON-NLS-1$
		}

		protected Point getInitialSize() {

			addPreviousPick(selectedElement);
			IWorkbenchPage activePage = window.getActivePage();
			if (activePage != null) {
				if (selectedElement instanceof AbstractElement) {
					AbstractElement element = (AbstractElement) selectedElement;
					element.execute();
						activePage.showView(viewDescriptor.getId());
						return;
					} catch (PartInitException e) {
					}
				}
				if (selectedElement instanceof IPerspectiveDescriptor) {
					IPerspectiveDescriptor perspectiveDescriptor = (IPerspectiveDescriptor) selectedElement;
					activePage.setPerspective(perspectiveDescriptor);
				}
				if (selectedElement instanceof IEditorReference) {
					IEditorReference editorReference = (IEditorReference) selectedElement;
					IWorkbenchPart part = editorReference.getPart(true);
					if (part != null) {
						activePage.activate(part);
					}
					return;
				}
				if (selectedElement instanceof PreferenceNode) {
					PreferenceNode preferenceNode = (PreferenceNode) selectedElement;
					WorkbenchPreferenceDialog dialog = WorkbenchPreferenceDialog
							.createDialogOn(window.getShell(), preferenceNode
									.getId());
					dialog.open();
					return;
				}
				if (selectedElement instanceof IWizardDescriptor) {
					IWizardDescriptor wizardDescriptor = (IWizardDescriptor) selectedElement;
					NewWizardShortcutAction wizardAction = new NewWizardShortcutAction(
							window, wizardDescriptor);
					wizardAction.run();
					return;
				}
				if (selectedElement instanceof ParameterizedCommand) {
					IHandlerService handlerService = (IHandlerService) window
							.getWorkbench().getService(IHandlerService.class);
					ParameterizedCommand command = (ParameterizedCommand) selectedElement;
					try {
						handlerService.executeCommand(command, null);
					} catch (ExecutionException e) {
						e.printStackTrace();
					} catch (NotDefinedException e) {
						e.printStackTrace();
					} catch (NotEnabledException e) {
						e.printStackTrace();
					} catch (NotHandledException e) {
						e.printStackTrace();
					}
					return;
				}
				if (selectedElement instanceof ActionContributionItem) {
					ActionContributionItem item = (ActionContributionItem) selectedElement;
					item.getAction().run();
					return;
				}
			}
		}

		}
	}

	private static class Node {
		private String name;

		private String imageId;

		Node(String name, String imageId) {
			this.name = name;
			this.imageId = imageId;
		}

		public String toString() {
			return name;
		}

		/**
		 * @return
		 */
		public String getImageId() {
			return imageId;
		}
	}

	private final class MyContentProvider implements ITreeContentProvider {
		private Object input;
		private final AbstractProvider[] providers;
		private HashMap elementMap;
				IncubatorMessages.CtrlEAction_Previous, IWorkbenchGraphicConstants.IMG_OBJ_NODE);

		private Node editorNode = new Node(
				IncubatorMessages.CtrlEAction_Editors, IWorkbenchGraphicConstants.IMG_OBJ_NODE);

		private Node viewNode = new Node(IncubatorMessages.CtrlEAction_Views,
				IWorkbenchGraphicConstants.IMG_VIEW_DEFAULTVIEW_MISC);

		private Node perspectiveNode = new Node(
				IncubatorMessages.CtrlEAction_Perspectives,
				IWorkbenchGraphicConstants.IMG_ETOOL_DEF_PERSPECTIVE);

		private Node commandNode = new Node(
				IncubatorMessages.CtrlEAction_Commands, IWorkbenchGraphicConstants.IMG_OBJ_NODE);

		private Node menusNode = new Node(IncubatorMessages.CtrlEAction_Menus,
				IWorkbenchGraphicConstants.IMG_OBJ_NODE);

		private Node newNode = new Node(IncubatorMessages.CtrlEAction_New, IWorkbenchGraphicConstants.IMG_OBJ_NODE);

		private Node preferencesNode = new Node(
				IncubatorMessages.CtrlEAction_Preferences, IWorkbenchGraphicConstants.IMG_OBJ_NODE);

		private SortedSet commands;

		/**
		 * @param providers
		 */
		public MyContentProvider(AbstractProvider[] providers) {
			this.providers = providers;
			this.elementMap = new HashMap();
			for (int i = 0; i < providers.length; i++) {
				elementMap.put(providers[i], providers[i].getElements());
			}
		}

		public Object[] getChildren(Object parentElement) {
			if (parentElement instanceof AbstractProvider) {
				return (Object[]) elementMap.get(parentElement);
					return getPreviousPicks();
				} else if (editorNode.equals(parentElement)) {
					if(window.getActivePage() != null) {
						return window.getActivePage().getEditorReferences();
					}
				} else if (viewNode.equals(parentElement)) {
					return PlatformUI.getWorkbench().getViewRegistry()
							.getViews();
				} else if (perspectiveNode.equals(parentElement)) {
					return PlatformUI.getWorkbench().getPerspectiveRegistry()
							.getPerspectives();
				} else if (commandNode.equals(parentElement)) {
					return commands.toArray();
				} else if (preferencesNode.equals(parentElement)) {
					List elements = PlatformUI.getWorkbench()
							.getPreferenceManager().getElements(
									PreferenceManager.PRE_ORDER);
					Set uniqueElements = new HashSet(elements);
					return uniqueElements.toArray();
				} else if (menusNode.equals(parentElement)) {
					MenuManager menu = ((WorkbenchWindow) window)
							.getMenuBarManager();
					Set result = new HashSet();
					collectContributions(menu, result);
					return result.toArray();
				} else if (newNode.equals(parentElement)) {
					IWizardCategory rootCategory = WorkbenchPlugin.getDefault()
							.getNewWizardRegistry().getRootCategory();
					List result = new ArrayList();
					collectWizards(rootCategory, result);
					return result.toArray();
				}
			}
			if (parentElement == input) {
				return providers;
						perspectiveNode, commandNode, menusNode, newNode,
						preferencesNode };
			}
			return new Object[0];
		}

		private void collectContributions(MenuManager menu, Set result) {
			IContributionItem[] items = menu.getItems();
			for (int i = 0; i < items.length; i++) {
				IContributionItem item = items[i];
				if (item instanceof SubContributionItem) {
					item = ((SubContributionItem) item).getInnerItem();
				}
				if (item instanceof MenuManager) {
					collectContributions((MenuManager) item, result);
				} else if (item instanceof ActionContributionItem) {
					result.add(item);
				}
			}
		}

		private void collectWizards(IWizardCategory category, List result) {
			result.addAll(Arrays.asList(category.getWizards()));
			IWizardCategory[] childCategories = category.getCategories();
			for (int i = 0; i < childCategories.length; i++) {
				collectWizards(childCategories[i], result);
			}
		}

		public Object getParent(Object element) {
			return null;
		}


		public Image getImage(Object element) {
			Image image = null;
			if (element instanceof AbstractProvider) {
				AbstractProvider provider = (AbstractProvider) element;
				image = findOrCreateImage(provider.getImageDescriptor());
			} else if (element instanceof AbstractElement) {
				image = findOrCreateImage(((AbstractElement) element)
			else if (element instanceof IEditorReference) {
				IEditorReference editorReference = (IEditorReference) element;
				image = editorReference.getTitleImage();
			}
			else if (element instanceof IViewDescriptor) {
				IViewDescriptor viewDescriptor = (IViewDescriptor) element;
				image = findOrCreateImage(viewDescriptor.getImageDescriptor());
			}
			else if (element instanceof IPerspectiveDescriptor) {
				IPerspectiveDescriptor perspectiveDescriptor = (IPerspectiveDescriptor) element;
				image = findOrCreateImage(perspectiveDescriptor
						.getImageDescriptor());
			}
			else if (element instanceof IPreferenceNode) {
				IPreferenceNode preferenceNode = (IPreferenceNode) element;
				image = preferenceNode.getLabelImage();
			}
			else if (element instanceof IWizardDescriptor) {
				IWizardDescriptor wizardDescriptor = (IWizardDescriptor) element;
				image = findOrCreateImage(wizardDescriptor.getDescriptionImage());
			}
			if (image == null) {
				image = WorkbenchImages
						.getImage(IWorkbenchGraphicConstants.IMG_OBJ_ELEMENT);
			}
			return image;
		}

		}

		public String getText(Object element) {
			if (element instanceof AbstractProvider) {
				AbstractProvider provider = (AbstractProvider) element;
				return provider.getName();
			} else if (element instanceof AbstractElement) {
				AbstractElement abstractElement = (AbstractElement) element;
				return abstractElement.getLabel();
				}
				result.append(editorReference.getName());
				result.append(separator);
				result.append(editorReference.getTitleToolTip());
				return result.toString();
			}
			if (element instanceof IViewDescriptor) {
				IViewDescriptor viewDescriptor = (IViewDescriptor) element;
				return viewDescriptor.getLabel();
			}
			if (element instanceof IPerspectiveDescriptor) {
				IPerspectiveDescriptor perspectiveDescriptor = (IPerspectiveDescriptor) element;
				return perspectiveDescriptor.getLabel();
			}
			if (element instanceof IPreferenceNode) {
				IPreferenceNode preferenceNode = (IPreferenceNode) element;
				IPreferencePage page = preferenceNode.getPage();
				if (page != null && page.getDescription() != null
						&& page.getDescription().length() != 0) {
					return preferenceNode.getLabelText() + separator
							+ page.getDescription();
				}
				return preferenceNode.getLabelText();
			}
			if (element instanceof IWizardDescriptor) {
				IWizardDescriptor wizardDescriptor = (IWizardDescriptor) element;
				return wizardDescriptor.getLabel() + separator
						+ wizardDescriptor.getDescription();
			}
			if (element instanceof ActionContributionItem) {
				ActionContributionItem item = (ActionContributionItem) element;
				IAction action = item.getAction();
				if (action.getToolTipText() != null
						&& action.getToolTipText().length() != 0) {
					return LegacyActionTools.removeMnemonics(action.getText())
							+ separator + action.getToolTipText();
				}
				return LegacyActionTools.removeMnemonics(action.getText());
			}
			if (element instanceof ParameterizedCommand) {
				ParameterizedCommand command = (ParameterizedCommand) element;
				try {
					Command nestedCommand = command.getCommand();
					if (nestedCommand != null
							&& nestedCommand.getDescription() != null
							&& nestedCommand.getDescription().length() != 0) {
						return command.getName() + separator
								+ nestedCommand.getDescription();
					}
					return command.getName();
				} catch (NotDefinedException e) {
					return command.toString();
				}
			}
			return super.getText(element);
		}
	}

	/**
	 * @param element
	 */

	/**
	 * @return
	 */
	private AbstractElement[] getPreviousPicks() {
		return (AbstractElement[]) previousPicksList
				.toArray(new AbstractElement[previousPicksList.size()]);
	}

	private class PreviousPicksProvider extends AbstractProvider {

		public AbstractElement getElementForId(String id) {
			return null;
		}

		public AbstractElement[] getElements() {
			return getPreviousPicks();
		}

		public String getId() {
			return "org.eclipse.ui.previousPicks"; //$NON-NLS-1$
		}
		return elementName;
	}

		public ImageDescriptor getImageDescriptor() {
			return WorkbenchImages
					.getImageDescriptor(IWorkbenchGraphicConstants.IMG_OBJ_NODE);
		}

		public String getName() {
			return IncubatorMessages.CtrlEAction_Previous;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.SubContributionItem;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
import org.eclipse.ui.internal.WorkbenchImages;
import org.eclipse.ui.internal.WorkbenchWindow;

/**
 * @since 3.3
 * 
 */
public class ActionProvider extends AbstractProvider {

	private AbstractElement[] cachedElements;
	private Map idToElement = new HashMap();

	public String getId() {
		return "org.eclipse.ui.actions"; //$NON-NLS-1$
	}

	public AbstractElement getElementForId(String id) {
		getElements();
		return (ActionElement) idToElement.get(id);
	}

	public AbstractElement[] getElements() {
		if (cachedElements == null) {
			WorkbenchWindow window = (WorkbenchWindow) PlatformUI
					.getWorkbench().getActiveWorkbenchWindow();
			if (window != null) {
				MenuManager menu = window.getMenuManager();
				Set result = new HashSet();
				collectContributions(menu, result);
				ActionContributionItem[] actions = (ActionContributionItem[]) result
						.toArray(new ActionContributionItem[result.size()]);
				cachedElements = new AbstractElement[actions.length];
				for (int i = 0; i < actions.length; i++) {
					ActionElement actionElement = new ActionElement(actions[i]);
					cachedElements[i] = actionElement;
					idToElement.put(actionElement.getId(), actionElement);
				}
			}
		}
		return cachedElements;
	}

	private void collectContributions(MenuManager menu, Set result) {
		IContributionItem[] items = menu.getItems();
		for (int i = 0; i < items.length; i++) {
			IContributionItem item = items[i];
			if (item instanceof SubContributionItem) {
				item = ((SubContributionItem) item).getInnerItem();
			}
			if (item instanceof MenuManager) {
				collectContributions((MenuManager) item, result);
			} else if (item instanceof ActionContributionItem) {
				result.add(item);
			}
		}
	}

	public ImageDescriptor getImageDescriptor() {
		return WorkbenchImages
				.getImageDescriptor(IWorkbenchGraphicConstants.IMG_OBJ_NODE);
	}

	public String getName() {
		return IncubatorMessages.CtrlEAction_Menus;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
import org.eclipse.ui.internal.WorkbenchImages;
import org.eclipse.ui.internal.WorkbenchPlugin;
import org.eclipse.ui.wizards.IWizardCategory;
import org.eclipse.ui.wizards.IWizardDescriptor;

/**
 * @since 3.3
 * 
 */
public class WizardProvider extends AbstractProvider {

	private AbstractElement[] cachedElements;
	private Map idToElement = new HashMap();

	public AbstractElement getElementForId(String id) {
		getElements();
		return (WizardElement) idToElement.get(id);
	}

	public AbstractElement[] getElements() {
		if (cachedElements == null) {
			IWizardCategory rootCategory = WorkbenchPlugin.getDefault()
					.getNewWizardRegistry().getRootCategory();
			List result = new ArrayList();
			collectWizards(rootCategory, result);
			IWizardDescriptor[] wizards = (IWizardDescriptor[]) result
					.toArray(new IWizardDescriptor[result.size()]);
			cachedElements = new AbstractElement[wizards.length];
			for (int i = 0; i < wizards.length; i++) {
				WizardElement wizardElement = new WizardElement(wizards[i]);
				cachedElements[i] = wizardElement;
				idToElement.put(wizardElement.getId(), wizardElement);
			}
		}
		return cachedElements;
	}

	private void collectWizards(IWizardCategory category, List result) {
		result.addAll(Arrays.asList(category.getWizards()));
		IWizardCategory[] childCategories = category.getCategories();
		for (int i = 0; i < childCategories.length; i++) {
			collectWizards(childCategories[i], result);
		}
	}

	public String getId() {
		return "org.eclipse.ui.wizards"; //$NON-NLS-1$
	}

	public ImageDescriptor getImageDescriptor() {
		return WorkbenchImages
				.getImageDescriptor(IWorkbenchGraphicConstants.IMG_OBJ_NODE);
	}

	public String getName() {
		return IncubatorMessages.CtrlEAction_New;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
import org.eclipse.ui.internal.WorkbenchImages;

/**
 * @since 3.3
 * 
 */
public class PerspectiveProvider extends AbstractProvider {

	private AbstractElement[] cachedElements;
	private Map idToElement = new HashMap();

	public String getId() {
		return "org.eclipse.ui.perspectives"; //$NON-NLS-1$
	}

	public AbstractElement getElementForId(String id) {
		getElements();
		return (PerspectiveElement) idToElement.get(id);
	}

	public AbstractElement[] getElements() {
		if (cachedElements == null) {
			IPerspectiveDescriptor[] perspectives = PlatformUI.getWorkbench()
					.getPerspectiveRegistry().getPerspectives();
			cachedElements = new AbstractElement[perspectives.length];
			for (int i = 0; i < perspectives.length; i++) {
				PerspectiveElement perspectiveElement = new PerspectiveElement(
						perspectives[i]);
				cachedElements[i] = perspectiveElement;
				idToElement.put(perspectiveElement.getId(), perspectiveElement);
			}
		}
		return cachedElements;
	}

	public ImageDescriptor getImageDescriptor() {
		return WorkbenchImages
				.getImageDescriptor(IWorkbenchGraphicConstants.IMG_ETOOL_DEF_PERSPECTIVE);
	}

	public String getName() {
		return IncubatorMessages.CtrlEAction_Perspectives;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import org.eclipse.jface.resource.ImageDescriptor;

/**
 * @since 3.3
 * 
 */
public abstract class AbstractProvider {

	public abstract String getId();

	public abstract String getName();

	public abstract ImageDescriptor getImageDescriptor();

	public abstract AbstractElement[] getElements();

	public abstract AbstractElement getElementForId(String id);
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.actions.NewWizardShortcutAction;
import org.eclipse.ui.wizards.IWizardDescriptor;

/**
 * @since 3.3
 *
 */
public class WizardElement extends AbstractElement {

	private static final String separator = " - "; //$NON-NLS-1$
	
	private IWizardDescriptor wizardDescriptor;
	
	public WizardElement(IWizardDescriptor wizardDescriptor) {
		this.wizardDescriptor = wizardDescriptor;
	}
	
	public void execute() {
		IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		if(window != null) {
			NewWizardShortcutAction wizardAction = new NewWizardShortcutAction(window, wizardDescriptor);
			wizardAction.run();
		}
	}

	public String getId() {
		return wizardDescriptor.getId();
	}

	public ImageDescriptor getImageDescriptor() {
		return wizardDescriptor.getImageDescriptor();
	}

	public String getLabel() {
		return wizardDescriptor.getLabel() + separator
		+ wizardDescriptor.getDescription();
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import org.eclipse.core.commands.Command;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.NotEnabledException;
import org.eclipse.core.commands.NotHandledException;
import org.eclipse.core.commands.ParameterizedCommand;
import org.eclipse.core.commands.common.NotDefinedException;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.handlers.IHandlerService;

/**
 * @since 3.3
 *
 */
public class CommandElement extends AbstractElement {

	private static final String separator = " - "; //$NON-NLS-1$
	
	private ParameterizedCommand command;
	
	public CommandElement(ParameterizedCommand command) {
		this.command = command;
	}
	
	public void execute() {
		IWorkbenchWindow window = PlatformUI.getWorkbench()
				.getActiveWorkbenchWindow();
		if (window != null) {
			IHandlerService handlerService = (IHandlerService) window
					.getWorkbench().getService(IHandlerService.class);
			try {
				handlerService.executeCommand(command, null);
			} catch (ExecutionException e) {
				e.printStackTrace();
			} catch (NotDefinedException e) {
				e.printStackTrace();
			} catch (NotEnabledException e) {
				e.printStackTrace();
			} catch (NotHandledException e) {
				e.printStackTrace();
			}
		}
	}

	public String getId() {
		return command.getId();
	}

	public ImageDescriptor getImageDescriptor() {
		return null;
	}

	public String getLabel() {
		try {
			Command nestedCommand = command.getCommand();
			if (nestedCommand != null
					&& nestedCommand.getDescription() != null
					&& nestedCommand.getDescription().length() != 0) {
				return command.getName() + separator + nestedCommand.getDescription();
			}
			return command.getName();
		} catch (NotDefinedException e) {
			return command.toString();
		}	
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PlatformUI;

/**
 * @since 3.3
 * 
 */
public class EditorElement extends AbstractElement {

	private static final String DIRTY_MARK = "*"; //$NON-NLS-1$

	private static final String separator = " - "; //$NON-NLS-1$

	private IEditorReference editorReference;

	public EditorElement(IEditorReference editorReference) {
		this.editorReference = editorReference;
	}

	public void execute() {
		IWorkbenchPart part = editorReference.getPart(true);
		if (part != null) {
			IWorkbenchPage activePage = PlatformUI.getWorkbench()
					.getActiveWorkbenchWindow().getActivePage();
			if (activePage != null) {
				activePage.activate(part);
			}
		}
	}

	public String getId() {
		return editorReference.getId();
	}

	public ImageDescriptor getImageDescriptor() {
		return ImageDescriptor.createFromImage(editorReference.getTitleImage());
	}

	public String getLabel() {
		boolean dirty = editorReference.isDirty();
		return (dirty ? DIRTY_MARK : "") + editorReference.getName() + separator + editorReference.getTitleToolTip(); //$NON-NLS-1$
	}

	public String getSortLabel() {
		return editorReference.getTitle();
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import java.util.HashSet;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import org.eclipse.jface.preference.IPreferenceNode;
import org.eclipse.jface.preference.PreferenceManager;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
import org.eclipse.ui.internal.WorkbenchImages;

/**
 * @since 3.3
 * 
 */
public class PreferenceProvider extends AbstractProvider {

	private AbstractElement[] cachedElements;
	private Map idToElement = new HashMap();

	public String getId() {
		return "org.eclipse.ui.preferences"; //$NON-NLS-1$
	}

	public AbstractElement getElementForId(String id) {
		getElements();
		return (PreferenceElement) idToElement.get(id);
	}

	public AbstractElement[] getElements() {
		if (cachedElements == null) {
			List list = PlatformUI.getWorkbench().getPreferenceManager().getElements(PreferenceManager.PRE_ORDER);
			Set uniqueElements = new HashSet(list);
			IPreferenceNode[] preferences = (IPreferenceNode[]) uniqueElements.toArray(new IPreferenceNode[uniqueElements.size()]);
			cachedElements = new AbstractElement[preferences.length];
			for (int i = 0; i < preferences.length; i++) {
				PreferenceElement preferenceElement = new PreferenceElement(
						preferences[i]);
				cachedElements[i] = preferenceElement;
				idToElement.put(preferenceElement.getId(), preferenceElement);
			}
		}
		return cachedElements;
	}

	public ImageDescriptor getImageDescriptor() {
		return WorkbenchImages
				.getImageDescriptor(IWorkbenchGraphicConstants.IMG_OBJ_NODE);
	}

	public String getName() {
		return IncubatorMessages.CtrlEAction_Preferences;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import org.eclipse.jface.preference.IPreferenceNode;
import org.eclipse.jface.preference.IPreferencePage;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.swt.graphics.Image;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.dialogs.WorkbenchPreferenceDialog;

/**
 * @since 3.3
 *
 */
public class PreferenceElement extends AbstractElement {

	private static final String separator = " - "; //$NON-NLS-1$
	
	private IPreferenceNode preferenceNode;
	
	public PreferenceElement(IPreferenceNode preferenceNode) {
		this.preferenceNode = preferenceNode;
	}
	
	public void execute() {
		IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		if(window != null) {
			WorkbenchPreferenceDialog dialog = WorkbenchPreferenceDialog
				.createDialogOn(window.getShell(), preferenceNode
						.getId());
		dialog.open();
		}
	}

	public String getId() {
		return preferenceNode.getId();
	}

	public ImageDescriptor getImageDescriptor() {
		Image image = preferenceNode.getLabelImage();
		if(image != null) {
			ImageDescriptor descriptor = ImageDescriptor.createFromImage(image);
			return descriptor;
		}
		return null;
	}

	public String getLabel() {
		IPreferencePage page = preferenceNode.getPage();
		if (page != null && page.getDescription() != null
				&& page.getDescription().length() != 0) {
			return preferenceNode.getLabelText() + separator
					+ page.getDescription();
		}
		return preferenceNode.getLabelText();
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import java.util.HashMap;
import java.util.Map;
import java.util.SortedSet;
import java.util.TreeSet;

import org.eclipse.core.commands.ParameterizedCommand;
import org.eclipse.jface.bindings.Binding;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
import org.eclipse.ui.internal.WorkbenchImages;
import org.eclipse.ui.internal.keys.BindingService;
import org.eclipse.ui.keys.IBindingService;

/**
 * @since 3.3
 * 
 */
public class CommandProvider extends AbstractProvider {

	private AbstractElement[] cachedElements;
	private Map idToElement = new HashMap();

	public String getId() {
		return "org.eclipse.ui.commands"; //$NON-NLS-1$
	}

	public AbstractElement getElementForId(String id) {
		getElements();
		return (CommandElement) idToElement.get(id);
	}

	public AbstractElement[] getElements() {
		if (cachedElements == null) {
			BindingService bindingService = (BindingService) PlatformUI
					.getWorkbench().getService(IBindingService.class);
			Binding[] bindings = bindingService.getBindings();
			SortedSet commandSet = new TreeSet();
			for (int i = 0; i < bindings.length; i++) {
				Binding binding = bindings[i];
				ParameterizedCommand command = binding
						.getParameterizedCommand();
				if (command != null && command.getCommand().isHandled()) {
					commandSet.add(command);
				}
			}
			ParameterizedCommand[] commands = (ParameterizedCommand[]) commandSet
					.toArray(new ParameterizedCommand[commandSet.size()]);
			cachedElements = new AbstractElement[commands.length];
			for (int i = 0; i < commands.length; i++) {
				CommandElement commandElement = new CommandElement(commands[i]);
				cachedElements[i] = commandElement;
				idToElement.put(commandElement.getId(), commandElement);
			}
		}
		return cachedElements;
	}

	public ImageDescriptor getImageDescriptor() {
		return WorkbenchImages
				.getImageDescriptor(IWorkbenchGraphicConstants.IMG_OBJ_NODE);
	}

	public String getName() {
		return IncubatorMessages.CtrlEAction_Commands;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PlatformUI;

/**
 * @since 3.3
 *
 */
public class PerspectiveElement extends AbstractElement {

	private final IPerspectiveDescriptor descriptor;
	
	public PerspectiveElement(IPerspectiveDescriptor descriptor) {
		this.descriptor = descriptor;
	}
	
	public void execute() {
		IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
		if(activePage != null) {
			activePage.setPerspective(descriptor);
		}
	}
	
	public String getId() {
		return descriptor.getId();
	}
	
	public ImageDescriptor getImageDescriptor() {
		return descriptor.getImageDescriptor();
	}
	
	public String getLabel() {
		return descriptor.getLabel();
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import org.eclipse.jface.resource.ImageDescriptor;

/**
 * @since 3.3
 * 
 */
public abstract class AbstractElement {

	public abstract String getLabel();

	public abstract ImageDescriptor getImageDescriptor();

	public abstract String getId();

	public abstract void execute();
	
	public String getSortLabel() {
		return getLabel();
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
import org.eclipse.ui.internal.WorkbenchImages;

/**
 * @since 3.3
 * 
 */
public class EditorProvider extends AbstractProvider {

	private AbstractElement[] cachedElements;
	private Map idToElement = new HashMap();

	public AbstractElement getElementForId(String id) {
		getElements();
		return (EditorElement) idToElement.get(id);
	}

	public AbstractElement[] getElements() {
		if (cachedElements == null) {
			IWorkbenchPage activePage = PlatformUI.getWorkbench()
					.getActiveWorkbenchWindow().getActivePage();
			IEditorReference[] editors = activePage.getEditorReferences();
			cachedElements = new AbstractElement[editors.length];
			for (int i = 0; i < editors.length; i++) {
				EditorElement editorElement = new EditorElement(editors[i]);
				cachedElements[i] = editorElement;
				idToElement.put(editorElement.getId(), editorElement);
			}
		}
		return cachedElements;
	}

	public String getId() {
		return "org.eclipse.ui.editors"; //$NON-NLS-1$
	}

	public ImageDescriptor getImageDescriptor() {
		return WorkbenchImages
				.getImageDescriptor(IWorkbenchGraphicConstants.IMG_OBJ_NODE);
	}

	public String getName() {
		return IncubatorMessages.CtrlEAction_Editors;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
import org.eclipse.ui.internal.WorkbenchImages;
import org.eclipse.ui.views.IViewDescriptor;

/**
 * @since 3.3
 * 
 */
public class ViewProvider extends AbstractProvider {

	private AbstractElement[] cachedElements;
	private Map idToElement = new HashMap();

	public String getId() {
		return "org.eclipse.ui.views"; //$NON-NLS-1$
	}

	public AbstractElement getElementForId(String id) {
		getElements();
		return (ViewElement) idToElement.get(id);
	}

	public AbstractElement[] getElements() {
		if (cachedElements == null) {
			IViewDescriptor[] views = PlatformUI.getWorkbench()
					.getViewRegistry().getViews();
			cachedElements = new AbstractElement[views.length];
			for (int i = 0; i < views.length; i++) {
				ViewElement viewElement = new ViewElement(views[i]);
				cachedElements[i] = viewElement;
				idToElement.put(viewElement.getId(), viewElement);
			}
		}
		return cachedElements;
	}

	public ImageDescriptor getImageDescriptor() {
		return WorkbenchImages
				.getImageDescriptor(IWorkbenchGraphicConstants.IMG_VIEW_DEFAULTVIEW_MISC);
	}

	public String getName() {
		return IncubatorMessages.CtrlEAction_Views;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.LegacyActionTools;
import org.eclipse.jface.resource.ImageDescriptor;

/**
 * @since 3.3
 *
 */
public class ActionElement extends AbstractElement {

	private static final String separator = " - "; //$NON-NLS-1$
	
	private ActionContributionItem item;
	
	public ActionElement(ActionContributionItem item) {
		this.item = item;
	}
	
	public void execute() {
		item.getAction().run();
	}

	public String getId() {
		return item.getId();
	}

	public ImageDescriptor getImageDescriptor() {
		return item.getAction().getImageDescriptor();
	}

	public String getLabel() {
		IAction action = item.getAction();
		if (action.getToolTipText() != null
				&& action.getToolTipText().length() != 0) {
			return LegacyActionTools.removeMnemonics(action.getText())
					+ separator + action.getToolTipText();
		}
		return LegacyActionTools.removeMnemonics(action.getText());
	}
}







/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.incubator;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.views.IViewDescriptor;

/**
 * @since 3.3
 *
 */
public class ViewElement extends AbstractElement {

	private final IViewDescriptor viewDescriptor;
	
	public ViewElement(IViewDescriptor viewDescriptor) {
		this.viewDescriptor = viewDescriptor;
	}
	
	public void execute() {
		IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
		if(activePage != null) {
			try {
				activePage.showView(viewDescriptor.getId());
			} catch (PartInitException e) {
			}
		}
	}

	public String getId() {
		return viewDescriptor.getId();
	}

	public ImageDescriptor getImageDescriptor() {
		return viewDescriptor.getImageDescriptor();
	}

	public String getLabel() {
		return viewDescriptor.getLabel();
	}
}

Return to bug 162006

Added Link Here

(-)Eclipse (+91 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import java.util.HashMap;
15	import java.util.HashSet;
16	import java.util.Map;
17	import java.util.Set;
18
19	import org.eclipse.jface.action.ActionContributionItem;
20	import org.eclipse.jface.action.IContributionItem;
21	import org.eclipse.jface.action.MenuManager;
22	import org.eclipse.jface.action.SubContributionItem;
23	import org.eclipse.jface.resource.ImageDescriptor;
24	import org.eclipse.ui.PlatformUI;
25	import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
26	import org.eclipse.ui.internal.WorkbenchImages;
27	import org.eclipse.ui.internal.WorkbenchWindow;
28
29	/**
30	* @since 3.3
31	*
32	*/
33	public class ActionProvider extends AbstractProvider {
34
35	private AbstractElement[] cachedElements;
36	private Map idToElement = new HashMap();
37
38	public String getId() {
39	return "org.eclipse.ui.actions"; //$NON-NLS-1$
40	}
41
42	public AbstractElement getElementForId(String id) {
43	getElements();
44	return (ActionElement) idToElement.get(id);
45	}
46
47	public AbstractElement[] getElements() {
48	if (cachedElements == null) {
49	WorkbenchWindow window = (WorkbenchWindow) PlatformUI
50	.getWorkbench().getActiveWorkbenchWindow();
51	if (window != null) {
52	MenuManager menu = window.getMenuManager();
53	Set result = new HashSet();
54	collectContributions(menu, result);
55	ActionContributionItem[] actions = (ActionContributionItem[]) result
56	.toArray(new ActionContributionItem[result.size()]);
57	cachedElements = new AbstractElement[actions.length];
58	for (int i = 0; i < actions.length; i++) {
59	ActionElement actionElement = new ActionElement(actions[i]);
60	cachedElements[i] = actionElement;
61	idToElement.put(actionElement.getId(), actionElement);
62	}
63	}
64	}
65	return cachedElements;
66	}
67
68	private void collectContributions(MenuManager menu, Set result) {
69	IContributionItem[] items = menu.getItems();
70	for (int i = 0; i < items.length; i++) {
71	IContributionItem item = items[i];
72	if (item instanceof SubContributionItem) {
73	item = ((SubContributionItem) item).getInnerItem();
74	}
75	if (item instanceof MenuManager) {
76	collectContributions((MenuManager) item, result);
77	} else if (item instanceof ActionContributionItem) {
78	result.add(item);
79	}
80	}
81	}
82
83	public ImageDescriptor getImageDescriptor() {
84	return WorkbenchImages
85	.getImageDescriptor(IWorkbenchGraphicConstants.IMG_OBJ_NODE);
86	}
87
88	public String getName() {
89	return IncubatorMessages.CtrlEAction_Menus;
90	}
91	}

Added Link Here

(-)Eclipse (+79 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import java.util.ArrayList;
15	import java.util.Arrays;
16	import java.util.HashMap;
17	import java.util.List;
18	import java.util.Map;
19
20	import org.eclipse.jface.resource.ImageDescriptor;
21	import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
22	import org.eclipse.ui.internal.WorkbenchImages;
23	import org.eclipse.ui.internal.WorkbenchPlugin;
24	import org.eclipse.ui.wizards.IWizardCategory;
25	import org.eclipse.ui.wizards.IWizardDescriptor;
26
27	/**
28	* @since 3.3
29	*
30	*/
31	public class WizardProvider extends AbstractProvider {
32
33	private AbstractElement[] cachedElements;
34	private Map idToElement = new HashMap();
35
36	public AbstractElement getElementForId(String id) {
37	getElements();
38	return (WizardElement) idToElement.get(id);
39	}
40
41	public AbstractElement[] getElements() {
42	if (cachedElements == null) {
43	IWizardCategory rootCategory = WorkbenchPlugin.getDefault()
44	.getNewWizardRegistry().getRootCategory();
45	List result = new ArrayList();
46	collectWizards(rootCategory, result);
47	IWizardDescriptor[] wizards = (IWizardDescriptor[]) result
48	.toArray(new IWizardDescriptor[result.size()]);
49	cachedElements = new AbstractElement[wizards.length];
50	for (int i = 0; i < wizards.length; i++) {
51	WizardElement wizardElement = new WizardElement(wizards[i]);
52	cachedElements[i] = wizardElement;
53	idToElement.put(wizardElement.getId(), wizardElement);
54	}
55	}
56	return cachedElements;
57	}
58
59	private void collectWizards(IWizardCategory category, List result) {
60	result.addAll(Arrays.asList(category.getWizards()));
61	IWizardCategory[] childCategories = category.getCategories();
62	for (int i = 0; i < childCategories.length; i++) {
63	collectWizards(childCategories[i], result);
64	}
65	}
66
67	public String getId() {
68	return "org.eclipse.ui.wizards"; //$NON-NLS-1$
69	}
70
71	public ImageDescriptor getImageDescriptor() {
72	return WorkbenchImages
73	.getImageDescriptor(IWorkbenchGraphicConstants.IMG_OBJ_NODE);
74	}
75
76	public String getName() {
77	return IncubatorMessages.CtrlEAction_New;
78	}
79	}

Added Link Here

(-)Eclipse (+64 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import java.util.HashMap;
15	import java.util.Map;
16
17	import org.eclipse.jface.resource.ImageDescriptor;
18	import org.eclipse.ui.IPerspectiveDescriptor;
19	import org.eclipse.ui.PlatformUI;
20	import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
21	import org.eclipse.ui.internal.WorkbenchImages;
22
23	/**
24	* @since 3.3
25	*
26	*/
27	public class PerspectiveProvider extends AbstractProvider {
28
29	private AbstractElement[] cachedElements;
30	private Map idToElement = new HashMap();
31
32	public String getId() {
33	return "org.eclipse.ui.perspectives"; //$NON-NLS-1$
34	}
35
36	public AbstractElement getElementForId(String id) {
37	getElements();
38	return (PerspectiveElement) idToElement.get(id);
39	}
40
41	public AbstractElement[] getElements() {
42	if (cachedElements == null) {
43	IPerspectiveDescriptor[] perspectives = PlatformUI.getWorkbench()
44	.getPerspectiveRegistry().getPerspectives();
45	cachedElements = new AbstractElement[perspectives.length];
46	for (int i = 0; i < perspectives.length; i++) {
47	PerspectiveElement perspectiveElement = new PerspectiveElement(
48	perspectives[i]);
49	cachedElements[i] = perspectiveElement;
50	idToElement.put(perspectiveElement.getId(), perspectiveElement);
51	}
52	}
53	return cachedElements;
54	}
55
56	public ImageDescriptor getImageDescriptor() {
57	return WorkbenchImages
58	.getImageDescriptor(IWorkbenchGraphicConstants.IMG_ETOOL_DEF_PERSPECTIVE);
59	}
60
61	public String getName() {
62	return IncubatorMessages.CtrlEAction_Perspectives;
63	}
64	}

Added Link Here

(-)Eclipse (+54 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import org.eclipse.jface.resource.ImageDescriptor;
15	import org.eclipse.ui.IWorkbenchWindow;
16	import org.eclipse.ui.PlatformUI;
17	import org.eclipse.ui.internal.actions.NewWizardShortcutAction;
18	import org.eclipse.ui.wizards.IWizardDescriptor;
19
20	/**
21	* @since 3.3
22	*
23	*/
24	public class WizardElement extends AbstractElement {
25
26	private static final String separator = " - "; //$NON-NLS-1$
27
28	private IWizardDescriptor wizardDescriptor;
29
30	public WizardElement(IWizardDescriptor wizardDescriptor) {
31	this.wizardDescriptor = wizardDescriptor;
32	}
33
34	public void execute() {
35	IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
36	if(window != null) {
37	NewWizardShortcutAction wizardAction = new NewWizardShortcutAction(window, wizardDescriptor);
38	wizardAction.run();
39	}
40	}
41
42	public String getId() {
43	return wizardDescriptor.getId();
44	}
45
46	public ImageDescriptor getImageDescriptor() {
47	return wizardDescriptor.getImageDescriptor();
48	}
49
50	public String getLabel() {
51	return wizardDescriptor.getLabel() + separator
52	+ wizardDescriptor.getDescription();
53	}
54	}

Added Link Here

(-)Eclipse (+80 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import org.eclipse.core.commands.Command;
15	import org.eclipse.core.commands.ExecutionException;
16	import org.eclipse.core.commands.NotEnabledException;
17	import org.eclipse.core.commands.NotHandledException;
18	import org.eclipse.core.commands.ParameterizedCommand;
19	import org.eclipse.core.commands.common.NotDefinedException;
20	import org.eclipse.jface.resource.ImageDescriptor;
21	import org.eclipse.ui.IWorkbenchWindow;
22	import org.eclipse.ui.PlatformUI;
23	import org.eclipse.ui.handlers.IHandlerService;
24
25	/**
26	* @since 3.3
27	*
28	*/
29	public class CommandElement extends AbstractElement {
30
31	private static final String separator = " - "; //$NON-NLS-1$
32
33	private ParameterizedCommand command;
34
35	public CommandElement(ParameterizedCommand command) {
36	this.command = command;
37	}
38
39	public void execute() {
40	IWorkbenchWindow window = PlatformUI.getWorkbench()
41	.getActiveWorkbenchWindow();
42	if (window != null) {
43	IHandlerService handlerService = (IHandlerService) window
44	.getWorkbench().getService(IHandlerService.class);
45	try {
46	handlerService.executeCommand(command, null);
47	} catch (ExecutionException e) {
48	e.printStackTrace();
49	} catch (NotDefinedException e) {
50	e.printStackTrace();
51	} catch (NotEnabledException e) {
52	e.printStackTrace();
53	} catch (NotHandledException e) {
54	e.printStackTrace();
55	}
56	}
57	}
58
59	public String getId() {
60	return command.getId();
61	}
62
63	public ImageDescriptor getImageDescriptor() {
64	return null;
65	}
66
67	public String getLabel() {
68	try {
69	Command nestedCommand = command.getCommand();
70	if (nestedCommand != null
71	&& nestedCommand.getDescription() != null
72	&& nestedCommand.getDescription().length() != 0) {
73	return command.getName() + separator + nestedCommand.getDescription();
74	}
75	return command.getName();
76	} catch (NotDefinedException e) {
77	return command.toString();
78	}
79	}
80	}

Added Link Here

(-)Eclipse (+31 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import org.eclipse.jface.resource.ImageDescriptor;
15
16	/**
17	* @since 3.3
18	*
19	*/
20	public abstract class AbstractProvider {
21
22	public abstract String getId();
23
24	public abstract String getName();
25
26	public abstract ImageDescriptor getImageDescriptor();
27
28	public abstract AbstractElement[] getElements();
29
30	public abstract AbstractElement getElementForId(String id);
31	}

Added Link Here

(-)Eclipse (+63 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import org.eclipse.jface.resource.ImageDescriptor;
15	import org.eclipse.ui.IEditorReference;
16	import org.eclipse.ui.IWorkbenchPage;
17	import org.eclipse.ui.IWorkbenchPart;
18	import org.eclipse.ui.PlatformUI;
19
20	/**
21	* @since 3.3
22	*
23	*/
24	public class EditorElement extends AbstractElement {
25
26	private static final String DIRTY_MARK = "*"; //$NON-NLS-1$
27
28	private static final String separator = " - "; //$NON-NLS-1$
29
30	private IEditorReference editorReference;
31
32	public EditorElement(IEditorReference editorReference) {
33	this.editorReference = editorReference;
34	}
35
36	public void execute() {
37	IWorkbenchPart part = editorReference.getPart(true);
38	if (part != null) {
39	IWorkbenchPage activePage = PlatformUI.getWorkbench()
40	.getActiveWorkbenchWindow().getActivePage();
41	if (activePage != null) {
42	activePage.activate(part);
43	}
44	}
45	}
46
47	public String getId() {
48	return editorReference.getId();
49	}
50
51	public ImageDescriptor getImageDescriptor() {
52	return ImageDescriptor.createFromImage(editorReference.getTitleImage());
53	}
54
55	public String getLabel() {
56	boolean dirty = editorReference.isDirty();
57	return (dirty ? DIRTY_MARK : "") + editorReference.getName() + separator + editorReference.getTitleToolTip(); //$NON-NLS-1$
58	}
59
60	public String getSortLabel() {
61	return editorReference.getTitle();
62	}
63	}

Added Link Here

(-)Eclipse (+69 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import java.util.HashSet;
15	import java.util.List;
16	import java.util.HashMap;
17	import java.util.Map;
18	import java.util.Set;
19
20	import org.eclipse.jface.preference.IPreferenceNode;
21	import org.eclipse.jface.preference.PreferenceManager;
22	import org.eclipse.jface.resource.ImageDescriptor;
23	import org.eclipse.ui.PlatformUI;
24	import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
25	import org.eclipse.ui.internal.WorkbenchImages;
26
27	/**
28	* @since 3.3
29	*
30	*/
31	public class PreferenceProvider extends AbstractProvider {
32
33	private AbstractElement[] cachedElements;
34	private Map idToElement = new HashMap();
35
36	public String getId() {
37	return "org.eclipse.ui.preferences"; //$NON-NLS-1$
38	}
39
40	public AbstractElement getElementForId(String id) {
41	getElements();
42	return (PreferenceElement) idToElement.get(id);
43	}
44
45	public AbstractElement[] getElements() {
46	if (cachedElements == null) {
47	List list = PlatformUI.getWorkbench().getPreferenceManager().getElements(PreferenceManager.PRE_ORDER);
48	Set uniqueElements = new HashSet(list);
49	IPreferenceNode[] preferences = (IPreferenceNode[]) uniqueElements.toArray(new IPreferenceNode[uniqueElements.size()]);
50	cachedElements = new AbstractElement[preferences.length];
51	for (int i = 0; i < preferences.length; i++) {
52	PreferenceElement preferenceElement = new PreferenceElement(
53	preferences[i]);
54	cachedElements[i] = preferenceElement;
55	idToElement.put(preferenceElement.getId(), preferenceElement);
56	}
57	}
58	return cachedElements;
59	}
60
61	public ImageDescriptor getImageDescriptor() {
62	return WorkbenchImages
63	.getImageDescriptor(IWorkbenchGraphicConstants.IMG_OBJ_NODE);
64	}
65
66	public String getName() {
67	return IncubatorMessages.CtrlEAction_Preferences;
68	}
69	}

Added Link Here

(-)Eclipse (+68 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import org.eclipse.jface.preference.IPreferenceNode;
15	import org.eclipse.jface.preference.IPreferencePage;
16	import org.eclipse.jface.resource.ImageDescriptor;
17	import org.eclipse.swt.graphics.Image;
18	import org.eclipse.ui.IWorkbenchWindow;
19	import org.eclipse.ui.PlatformUI;
20	import org.eclipse.ui.internal.dialogs.WorkbenchPreferenceDialog;
21
22	/**
23	* @since 3.3
24	*
25	*/
26	public class PreferenceElement extends AbstractElement {
27
28	private static final String separator = " - "; //$NON-NLS-1$
29
30	private IPreferenceNode preferenceNode;
31
32	public PreferenceElement(IPreferenceNode preferenceNode) {
33	this.preferenceNode = preferenceNode;
34	}
35
36	public void execute() {
37	IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
38	if(window != null) {
39	WorkbenchPreferenceDialog dialog = WorkbenchPreferenceDialog
40	.createDialogOn(window.getShell(), preferenceNode
41	.getId());
42	dialog.open();
43	}
44	}
45
46	public String getId() {
47	return preferenceNode.getId();
48	}
49
50	public ImageDescriptor getImageDescriptor() {
51	Image image = preferenceNode.getLabelImage();
52	if(image != null) {
53	ImageDescriptor descriptor = ImageDescriptor.createFromImage(image);
54	return descriptor;
55	}
56	return null;
57	}
58
59	public String getLabel() {
60	IPreferencePage page = preferenceNode.getPage();
61	if (page != null && page.getDescription() != null
62	&& page.getDescription().length() != 0) {
63	return preferenceNode.getLabelText() + separator
64	+ page.getDescription();
65	}
66	return preferenceNode.getLabelText();
67	}
68	}

Added Link Here

(-)Eclipse (+49 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import org.eclipse.jface.resource.ImageDescriptor;
15	import org.eclipse.ui.IPerspectiveDescriptor;
16	import org.eclipse.ui.IWorkbenchPage;
17	import org.eclipse.ui.PlatformUI;
18
19	/**
20	* @since 3.3
21	*
22	*/
23	public class PerspectiveElement extends AbstractElement {
24
25	private final IPerspectiveDescriptor descriptor;
26
27	public PerspectiveElement(IPerspectiveDescriptor descriptor) {
28	this.descriptor = descriptor;
29	}
30
31	public void execute() {
32	IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
33	if(activePage != null) {
34	activePage.setPerspective(descriptor);
35	}
36	}
37
38	public String getId() {
39	return descriptor.getId();
40	}
41
42	public ImageDescriptor getImageDescriptor() {
43	return descriptor.getImageDescriptor();
44	}
45
46	public String getLabel() {
47	return descriptor.getLabel();
48	}
49	}

Added Link Here

(-)Eclipse (+33 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import org.eclipse.jface.resource.ImageDescriptor;
15
16	/**
17	* @since 3.3
18	*
19	*/
20	public abstract class AbstractElement {
21
22	public abstract String getLabel();
23
24	public abstract ImageDescriptor getImageDescriptor();
25
26	public abstract String getId();
27
28	public abstract void execute();
29
30	public String getSortLabel() {
31	return getLabel();
32	}
33	}

Added Link Here

(-)Eclipse (+65 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import java.util.HashMap;
15	import java.util.Map;
16
17	import org.eclipse.jface.resource.ImageDescriptor;
18	import org.eclipse.ui.IEditorReference;
19	import org.eclipse.ui.IWorkbenchPage;
20	import org.eclipse.ui.PlatformUI;
21	import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
22	import org.eclipse.ui.internal.WorkbenchImages;
23
24	/**
25	* @since 3.3
26	*
27	*/
28	public class EditorProvider extends AbstractProvider {
29
30	private AbstractElement[] cachedElements;
31	private Map idToElement = new HashMap();
32
33	public AbstractElement getElementForId(String id) {
34	getElements();
35	return (EditorElement) idToElement.get(id);
36	}
37
38	public AbstractElement[] getElements() {
39	if (cachedElements == null) {
40	IWorkbenchPage activePage = PlatformUI.getWorkbench()
41	.getActiveWorkbenchWindow().getActivePage();
42	IEditorReference[] editors = activePage.getEditorReferences();
43	cachedElements = new AbstractElement[editors.length];
44	for (int i = 0; i < editors.length; i++) {
45	EditorElement editorElement = new EditorElement(editors[i]);
46	cachedElements[i] = editorElement;
47	idToElement.put(editorElement.getId(), editorElement);
48	}
49	}
50	return cachedElements;
51	}
52
53	public String getId() {
54	return "org.eclipse.ui.editors"; //$NON-NLS-1$
55	}
56
57	public ImageDescriptor getImageDescriptor() {
58	return WorkbenchImages
59	.getImageDescriptor(IWorkbenchGraphicConstants.IMG_OBJ_NODE);
60	}
61
62	public String getName() {
63	return IncubatorMessages.CtrlEAction_Editors;
64	}
65	}

Added Link Here

(-)Eclipse (+57 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import org.eclipse.jface.action.ActionContributionItem;
15	import org.eclipse.jface.action.IAction;
16	import org.eclipse.jface.action.LegacyActionTools;
17	import org.eclipse.jface.resource.ImageDescriptor;
18
19	/**
20	* @since 3.3
21	*
22	*/
23	public class ActionElement extends AbstractElement {
24
25	private static final String separator = " - "; //$NON-NLS-1$
26
27	private ActionContributionItem item;
28
29	public ActionElement(ActionContributionItem item) {
30	this.item = item;
31	}
32
33	public void execute() {
34	item.getAction().run();
35	}
36
37	public String getId() {
38	return item.getId();
39	}
40
41	public ImageDescriptor getImageDescriptor() {
42	return item.getAction().getImageDescriptor();
43	}
44
45	public String getLabel() {
46	IAction action = item.getAction();
47	if (action.getToolTipText() != null
48	&& action.getToolTipText().length() != 0) {
49	return LegacyActionTools.removeMnemonics(action.getText())
50	+ separator + action.getToolTipText();
51	}
52	return LegacyActionTools.removeMnemonics(action.getText());
53	}
54	}
55
56
57

Added Link Here

(-)Eclipse (+53 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.incubator;
13
14	import org.eclipse.jface.resource.ImageDescriptor;
15	import org.eclipse.ui.IWorkbenchPage;
16	import org.eclipse.ui.PartInitException;
17	import org.eclipse.ui.PlatformUI;
18	import org.eclipse.ui.views.IViewDescriptor;
19
20	/**
21	* @since 3.3
22	*
23	*/
24	public class ViewElement extends AbstractElement {
25
26	private final IViewDescriptor viewDescriptor;
27
28	public ViewElement(IViewDescriptor viewDescriptor) {
29	this.viewDescriptor = viewDescriptor;
30	}
31
32	public void execute() {
33	IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
34	if(activePage != null) {
35	try {
36	activePage.showView(viewDescriptor.getId());
37	} catch (PartInitException e) {
38	}
39	}
40	}
41
42	public String getId() {
43	return viewDescriptor.getId();
44	}
45
46	public ImageDescriptor getImageDescriptor() {
47	return viewDescriptor.getImageDescriptor();
48	}
49
50	public String getLabel() {
51	return viewDescriptor.getLabel();
52	}
53	}