bundles/org.eclipse.ui.workbench/Eclipse UI/org/eclipse/ui/internal/EditorMenuManager.java

package org.eclipse.ui.internal;

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

Contributors:
	IBM - Initial implementation
************************************************************************/

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IContributionManagerOverrides;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.SubMenuManager;
import org.eclipse.ui.actions.RetargetAction;

/**
 * An <code>EditorMenuManager</code> is used to sort the contributions
 * made by an editor so that they always appear after the action sets.  
 */
public class EditorMenuManager extends SubMenuManager {
	private ArrayList wrappers;
	private boolean enabledAllowed = true;

	private class Overrides implements IContributionManagerOverrides {
		/**
		 * Indicates that the items of this manager are allowed to enable;
		 * <code>true</code> by default.
		 */
		public void updateEnabledAllowed() {
			// update the items in the map
			IContributionItem[] items = EditorMenuManager.super.getItems();
			for (int i = 0; i < items.length; i++) {
				IContributionItem item = items[i];
				item.update(IContributionManagerOverrides.P_ENABLED);
			}
			// update the wrapped menus
			if (wrappers != null) {
				for (int i = 0; i < wrappers.size(); i++) {
					EditorMenuManager manager = (EditorMenuManager) wrappers.get(i);
					manager.setEnabledAllowed(enabledAllowed);
				}
			}
		}
		public Boolean getEnabled(IContributionItem item) {
			if (((item instanceof ActionContributionItem) && (((ActionContributionItem) item).getAction() instanceof RetargetAction)) || enabledAllowed)
				return null;
			else
				return Boolean.FALSE;
		}
		public Integer getAccelerator(IContributionItem item) {
			if (getEnabled(item) == null)
				return getParentMenuManager().getOverrides().getAccelerator(item);
			else
				// no acclerator if the item is disabled
				return new Integer(0);
		}
		public String getAcceleratorText(IContributionItem item) {
			return getParentMenuManager().getOverrides().getAcceleratorText(item);
		}
		public String getText(IContributionItem item) {
			return getParentMenuManager().getOverrides().getText(item);
		}
	}
	private Overrides overrides = new Overrides();
	/**
	 * Constructs a new editor manager.
	 */
	public EditorMenuManager(IMenuManager mgr) {
		super(mgr);
	}
	/* (non-Javadoc)
	 * Method declared on IContributionManager.
	 */
	public IContributionItem[] getItems() {
		return getParentMenuManager().getItems();
	}
	/* (non-Javadoc)
	 * Method declared on IContributionManager.
	 */
	public IContributionManagerOverrides getOverrides() {
		return overrides;
	}
	/* (non-Javadoc)
	 * Method declared on IContributionManager.
	 * Inserts the new item after any action set contributions which may
	 * exist within the toolbar to ensure a consistent order for actions.
	 */
	public void insertAfter(String id, IContributionItem item) {
		IContributionItem refItem = PluginActionSetBuilder.findInsertionPoint(id, null, getParentMenuManager(), false);
		if (refItem != null) {
			super.insertAfter(refItem.getId(), item);
		} else {
			WorkbenchPlugin.log("Reference item " + id + " not found for action " + item.getId()); //$NON-NLS-1$
		}
	}
	/* (non-Javadoc)
	 * Method declared on IContributionManager.
	 * Inserts the new item after any action set contributions which may
	 * exist within the toolbar to ensure a consistent order for actions.
	 */
	public void prependToGroup(String groupName, IContributionItem item) {
		insertAfter(groupName, item);
	}
	/**
	 * Sets the visibility of the manager. If the visibility is <code>true</code>
	 * then each item within the manager appears within the parent manager.
	 * Otherwise, the items are not visible.
	 * <p>
	 * If force visibility is <code>true</code>, or grayed out if force visibility is <code>false</code>
	 * <p>
	 * This is a workaround for the layout flashing when editors contribute
	 * large amounts of items.</p>
	 *
	 * @param visible the new visibility
	 * @param forceVisibility whether to change the visibility or just the
	 * 		enablement state.
	 */
	public void setVisible(boolean visible, boolean forceVisibility) {
		if (visible) {
			if (forceVisibility) {
				// Make the items visible 
				if (!enabledAllowed)
					setEnabledAllowed(true);
			} else {
				if (enabledAllowed)
					setEnabledAllowed(false);
			}
			if (!isVisible())
				setVisible(true);
		} else {
			if (forceVisibility)
				// Remove the editor menu items
				setVisible(false);
			else
				// Disable the editor menu items.
				setEnabledAllowed(false);
		}
	}
	/**
	 * Sets the enablement ability of all the items contributed by the editor.
	 *
	 * @param enabledAllowed <code>true</code> if the items may enable
	 * @since 2.0
	 */
	public void setEnabledAllowed(boolean enabledAllowed) {
		if (this.enabledAllowed == enabledAllowed)
			return;
		this.enabledAllowed = enabledAllowed;
		overrides.updateEnabledAllowed();
	}
	/* (non-Javadoc)
	 * Method declared on SubMenuManager.
	 */
	protected SubMenuManager wrapMenu(IMenuManager menu) {
		if (wrappers == null)
			wrappers = new ArrayList();
		EditorMenuManager manager = new EditorMenuManager(menu);
		wrappers.add(manager);
		return manager;
	}

	protected IAction[] getAllContributedActions() {
		HashSet set = new HashSet();
		getAllContributedActions(set);
		return (IAction[]) set.toArray(new IAction[set.size()]);
	}
	protected void getAllContributedActions(HashSet set) {
		IContributionItem[] items = super.getItems();
		for (int i = 0; i < items.length; i++)
			getAllContributedActions(set, items[i]);
		if (wrappers == null)
			return;
		for (Iterator iter = wrappers.iterator(); iter.hasNext();) {
			EditorMenuManager element = (EditorMenuManager) iter.next();
			element.getAllContributedActions(set);
		}
	}
	protected void getAllContributedActions(HashSet set, IContributionItem item) {
		if (item instanceof MenuManager) {
			IContributionItem subItems[] = ((MenuManager) item).getItems();
			for (int j = 0; j < subItems.length; j++)
				getAllContributedActions(set, subItems[j]);
		} else if (item instanceof ActionContributionItem) {
			set.add(((ActionContributionItem) item).getAction());
		}
	}

}