| /******************************************************************************* |
| * 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 Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jface.action; |
| |
| import org.eclipse.jface.util.ListenerList; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.*; |
| import org.eclipse.swt.widgets.*; |
| import java.util.*; |
| import java.util.List; // disambiguate from SWT List |
| |
| /** |
| * A menu manager is a contribution manager which realizes itself and its items |
| * in a menu control; either as a menu bar, a sub-menu, or a context menu. |
| * <p> |
| * This class may be instantiated; it may also be subclassed. |
| * </p> |
| */ |
| public class MenuManager extends ContributionManager implements IMenuManager { |
| |
| private final static String PERMANENT = "lkg84hsdf098a!243lkjha9SDFlkjhsdfXlkjhsfdkljhfds$#$%sdfa68fgh"; //$NON-NLS-1$ |
| |
| /** |
| * The menu control; <code>null</code> before |
| * creation and after disposal. |
| */ |
| private Menu menu = null; |
| |
| /** |
| * List of registered menu listeners (element type: <code>IMenuListener</code>). |
| */ |
| private ListenerList listeners = new ListenerList(1); |
| |
| /** |
| * The menu id. |
| */ |
| private String id; |
| |
| /** |
| * The menu item widget; <code>null</code> before |
| * creation and after disposal. This field is used |
| * when this menu manager is a sub-menu. |
| */ |
| private MenuItem menuItem; |
| |
| /** |
| * The text for a sub-menu. |
| */ |
| private String menuText; |
| |
| /** |
| * Indicates whether <code>removeAll</code> should be |
| * called just before the menu is displayed. |
| */ |
| private boolean removeAllWhenShown = false; |
| |
| /** |
| * The parent contribution manager. |
| */ |
| private IContributionManager parent; |
| |
| /** |
| * Indicates this item is visible in its manager; <code>true</code> |
| * by default. |
| */ |
| private boolean visible = true; |
| |
| /** |
| * The overrides for items of this manager |
| */ |
| private IContributionManagerOverrides overrides; |
| |
| |
| /** |
| * Creates a menu manager. The text and id are <code>null</code>. |
| * Typically used for creating a context menu, where it doesn't need to be referred to by id. |
| */ |
| public MenuManager() { |
| this(null, null); |
| } |
| /** |
| * Creates a menu manager with the given text. The id of the menu |
| * is <code>null</code>. |
| * Typically used for creating a sub-menu, where it doesn't need to be referred to by id. |
| * |
| * @param text the text for the menu, or <code>null</code> if none |
| */ |
| public MenuManager(String text) { |
| this(text, null); |
| } |
| /** |
| * Creates a menu manager with the given text and id. |
| * Typically used for creating a sub-menu, where it needs to be referred to by id. |
| * |
| * @param text the text for the menu, or <code>null</code> if none |
| * @param id the menu id, or <code>null</code> if it is to have no id |
| */ |
| public MenuManager(String text, String id) { |
| this.menuText = text; |
| this.id = id; |
| } |
| /* (non-Javadoc) |
| * Method declared on IMenuManager. |
| */ |
| public void addMenuListener(IMenuListener listener) { |
| listeners.add(listener); |
| } |
| /** |
| * Creates and returns an SWT context menu control for this menu, |
| * and installs all registered contributions. |
| * Does not create a new control if one already exists. |
| * <p> |
| * Note that the menu is not expected to be dynamic. |
| * </p> |
| * |
| * @param parent the parent control |
| * @return the menu control |
| */ |
| public Menu createContextMenu(Control parent) { |
| if (!menuExist()) { |
| menu = new Menu(parent); |
| initializeMenu(); |
| } |
| return menu; |
| } |
| /** |
| * Creates and returns an SWT menu bar control for this menu, |
| * for use in the given <code>Decorations</code>, and installs all registered |
| * contributions. Does not create a new control if one already exists. |
| * |
| * @param parent the parent decorations |
| * @return the menu control |
| * @since 2.1 |
| */ |
| public Menu createMenuBar(Decorations parent) { |
| if (!menuExist()) { |
| menu = new Menu(parent, SWT.BAR); |
| update(false); |
| } |
| return menu; |
| } |
| /** |
| * Creates and returns an SWT menu bar control for this menu, for use in the |
| * given <code>Shell</code>, and installs all registered contributions. Does not |
| * create a new control if one already exists. This implementation simply calls |
| * the <code>createMenuBar(Decorations)</code> method |
| * |
| * @param parent the parent decorations |
| * @return the menu control |
| * @deprecated use <code>createMenuBar(Decorations)</code> instead. |
| */ |
| public Menu createMenuBar(Shell parent) { |
| return createMenuBar((Decorations)parent); |
| } |
| /** |
| * Disposes of this menu manager and frees all allocated SWT resources. |
| * Notifies all contribution items of the dispose. Note that this method does |
| * not clean up references between this menu manager and its associated |
| * contribution items. Use <code>removeAll</code> for that purpose. |
| */ |
| public void dispose() { |
| if (menuExist()) |
| menu.dispose(); |
| menu = null; |
| |
| if (menuItem != null) { |
| menuItem.dispose(); |
| menuItem = null; |
| } |
| |
| IContributionItem[] items = getItems(); |
| for (int i = 0; i < items.length; i++) { |
| items[i].dispose(); |
| } |
| } |
| /* (non-Javadoc) |
| * Method declared on IContributionItem. |
| */ |
| public void fill(Composite parent) {} |
| /* (non-Javadoc) |
| * Method declared on IContributionItem. |
| */ |
| public void fill(Menu parent, int index) { |
| if (menuItem == null || menuItem.isDisposed()) { |
| if (index >= 0) |
| menuItem = new MenuItem(parent, SWT.CASCADE, index); |
| else |
| menuItem = new MenuItem(parent, SWT.CASCADE); |
| |
| menuItem.setText(menuText); |
| |
| if (!menuExist()) |
| menu = new Menu(parent); |
| |
| menuItem.setMenu(menu); |
| |
| initializeMenu(); |
| |
| // populate the submenu, in order to enable accelerators |
| // and to set enabled state on the menuItem properly |
| update(true); |
| } |
| } |
| /* (non-Javadoc) |
| * Method declared on IContributionItem. |
| */ |
| public void fill(ToolBar parent, int index) {} |
| /* (non-Javadoc) |
| * Method declared on IMenuManager. |
| */ |
| public IMenuManager findMenuUsingPath(String path) { |
| IContributionItem item = findUsingPath(path); |
| if (item instanceof IMenuManager) |
| return (IMenuManager) item; |
| return null; |
| } |
| /* (non-Javadoc) |
| * Method declared on IMenuManager. |
| */ |
| public IContributionItem findUsingPath(String path) { |
| String id = path; |
| String rest = null; |
| int separator = path.indexOf('/'); |
| if (separator != -1) { |
| id = path.substring(0, separator); |
| rest = path.substring(separator + 1); |
| } else { |
| return super.find(path); |
| } |
| |
| IContributionItem item = super.find(id); |
| if (item instanceof IMenuManager) { |
| IMenuManager manager = (IMenuManager) item; |
| return manager.findUsingPath(rest); |
| } |
| return null; |
| } |
| /** |
| * Notifies any menu listeners that a menu is about to show. |
| * Only listeners registered at the time this method is called are notified. |
| * |
| * @param manager the menu manager |
| * |
| * @see IMenuListener#menuAboutToShow |
| */ |
| private void fireAboutToShow(IMenuManager manager) { |
| Object[] listeners = this.listeners.getListeners(); |
| for (int i = 0; i < listeners.length; ++i) { |
| ((IMenuListener) listeners[i]).menuAboutToShow(manager); |
| } |
| } |
| /** |
| * Returns the menu id. |
| * The menu id is used when creating a contribution item |
| * for adding this menu as a sub menu of another. |
| * |
| * @return the menu id |
| */ |
| public String getId() { |
| return id; |
| } |
| /** |
| * Returns the SWT menu control for this menu manager. |
| * |
| * @return the menu control |
| */ |
| public Menu getMenu() { |
| return menu; |
| } |
| /** |
| * Returns the text shown in the menu. |
| * |
| * @return the menu text |
| */ |
| public String getMenuText() { |
| return menuText; |
| } |
| /* (non-Javadoc) |
| * Method declared on IContributionManager. |
| */ |
| public IContributionManagerOverrides getOverrides() { |
| if (overrides == null) { |
| if (parent == null) { |
| overrides = new IContributionManagerOverrides() { |
| public Boolean getEnabled(IContributionItem item) { |
| return null; |
| } |
| public Integer getAccelerator(IContributionItem item) { |
| return null; |
| } |
| public String getAcceleratorText(IContributionItem item) { |
| return null; |
| } |
| public String getText(IContributionItem item) { |
| return null; |
| } |
| }; |
| } else { |
| overrides = parent.getOverrides(); |
| } |
| super.setOverrides(overrides); |
| } |
| return overrides; |
| } |
| |
| /** |
| * Returns the parent contribution manager of this manger. |
| * |
| * @return the parent contribution manager |
| * @since 2.0 |
| */ |
| public IContributionManager getParent() { |
| return parent; |
| } |
| |
| /* (non-Javadoc) |
| * Method declared on IMenuManager. |
| */ |
| public boolean getRemoveAllWhenShown() { |
| return removeAllWhenShown; |
| } |
| /** |
| * Notifies all listeners that this menu is about to appear. |
| */ |
| private void handleAboutToShow() { |
| if (removeAllWhenShown) |
| removeAll(); |
| fireAboutToShow(this); |
| update(false,true); |
| } |
| /** |
| * Initializes the menu control. |
| */ |
| private void initializeMenu() { |
| menu.addMenuListener(new MenuAdapter() { |
| public void menuShown(MenuEvent e) { |
| handleAboutToShow(); |
| } |
| public void menuHidden(MenuEvent e) { |
| // ApplicationWindow.resetDescription(e.widget); |
| } |
| }); |
| markDirty(); |
| // Don't do an update(true) here, in case menu is never opened. |
| // Always do it lazily in handleAboutToShow(). |
| } |
| /* (non-Javadoc) |
| * Method declared on IContributionItem. |
| */ |
| public boolean isDynamic() { |
| return false; |
| } |
| /** |
| * Returns whether this menu should be enabled or not. |
| * Used to enable the menu item containing this menu when it is realized as a sub-menu. |
| * <p> |
| * The default implementation of this framework method |
| * returns <code>true</code>. Subclasses may reimplement. |
| * </p> |
| * |
| * @return <code>true</code> if enabled, and |
| * <code>false</code> if disabled |
| */ |
| public boolean isEnabled() { |
| return true; |
| } |
| /* (non-Javadoc) |
| * Method declared on IContributionItem. |
| */ |
| public boolean isGroupMarker() { |
| return false; |
| } |
| /* (non-Javadoc) |
| * Method declared on IContributionItem. |
| */ |
| public boolean isSeparator() { |
| return false; |
| } |
| /* (non-Javadoc) |
| * Method declared on IContributionItem. |
| */ |
| public boolean isSubstituteFor(IContributionItem item) { |
| return this.equals(item); |
| } |
| /* (non-Javadoc) |
| * Method declared on IContributionItem. |
| */ |
| public boolean isVisible() { |
| return visible; |
| } |
| /** |
| * Returns whether the menu control is created |
| * and not disposed. |
| * |
| * @return <code>true</code> if the control is created |
| * and not disposed, <code>false</code> otherwise |
| */ |
| private boolean menuExist() { |
| return menu != null && !menu.isDisposed(); |
| } |
| /* (non-Javadoc) |
| * Method declared on IMenuManager. |
| */ |
| public void removeMenuListener(IMenuListener listener) { |
| listeners.remove(listener); |
| } |
| /* (non-Javadoc) |
| * Method declared on IMenuManager. |
| */ |
| public void setRemoveAllWhenShown(boolean removeAll) { |
| this.removeAllWhenShown = removeAll; |
| } |
| /* (non-Javadoc) |
| * Method declared on IContributionItem. |
| */ |
| public void setVisible(boolean visible) { |
| this.visible = visible; |
| } |
| /** |
| * Sets the overrides for this contribution manager |
| * |
| * @param newOverrides the overrides for the items of this manager |
| * @since 2.0 |
| */ |
| public void setOverrides(IContributionManagerOverrides newOverrides) { |
| overrides = newOverrides; |
| super.setOverrides(overrides); |
| } |
| /* (non-Javadoc) |
| * Method declared on IContributionItem. |
| */ |
| public void setParent(IContributionManager manager) { |
| parent = manager; |
| } |
| /* (non-Javadoc) |
| * Method declared on IContributionItem. |
| */ |
| public void update() { |
| updateMenuItem(); |
| } |
| /** |
| * The <code>MenuManager</code> implementation of this <code>IContributionManager</code> |
| * updates this menu, but not any of its submenus. |
| * |
| * @see #updateAll |
| */ |
| public void update(boolean force) { |
| update(force, false); |
| } |
| public void update(String property) { |
| IContributionItem items[] = getItems(); |
| for (int i = 0; i < items.length; i++) { |
| items[i].update(property); |
| } |
| if(menu != null && (IAction.TEXT.equals(property))) { |
| String text = getOverrides().getText(this); |
| if(text == null) |
| text = menuText; |
| if(menu == null || menu.isDisposed()) |
| return; |
| if((text != null) && (menu.getParentItem() != null)) |
| menu.getParentItem().setText(text); |
| } |
| } |
| /** |
| * Incrementally builds the menu from the contribution items. |
| * This method leaves out double separators and separators in the first |
| * or last position. |
| * |
| * @param force <code>true</code> means update even if not dirty, |
| * and <code>false</code> for normal incremental updating |
| * @param recursive <code>true</code> means recursively update |
| * all submenus, and <code>false</code> means just this menu |
| */ |
| protected void update(boolean force, boolean recursive) { |
| if (isDirty() || force) { |
| if (menuExist()) { |
| // clean contains all active items without double separators |
| IContributionItem[] items= getItems(); |
| List clean= new ArrayList(items.length); |
| IContributionItem separator= null; |
| for (int i = 0; i < items.length; ++i) { |
| IContributionItem ci= items[i]; |
| if (!ci.isVisible()) |
| continue; |
| if (ci.isSeparator()) { |
| // delay creation until necessary |
| // (handles both adjacent separators, and separator at end) |
| separator= ci; |
| } else { |
| if (separator != null) { |
| if (clean.size() > 0) // no separator if first item |
| clean.add(separator); |
| separator= null; |
| } |
| clean.add(ci); |
| } |
| } |
| |
| // remove obsolete (removed or non active) |
| MenuItem[] mi= menu.getItems(); |
| |
| for (int i= 0; i < mi.length; i++) { |
| if (PERMANENT.equals(mi[i].getData(PERMANENT))) |
| continue; |
| |
| Object data = mi[i].getData(); |
| |
| if (data == null || !clean.contains(data)) { |
| mi[i].dispose(); |
| } else if (data instanceof IContributionItem && |
| ((IContributionItem)data).isDynamic() && |
| ((IContributionItem)data).isDirty()) { |
| mi[i].dispose(); |
| } |
| } |
| |
| // add new |
| mi= menu.getItems(); |
| int srcIx= 0; |
| int destIx= 0; |
| |
| for (Iterator e= clean.iterator(); e.hasNext();) { |
| IContributionItem src= (IContributionItem) e.next(); |
| IContributionItem dest; |
| |
| while (srcIx < mi.length && PERMANENT.equals(mi[srcIx].getData(PERMANENT))) { |
| srcIx++; |
| destIx++; |
| } |
| |
| // get corresponding item in SWT widget |
| if (srcIx < mi.length) |
| dest= (IContributionItem) mi[srcIx].getData(); |
| else |
| dest= null; |
| |
| if (dest != null && src.equals(dest)) { |
| srcIx++; |
| destIx++; |
| } else if (dest != null && dest.isSeparator() && src.isSeparator()) { |
| mi[srcIx].setData(src); |
| srcIx++; |
| destIx++; |
| } else { |
| int start= menu.getItemCount(); |
| src.fill(menu, destIx); |
| int newItems= menu.getItemCount()-start; |
| for (int i= 0; i < newItems; i++) { |
| MenuItem item = menu.getItem(destIx++); |
| item.setData(src); |
| } |
| } |
| |
| // May be we can optimize this call. If the menu has just |
| // been created via the call src.fill(fMenuBar, destIx) then |
| // the menu has already been updated with update(true) |
| // (see MenuManager). So if force is true we do it again. But |
| // we can't set force to false since then information for the |
| // sub sub menus is lost. |
| if (recursive) { |
| IContributionItem item = src; |
| if (item instanceof SubContributionItem) |
| item = ((SubContributionItem)item).getInnerItem(); |
| if (item instanceof IMenuManager) |
| ((IMenuManager)item).updateAll(force); |
| } |
| |
| } |
| |
| // remove any old menu items not accounted for |
| for (; srcIx < mi.length; srcIx++) { |
| if (!PERMANENT.equals(mi[srcIx].getData(PERMANENT))) |
| mi[srcIx].dispose(); |
| } |
| |
| setDirty(false); |
| } |
| } else { |
| // I am not dirty. Check if I must recursivly walk down the hierarchy. |
| if (recursive) { |
| IContributionItem[] items= getItems(); |
| for (int i = 0; i < items.length; ++i) { |
| IContributionItem ci= items[i]; |
| if (ci instanceof IMenuManager) { |
| IMenuManager mm = (IMenuManager) ci; |
| if (mm.isVisible()) { |
| mm.updateAll(force); |
| } |
| } |
| } |
| } |
| } |
| updateMenuItem(); |
| } |
| /* (non-Javadoc) |
| * Method declared on IMenuManager. |
| */ |
| public void updateAll(boolean force) { |
| update(force, true); |
| } |
| /** |
| * Updates the menu item for this sub menu. |
| * The menu item is disabled if this sub menu is empty. |
| * Does nothing if this menu is not a submenu. |
| */ |
| private void updateMenuItem() { |
| /* |
| * Commented out until proper solution to enablement of |
| * menu item for a sub-menu is found. See bug 30833 for |
| * more details. |
| * |
| if (menuItem != null && !menuItem.isDisposed() && menuExist()) { |
| IContributionItem items[] = getItems(); |
| boolean enabled = false; |
| for (int i = 0; i < items.length; i++) { |
| IContributionItem item = items[i]; |
| enabled = item.isEnabled(); |
| if(enabled) break; |
| } |
| // Workaround for 1GDDCN2: SWT:Linux - MenuItem.setEnabled() always causes a redraw |
| if (menuItem.getEnabled() != enabled) |
| menuItem.setEnabled(enabled); |
| } |
| */ |
| // Partial fix for bug #34969 - diable the menu item if no |
| // items in sub-menu (for context menus). |
| if (menuItem != null && !menuItem.isDisposed() && menuExist()) { |
| boolean enabled = menu.getItemCount() > 0; |
| // Workaround for 1GDDCN2: SWT:Linux - MenuItem.setEnabled() always causes a redraw |
| if (menuItem.getEnabled() != enabled) { |
| // We only do this for context menus (for bug #34969) |
| Menu topMenu = menu; |
| while (topMenu.getParentMenu() != null) |
| topMenu = topMenu.getParentMenu(); |
| if ((topMenu.getStyle() & SWT.BAR) == 0) |
| menuItem.setEnabled(enabled); |
| } |
| } |
| } |
| |
| } |