bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/ExtendedEditorActionBuilder.java

/*******************************************************************************
 * Copyright (c) 2001, 2007 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
 *     Jens Lukowski/Innoopract - initial renaming/restructuring
 *     
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IMenuListener;
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.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.swt.graphics.Point;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.IKeyBindingService;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.part.MultiPageEditorSite;
import org.eclipse.ui.texteditor.IUpdate;
import org.eclipse.wst.sse.ui.internal.extension.ActionDescriptor;
import org.eclipse.wst.sse.ui.internal.extension.IExtendedEditorActionProxyForDelayLoading;
import org.eclipse.wst.sse.ui.internal.extension.RegistryReader;
import org.eclipse.wst.sse.ui.internal.provisional.extensions.ISourceEditingTextTools;


/**
 * This class reads the registry for extensions that plug into 'editorActions'
 * extension point.
 */

public class ExtendedEditorActionBuilder extends RegistryReader {

	public class ExtendedContributor implements IExtendedContributor, IMenuListener {
		private IExtendedSimpleEditor activeExtendedEditor = null;

		private List cache;
		private Map map = new HashMap();
		private IMenuManager menuBar = null;

		private Set menus = new HashSet();

		public ExtendedContributor(List cache) {
			this.cache = cache;
		}

		private IExtendedSimpleEditor computeExtendedEditor(final IEditorPart editor) {
			IExtendedSimpleEditor simpleEditor = null;
			if (editor instanceof IExtendedSimpleEditor) {
				simpleEditor = (IExtendedSimpleEditor) editor;
			}
			if (editor != null && simpleEditor == null) {
				final ISourceEditingTextTools tools = (ISourceEditingTextTools) editor.getAdapter(ISourceEditingTextTools.class);
				if (tools != null) {
					simpleEditor = new IExtendedSimpleEditor() {
						public int getCaretPosition() {
							return tools.getCaretOffset();
						}

						public IDocument getDocument() {
							return tools.getDocument();
						}

						public IEditorPart getEditorPart() {
							return tools.getEditorPart();
						}

						public Point getSelectionRange() {
							ITextSelection selection = tools.getSelection();
							return new Point(selection.getOffset(), selection.getOffset() + selection.getLength());
						}

					};
				}
			}
			return simpleEditor;
		}

		public void contributeToMenu(IMenuManager menu) {
			menuBar = menu;
			long time0 = System.currentTimeMillis();
			for (int i = 0; i < cache.size(); i++) {
				Object obj = cache.get(i);
				if (obj instanceof IConfigurationElement) {
					IConfigurationElement menuElement = (IConfigurationElement) obj;
					if ((menuElement.getName()).equals(TAG_MENU)) {
						contributeMenu(menuElement, menu, true);
						if (debugMenu)
							System.out.println(getClass().getName() + "#contributeToMenu() added: " + menuElement.getAttribute(ATT_ID)); //$NON-NLS-1$
					}
				}
				else if (obj instanceof ActionDescriptor) {
					try {
						ActionDescriptor ad = (ActionDescriptor) obj;
						IMenuManager mm = contributeMenuAction(ad, menu, true, false);
						if (mm != null) {
							map.put(ad.getContributionItem(), mm);
							mm.addMenuListener(this);
							menus.add(mm);
							if (debugMenu)
								System.out.println(getClass().getName() + "#contributeToMenu() added: " + ad.getId()); //$NON-NLS-1$
						}
					}
					catch (Exception e) {
						Logger.logException("contributing to menu", e); //$NON-NLS-1$
					}
				}
			}
			if (debugContributeTime)
				System.out.println(getClass().getName() + "#contributeToMenu(): ran in " + (System.currentTimeMillis() - time0) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$
		}

		public void contributeToPopupMenu(IMenuManager menu) {
			long time0 = System.currentTimeMillis();
			for (int i = 0; i < cache.size(); i++) {
				Object obj = cache.get(i);
				if (obj instanceof IConfigurationElement) {
					IConfigurationElement menuElement = (IConfigurationElement) obj;
					if ((menuElement.getName()).equals(TAG_POPUPMENU)) {
						contributeMenu(menuElement, menu, true);
					}
				}
				else if (obj instanceof ActionDescriptor) {
					try {
						ActionDescriptor ad = (ActionDescriptor) obj;
						IAction a = ad.getAction();
						if (a instanceof IExtendedEditorAction) {
							// uncaught exceptions could cause the menu to not
							// be shown
							try {
								if (((ad.getPopupMenuPath() != null) || (ad.getPopupMenuGroup() != null)) && (a instanceof IExtendedEditorActionProxyForDelayLoading)) {
								    ((IExtendedEditorActionProxyForDelayLoading)a).realize();
								}

								IExtendedEditorAction eea = (IExtendedEditorAction) a;
								eea.setActiveExtendedEditor(activeExtendedEditor);
								eea.update();
								if (eea.isVisible()) {
									IMenuManager parent = contributeMenuAction(ad, menu, true, true);
									if (debugPopup && parent != null)
										System.out.println(getClass().getName() + "#contributeToPopupMenu() added: " + ad.getId()); //$NON-NLS-1$
								}
							}
							catch (Exception e) {
								Logger.logException(e);
							}

						}
						else {
							IMenuManager parent = contributeMenuAction(ad, menu, true, true);
							if (debugPopup && parent != null)
								System.out.println(getClass().getName() + "#contributeToPopupMenu() added: " + ad.getId()); //$NON-NLS-1$
						}
					}
					catch (Exception e) {
						Logger.logException("contributing to popup", e); //$NON-NLS-1$
					}
				}
			}
			if (debugContributeTime)
				System.out.println(getClass().getName() + "#contributeToPopupMenu(): ran in " + (System.currentTimeMillis() - time0) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$
		}

		public void contributeToStatusLine(IStatusLineManager manager) {
			// nothing from here
		}

		public void contributeToToolBar(IToolBarManager manager) {
			long time0 = System.currentTimeMillis();
			for (int i = 0; i < cache.size(); i++) {
				Object obj = cache.get(i);
				if (obj instanceof ActionDescriptor) {
					try {
						ActionDescriptor ad = (ActionDescriptor) obj;
						IAction a = ad.getAction();
						if (a instanceof IExtendedEditorAction) {
							if (((ad.getToolbarPath() != null) || (ad.getToolbarGroup() != null)) && (a instanceof IExtendedEditorActionProxyForDelayLoading)) {
							    ((IExtendedEditorActionProxyForDelayLoading)a).realize();
							}
							IExtendedEditorAction eea = (IExtendedEditorAction) a;
							eea.setActiveExtendedEditor(activeExtendedEditor);
							eea.update();
							if (eea.isVisible()) {
								boolean contributed = contributeToolbarAction(ad, manager, true);
								if (debugToolbar && contributed)
									System.out.println(getClass().getName() + "#contributeToToolBar() added: " + ad.getId()); //$NON-NLS-1$
							}
							else {
								if (debugToolbar)
									System.out.println(getClass().getName() + "#contributeToToolBar(): [skipped] " + ad.getId()); //$NON-NLS-1$
							}
						}
						else {
							boolean contributed = contributeToolbarAction(ad, manager, true);
							if (debugToolbar && contributed)
								System.out.println(getClass().getName() + "#contributeToToolBar() added: " + ad.getId()); //$NON-NLS-1$
						}
					}
					catch (Exception e) {
						Logger.logException("contributing to toolbar", e); //$NON-NLS-1$
					}
				}
			}
			if (debugContributeTime)
				System.out.println(getClass().getName() + "#contributeToToolBar(): ran in " + (System.currentTimeMillis() - time0) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$
		}

		public void dispose() {
			Iterator it = menus.iterator();
			while (it.hasNext()) {
				Object o = it.next();
				if (o instanceof IMenuManager) {
					((IMenuManager) o).removeMenuListener(this);
				}
			}
		}

		public void init(IActionBars bars, IWorkbenchPage page) {
			// nothing from here
		}

		public void menuAboutToShow(IMenuManager menu) {
			// slows down the menu and interferes with it for other editors;
			// optimize on visibility
			IEditorSite site = null;
			boolean activeEditorIsVisible = false;

			if (activeExtendedEditor != null && activeExtendedEditor.getEditorPart() != null)
				site = activeExtendedEditor.getEditorPart().getEditorSite();
			if (site == null)
				return;

			// Eclipse bug 48784 - [MPE] ClassCast exception Workbench page
			// isPartVisiable for MultiPageSite
			if (site instanceof MultiPageEditorSite) {
				Object multiPageEditor = ((MultiPageEditorSite) site).getMultiPageEditor();
				activeEditorIsVisible = multiPageEditor.equals(site.getPage().getActiveEditor()) || multiPageEditor.equals(site.getPage().getActivePart());
			}
			else {
				activeEditorIsVisible = site.getWorkbenchWindow().getPartService().getActivePart().equals(activeExtendedEditor.getEditorPart());
			}
			// due to a delay class loading, don't return now
//			if (!activeEditorIsVisible)
//				return;

			IContributionItem[] items = menu.getItems();
			if (items == null || items.length == 0)
				return;

			for (int i = 0; i < items.length; ++i) {
				// add menu listener to submenu
				if (items[i] instanceof IMenuManager) {
					((IMenuManager) items[i]).addMenuListener(this);
					menus.add(items[i]);
				}
			}

			Set keys = map.keySet();
			Iterator it = keys.iterator();
			boolean needActionContributionItemUpdate = false;
			while (it.hasNext()) {
				IContributionItem item = (IContributionItem) it.next();
				IMenuManager mm = (IMenuManager) map.get(item);
				if (menu.getId() != null && menu.getId().equals(mm.getId()) && item instanceof ActionContributionItem) {
					try {
						IAction action = ((ActionContributionItem) item).getAction();

						if (action instanceof IExtendedEditorActionProxyForDelayLoading) {
						    IExtendedEditorActionProxyForDelayLoading eea = (IExtendedEditorActionProxyForDelayLoading)action;
						    if (eea.isBundleActive() == true && eea.isRealized() == false) {
						        eea.realize();
						        needActionContributionItemUpdate = true;
						    }
						}

						if (activeEditorIsVisible || needActionContributionItemUpdate) {
							if (action instanceof IUpdate) {
								((IUpdate) action).update();
							}
						}

						if (activeEditorIsVisible || needActionContributionItemUpdate) {
							boolean visible = true;
							if (action instanceof IExtendedEditorAction) {
								visible = ((IExtendedEditorAction) action).isVisible();
							}
							item.setVisible(visible);
						}

						if (needActionContributionItemUpdate) {
						    ((ActionContributionItem)item).update();
						}

					}
					catch (Exception e) {
						Logger.logException("updating actions", e); //$NON-NLS-1$
					}
				}
			}
			if (activeEditorIsVisible || needActionContributionItemUpdate) {
			    if (needActionContributionItemUpdate) {
			        // the action is realized so that need to update the menu w/
			        // force set to true
			        menu.update(true);
			    } else {
			        menu.update(false);
			    }
			}
		}

		public void setActiveEditor(IEditorPart editor) {
			activeExtendedEditor = computeExtendedEditor(editor);
			IKeyBindingService svc = (editor != null) ? editor.getEditorSite().getKeyBindingService() : null;
			for (int i = 0; i < cache.size(); i++) {
				Object obj = cache.get(i);
				if (obj instanceof ActionDescriptor) {
					ActionDescriptor ad = (ActionDescriptor) obj;
					try {
						IAction action = ad.getAction();
						if (action instanceof IExtendedEditorAction) {
							((IExtendedEditorAction) action).setActiveExtendedEditor(activeExtendedEditor);
							((IExtendedEditorAction) action).update();
							// update visibility right now so that the menu
							// will show/hide properly
							if (!((IExtendedEditorAction) action).isVisible() && ad.getContributionItem() != null)
								ad.getContributionItem().setVisible(false);
							if (svc != null && action.getActionDefinitionId() != null) {
								svc.registerAction(action);
							}
						}
					}
					catch (Exception e) {
						Logger.logException("setting active editor on actions", e); //$NON-NLS-1$
					}
				}
			}

			if (menuBar != null && editor != null) {
				// Class clz = editor.getClass();
				// while (clz != null) {
				// if (clz.getName().equals(targetID)) {
				// contributeToMenu(menuBar);
				// break;
				// }
				// clz = clz.getSuperclass();
				// }
				if (targetIDs.contains(editor.getEditorSite().getId())) {
					contributeToMenu(menuBar);
				}
			}

			updateToolbarActions();
		}

		public void updateToolbarActions() {
			for (int i = 0; i < cache.size(); i++) {
				Object obj = cache.get(i);
				if (obj instanceof ActionDescriptor) {
					try {
						ActionDescriptor ad = (ActionDescriptor) obj;
						if (ad.getToolbarPath() != null) {
							IAction action = ad.getAction();
							if (action instanceof IUpdate) {
								((IUpdate) action).update();
							}
						}
					}
					catch (Exception e) {
						Logger.logException("updating toolbar actions", e); //$NON-NLS-1$
					}
				}
			}
		}
	}

	public static final String ATT_ID = "id"; //$NON-NLS-1$
	public static final String ATT_LABEL = "label"; //$NON-NLS-1$
	public static final String ATT_NAME = "name"; //$NON-NLS-1$
	public static final String ATT_PATH = "path"; //$NON-NLS-1$

	public static final String ATT_TARGET_ID = "targetID"; //$NON-NLS-1$
	protected final static boolean debugContributeTime = "true".equalsIgnoreCase(Platform.getDebugOption("org.eclipse.wst.sse.ui/extendededitoractionbuilder/contributetime")); //$NON-NLS-1$  //$NON-NLS-2$

	protected final static boolean debugMenu = "true".equalsIgnoreCase(Platform.getDebugOption("org.eclipse.wst.sse.ui/extendededitoractionbuilder/debugmenu")); //$NON-NLS-1$  //$NON-NLS-2$;
	protected final static boolean debugPopup = "true".equalsIgnoreCase(Platform.getDebugOption("org.eclipse.wst.sse.ui/extendededitoractionbuilder/debugpopup")); //$NON-NLS-1$  //$NON-NLS-2$;
	protected final static boolean debugReadTime = "true".equalsIgnoreCase(Platform.getDebugOption("org.eclipse.wst.sse.ui/extendededitoractionbuilder/readtime")); //$NON-NLS-1$  //$NON-NLS-2$
	protected final static boolean debugToolbar = "true".equalsIgnoreCase(Platform.getDebugOption("org.eclipse.wst.sse.ui/extendededitoractionbuilder/debugtoolbar")); //$NON-NLS-1$  //$NON-NLS-2$;

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

	public static final String PL_EXTENDED_EDITOR_ACTIONS = "extendedEditorActions"; //$NON-NLS-1$

	public static final String PLUGIN_ID = "org.eclipse.wst.sse.ui"; //$NON-NLS-1$
	public static final String TAG_ACTION = "action"; //$NON-NLS-1$

	public static final String TAG_CONTRIBUTION_TYPE = "editorContribution"; //$NON-NLS-1$

	public static final String TAG_MENU = "menu"; //$NON-NLS-1$
	public static final String TAG_POPUPMENU = "popupmenu"; //$NON-NLS-1$
	public static final String TAG_RULERMENU = "rulermenu"; //$NON-NLS-1$
	public static final String TAG_SEPARATOR = "separator"; //$NON-NLS-1$

	protected List readingCache;

	protected String targetContributionTag;
	protected List targetIDs;

	/**
	 * The constructor.
	 */
	public ExtendedEditorActionBuilder() {
		super();
	}

	/**
	 * Creates a menu from the information in the menu configuration element
	 * and adds it into the provided menu manager. If 'appendIfMissing' is
	 * true, and menu path slot is not found, it will be created and menu will
	 * be added into it. Otherwise, add operation will fail.
	 */
	protected void contributeMenu(IConfigurationElement menuElement, IMenuManager mng, boolean appendIfMissing) {
		// Get config data.
		String id = menuElement.getAttribute(ATT_ID);
		String label = menuElement.getAttribute(ATT_LABEL);
		String path = menuElement.getAttribute(ATT_PATH);
		if (label == null) {
			Logger.log(Logger.ERROR, "Invalid Menu Extension (label == null): " + id); //$NON-NLS-1$
			return;
		}

		// Calculate menu path and group.
		String group = null;
		if (path != null) {
			int loc = path.lastIndexOf('/');
			if (loc != -1) {
				group = path.substring(loc + 1);
				path = path.substring(0, loc);
			}
			else {
				// assume that path represents a slot
				// so actual path portion should be null
				group = path;
				path = null;
			}
		}

		// Find parent menu.
		IMenuManager parent = mng;
		if (path != null) {
			parent = mng.findMenuUsingPath(path);
			if (parent == null) {
				// Logger.log("Invalid Menu Extension (Path is invalid): " +
				// id);//$NON-NLS-1$
				return;
			}
			// IMenuManager.findMenuUsingPath() returns invisible menu item if
			// the manager can't find
			// the specified path and create new MenuManager for it.
			// I don't know this is a specification or bug.
			// Anyway, to ensure the menu can be visible, setVisible(true)
			// needs to be called.
			parent.setVisible(true);
		}

		// Find reference group.
		if (group == null)
			group = IWorkbenchActionConstants.MB_ADDITIONS;
		IContributionItem sep = parent.find(group);
		if (sep == null) {
			if (appendIfMissing)
				parent.add(new Separator(group));
			else {
				Logger.log(Logger.ERROR, "Invalid Menu Extension (Group is invalid): " + id); //$NON-NLS-1$
				return;
			}
		}

		// If the menu does not exist create it.
		IMenuManager newMenu = parent.findMenuUsingPath(id);
		if (newMenu == null)
			newMenu = new MenuManager(label, id);

		// Create separators.
		IConfigurationElement[] children = menuElement.getChildren(TAG_SEPARATOR);
		for (int i = 0; i < children.length; i++) {
			contributeSeparator(newMenu, children[i]);
		}

		// Add new menu
		try {
			parent.insertAfter(group, newMenu);
		}
		catch (IllegalArgumentException e) {
			Logger.log(Logger.ERROR, "Invalid Menu Extension (Group is missing): " + id); //$NON-NLS-1$
		}
	}

	/**
	 * Contributes action from action descriptor into the provided menu
	 * manager.
	 */
	protected IMenuManager contributeMenuAction(ActionDescriptor ad, IMenuManager menu, boolean appendIfMissing, boolean popupmenu) {
		if (ad.getContributionItem() == null || ad.getAction() == null)
			return null;

		// Get config data.
		String mpath = popupmenu ? ad.getPopupMenuPath() : ad.getMenuPath();
		String mgroup = popupmenu ? ad.getPopupMenuGroup() : ad.getMenuGroup();
		if (mpath == null && mgroup == null)
			return null;

		// Find parent menu.
		IMenuManager parent = menu;
		if (mpath != null) {
			parent = parent.findMenuUsingPath(mpath);
			if (parent == null) {
				// Logger.log("Invalid Menu Extension (Path is invalid): " +
				// ad.getId()); //$NON-NLS-1$
				return null;
			}
			// IMenuManager.findMenuUsingPath() returns invisible menu item if
			// the manager can't find
			// the specified path and create new MenuManager for it.
			// I don't know this is a specification or bug.
			// Anyway, to ensure the menu can be visible, setVisible(true)
			// needs to be called.
			parent.setVisible(true);
		}

		// First remove existing menu item
		IContributionItem item = parent.find(ad.getId());
		if (item != null) {
			parent.remove(ad.getId());
		}

		// Find reference group.
		if (mgroup == null)
			mgroup = IWorkbenchActionConstants.MB_ADDITIONS;
		IContributionItem sep = parent.find(mgroup);
		if (sep == null) {
			if (appendIfMissing)
				parent.add(sep = new Separator(mgroup));
			else {
				Logger.log(Logger.ERROR, "Invalid Menu Extension (Group is invalid): " + ad.getId()); //$NON-NLS-1$
				return null;
			}
		}

		// Add action.
		try {
			if (popupmenu) {
				// Context menu need a newly created contribution item
				if (sep != null && sep.isGroupMarker())
					parent.appendToGroup(sep.getId(), ad.getAction());
				else
					parent.insertAfter(mgroup, ad.getAction());
			}
			else {
				// Normal menu need to add existing contribution item to
				// remove it from menu listener
				if (sep != null && sep.isGroupMarker())
					parent.appendToGroup(sep.getId(), ad.getContributionItem());
				else
					parent.insertAfter(mgroup, ad.getContributionItem());
			}
		}
		catch (IllegalArgumentException e) {
			Logger.log(Logger.ERROR, "Invalid Menu Extension (Group is missing): " + ad.getId()); //$NON-NLS-1$
			parent = null;
		}

		return parent;
	}

	/**
	 * Creates a named menu separator from the information in the
	 * configuration element. If the separator already exists do not create a
	 * second.
	 */
	protected boolean contributeSeparator(IMenuManager menu, IConfigurationElement element) {
		String id = element.getAttribute(ATT_NAME);
		if (id == null || id.length() <= 0)
			return false;
		IContributionItem sep = menu.find(id);
		if (sep != null)
			return false;
		menu.add(new Separator(id));
		return true;
	}

	/**
	 * Contributes action from the action descriptor into the provided tool
	 * bar manager.
	 */
	protected boolean contributeToolbarAction(ActionDescriptor ad, IToolBarManager toolbar, boolean appendIfMissing) {
		if (ad.getContributionItem() == null || ad.getAction() == null)
			return false;

		// Get config data.
		String tpath = ad.getToolbarPath();
		String tgroup = ad.getToolbarGroup();
		if (tpath == null && tgroup == null)
			return false;

		// First remove existing toolbar item
		IContributionItem item = toolbar.find(ad.getId());
		if (item != null) {
			toolbar.remove(ad.getId());
		}

		// Find reference group.
		if (tgroup == null)
			tgroup = IWorkbenchActionConstants.MB_ADDITIONS;
		IContributionItem sep = toolbar.find(tgroup);
		if (sep == null) {
			if (appendIfMissing)
				toolbar.add(new Separator(tgroup));
			else {
				Logger.log(Logger.ERROR, "Invalid Toolbar Extension (Group is invalid): " + ad.getId()); //$NON-NLS-1$
				return false;
			}
		}

		// Add action to tool bar.
		try {
			if (sep != null && sep.isGroupMarker())
				toolbar.appendToGroup(sep.getId(), ad.getAction());
			else
				toolbar.insertAfter(tgroup, ad.getAction());
		}
		catch (IllegalArgumentException e) {
			Logger.log(Logger.ERROR, "Invalid Toolbar Extension (Group is missing): " + ad.getId()); //$NON-NLS-1$
			return false;
		}
		return true;
	}

	/**
	 * This factory method returns a new ActionDescriptor for the
	 * configuration element. It should be implemented by subclasses.
	 */
	protected ActionDescriptor createActionDescriptor(IConfigurationElement element) {
		ActionDescriptor ad = null;
		try {
			ad = new ActionDescriptor(element);
			// these cases like "class not found" are handled
			// at lower level, so no action if formed. In that
			// case, we also don't want to form an action descriptor.
			if ((ad != null) && (ad.getAction() == null)) {
				ad = null;
			}
		}
		catch (Exception e) {
			Logger.traceException(EXTENDED_EDITOR, e);
			ad = null;
		}
		return ad;
	}

	/**
	 * Returns the name of the part ID attribute that is expected in the
	 * target extension.
	 */
	protected String getTargetID(IConfigurationElement element) {
		String value = element.getAttribute(ATT_TARGET_ID);
		return value != null ? value : "???"; //$NON-NLS-1$
	}

	/**
	 * Reads editor contributor if specified directly in the 'editor'
	 * extension point, and all external contributions for this editor's ID
	 * registered in 'editorActions' extension point.
	 */
	public IExtendedContributor readActionExtensions(String editorId) {
		return readActionExtensions(new String[]{editorId});
	}

	/**
	 * Reads editor contributor if specified directly in the 'editor'
	 * extension point, and all external contributions for this editor's ID
	 * registered in 'editorActions' extension point.
	 */
	public IExtendedContributor readActionExtensions(String[] ids) {
		long time0 = System.currentTimeMillis();
		ExtendedContributor ext = null;
		readContributions(ids, TAG_CONTRIBUTION_TYPE, PL_EXTENDED_EDITOR_ACTIONS);
		if (debugReadTime) {
			String idlist = ""; //$NON-NLS-1$
			if (ids.length > 0) {
				for (int i = 0; i < ids.length; i++) {
					idlist += ids[i];
					if (i < ids.length - 1)
						idlist += ","; //$NON-NLS-1$
				}
			}
			System.out.println(getClass().getName() + "#readActionExtensions(" + idlist + "): read in " + (System.currentTimeMillis() - time0) + "ms [" + (readingCache != null ? readingCache.size() : 0) + " contributions]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
		}
		if (readingCache != null) {
			ext = new ExtendedContributor(readingCache);
			readingCache = null;
		}
		return ext;
	}

	/**
	 * Reads the contributions from the registry for the provided workbench
	 * part and the provided extension point IDs.
	 */
	protected void readContributions(String[] ids, String tag, String extensionPoint) {
		readingCache = null;
		targetIDs = Arrays.asList(ids);
		targetContributionTag = tag;
		IExtensionRegistry registry = Platform.getExtensionRegistry();
		readRegistry(registry, PLUGIN_ID, extensionPoint);
	}

	/**
	 * Implements abstract method to handle the provided XML element in the
	 * registry.
	 */
	protected boolean readElement(IConfigurationElement element) {
		String tag = element.getName();
		if (tag.equals(targetContributionTag)) {
			String id = getTargetID(element);
			if (id == null || !targetIDs.contains(id)) {
				// This is not of interest to us - don't go deeper
				return true;
			}
		}
		else if (tag.equals(TAG_MENU)) {
			if (readingCache == null)
				readingCache = new ArrayList();
			readingCache.add(element);
			return true; // just cache the element - don't go into it
		}
		else if (tag.equals(TAG_POPUPMENU)) {
			if (readingCache == null)
				readingCache = new ArrayList();
			readingCache.add(element);
			return true; // just cache the element - don't go into it
		}
		else if (tag.equals(TAG_RULERMENU)) {
			if (readingCache == null)
				readingCache = new ArrayList();
			readingCache.add(element);
			return true; // just cache the element - don't go into it
		}
		else if (tag.equals(TAG_ACTION)) {
			if (readingCache == null)
				readingCache = new ArrayList();
			ActionDescriptor ad = createActionDescriptor(element);
			if (ad != null)
				readingCache.add(ad);
			return true; // just cache the action - don't go into
		}
		else {
			return false;
		}

		readElementChildren(element);
		return true;
	}
}