ActionMenuManager.java

/******************************************************************************
 * Copyright (c) 2002, 2008 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.gmf.runtime.common.ui.action;

import org.eclipse.gmf.runtime.common.core.util.Log;
import org.eclipse.gmf.runtime.common.ui.internal.CommonUIPlugin;
import org.eclipse.gmf.runtime.common.ui.internal.CommonUIStatusCodes;
import org.eclipse.jface.action.AbstractGroupMarker;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IContributionManager;
import org.eclipse.jface.action.IMenuCreator;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.SubContributionItem;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.ui.actions.LabelRetargetAction;

/**
 * An implementation of an <code>IMenuManager</code> that inherits its
 * UI (text + icon + hints) from a given action. 
 * 
 * When filled in a toolbar, the menu is rendered as a tool item
 * with two parts: a button, whose icon comes from the supplied
 * action handler, and a drop-down menu arrow.
 * When the arrow is pressed, the drop-down menu is shown. When the
 * button is pressed, the associated action is executed. The manager can have
 * an optional style to retarget the last executed action. In this
 * case the tool item UI reflects the last executed sub-action from the menu.
 * 
 * When filled in a menu, this menu shows up as a normal cascading menu with 
 * its GUI inherited from the supplied action.
 *  
 * @author melaasar
 */
public class ActionMenuManager extends MenuManager {

    /**
     * An action that provides a menu and fills it from the contribution
     * items of the enclosing menu manager. It also retargets to the
     * manager's supplied action handler.
     */
    public class MenuCreatorAction
        extends LabelRetargetAction
        implements IMenuCreator {
        // the menu widget
        private Menu menu;

        // menu item selection listener: listens to selection events
        private Listener menuItemListener = new Listener() {
            public void handleEvent(Event event) {
                if (SWT.Selection == event.type
                    && !event.widget.isDisposed()) {
                    ActionContributionItem item =
                        (ActionContributionItem) event.widget.getData();
                    if (retargetLastAction) {
                        setActionHandler(item.getAction());
                        setDefaultAction(item.getAction());
                    }
                    subActionSelected(item.getAction());
                }
            }
        };

        /**
         * Creates a new menu creator action
         * 
         * @param actionHandler the action handler
         */
        public MenuCreatorAction(IAction actionHandler) {
            super(actionHandler.getId(), actionHandler.getText());
            setEnabled(false); // initially untill a menu item is added
            setActionHandler(actionHandler);
            setMenuCreator(this);
        }

        /* (non-Javadoc)
         * @see org.eclipse.jface.action.IMenuCreator#getMenu(org.eclipse.swt.widgets.Control)
         */
        public Menu getMenu(Control parent) {
            if (menu != null)
                menu.dispose();

            menu = new Menu(parent);
            return createMenu(menu);
        }

        /* (non-Javadoc)
         * @see org.eclipse.jface.action.IMenuCreator#getMenu(org.eclipse.swt.widgets.Menu)
         */
        public Menu getMenu(Menu parent) {
            if (menu != null)
                menu.dispose();
            menu = new Menu(parent);
            return createMenu(menu);
        }

        /* (non-Javadoc)
         * @see org.eclipse.ui.actions.ActionFactory.IWorkbenchAction#dispose()
         */
        public void dispose() {
            if (menu != null) {
                menu.dispose();
                menu = null;
            }
            super.dispose();
            ActionMenuManager.this.dispose();
        }

        /**
         * Create the drop-down/pop-up menu.
         * 
         * @param mnu <code>Menu</code> for which to create the drop-down/pop-up menu
         * @return <code>Menu</code> the drop-down/pop-up menu 
         */
        protected Menu createMenu(Menu mnu) {
            IContributionItem[] items = getRealItems();
            IContributionItem lastGroupMarker = null;
            for (int i = 0; i < items.length; i++) {
                IContributionItem item = items[i];
                if (item instanceof AbstractGroupMarker) {
                    if (i == 0
                        || i == items.length - 1
                        || items[i + 1] instanceof AbstractGroupMarker
                        || mnu.getItemCount() < 1 
                        || !item.isVisible()) {
                        continue;
                    } else {
                        // Do not add last group marker until we know that there
                        // will be items following it.
                        lastGroupMarker = item;
                    }
                } else {
                    if (!item.isVisible()) {
                        continue;
                    }
                    try {
                        if (lastGroupMarker != null) {
                            lastGroupMarker.fill(menu, -1);
                            lastGroupMarker = null;
                        }
                        item.fill(menu, -1);
                    } catch (Exception e) {
                        Log.info(CommonUIPlugin.getDefault(), CommonUIStatusCodes.GENERAL_UI_FAILURE, "The contribution item (" + item.getId() + ") failed to fill within the menu"); //$NON-NLS-1$ //$NON-NLS-2$
                    }
                }
            }
            MenuItem menuItems[] = mnu.getItems();
            for (int i = 0; i < menuItems.length; i++) {
                if (menuItems[i].getStyle() == SWT.SEPARATOR)
                    continue;
                menuItems[i].addListener(SWT.Selection, menuItemListener);
            }
            return mnu;
        }

        /**
         * Ignores the action handler's "enable" event since "enablement"
         * is determined by the sub-action(s) enablement state
         * 
         */
        protected void propagateChange(PropertyChangeEvent event) {
            if (!event.getProperty().equals(Action.ENABLED))
                super.propagateChange(event);
        }

        /**
         * Ignores the action handler's "enable" event since "enablement"
         * is determined by the sub-action(s)
         * 
         */
        protected void setActionHandler(IAction handler) {
            boolean enabled = MenuCreatorAction.this.isEnabled();
            super.setActionHandler(handler);
            MenuCreatorAction.this.setEnabled(enabled);
        }
        
        /**
         * Only run the action handler if it is enabled
         * 
         */
        public void run() {
            if (getActionHandler() != null && getActionHandler().isEnabled())
                super.run();
            else if (getDefaultAction().isEnabled()) {
                setActionHandler(getDefaultAction());
                super.run();
           }
        }

        /**
         * Only run the action handler if it is enabled
         * 
         */
        public void runWithEvent(Event event) {
            if (getActionHandler() != null && getActionHandler().isEnabled())
                super.runWithEvent(event);
            else if (getDefaultAction().isEnabled()) {
                 setActionHandler(getDefaultAction());
                 super.runWithEvent(event);
            }
        }

    }

    /** the associated menu action */
    protected final MenuCreatorAction action;

    /** the associated menu action */
    protected IAction defaultAction = null;

    /** the delege action contribution item */
    private final ActionContributionItem actionContributionItem;

    /** an option to retarget the last action */
    private boolean retargetLastAction;

    /**
     * Creates a new instance of <code>ActionMenuManager</code> with
     * a given action handler. The manager does not retarget the last
     * selected action from the menu
     * 
     * @param id The menu manager id
     * @param actionHandler the menu associated action handler
     */
    public ActionMenuManager(String id, IAction actionHandler) {
        this(id, actionHandler, false);
    }

    /**
     * Creates a new instance of <code>ActionMenuManager</code> with
     * a given action handler and an option to retarget the last 
     * executed menu action.
     * 
     * @param id The menu manager id
     * @param actionHandler the menu associated action handler
     * @param retargetLastAction whether to retarget the last action or not
     */
    public ActionMenuManager(
        String id,
        IAction actionHandler,
        boolean retargetLastAction) {
        super(actionHandler.getText(), id);
        assert null != actionHandler;
        action = new MenuCreatorAction(actionHandler);
        defaultAction = actionHandler;
        actionContributionItem = new ActionContributionItem(action);
        this.retargetLastAction = retargetLastAction;
    }

    /**
     * Returns whether the option to retarget last action was requested
     * 
     * @return <code>true</code> if retargetLastAction is enabled, <code>false</code> otherwise
     */
    protected boolean isRetargetLastAction() {
        return retargetLastAction;
    }

    /**
     * Handle subaction selection
     * 
     * @param subActionHandler The selected sub action handler
     */
    protected void subActionSelected(IAction subActionHandler) {
         /* method not implemented */
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#fill(org.eclipse.swt.widgets.Composite)
     */
    public void fill(Composite parent) {
        // this is only relevant in toolbars
        retargetLastAction = false;
        actionContributionItem.fill(parent);
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#fill(org.eclipse.swt.widgets.Menu, int)
     */
    public void fill(Menu parent, int index) {
        // this is only relevant in toolbars
        retargetLastAction = false;
        actionContributionItem.fill(parent, index);
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#fill(org.eclipse.swt.widgets.ToolBar, int)
     */
    public void fill(ToolBar parent, int index) {
        actionContributionItem.fill(parent, index);
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#dispose()
     */
    public void dispose() {
        actionContributionItem.dispose();
        super.dispose();
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#isEnabled()
     */
    public boolean isEnabled() {
        return actionContributionItem.isEnabled();
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionManager#isDirty()
     */
    public boolean isDirty() {
        return actionContributionItem.isDirty();
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#isDynamic()
     */
    public boolean isDynamic() {
        return actionContributionItem.isDynamic();
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#isGroupMarker()
     */
    public boolean isGroupMarker() {
        return actionContributionItem.isGroupMarker();
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#isSeparator()
     */
    public boolean isSeparator() {
        return actionContributionItem.isSeparator();
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#isVisible()
     */
    public boolean isVisible() {
        IContributionItem[] items = getRealItems();
        for (int i = 0; i < items.length; i++) {
            IContributionItem item = items[i];
            if (!(item instanceof AbstractGroupMarker) && item.isVisible()) {
                return actionContributionItem.isVisible();
            }
        }
        return false;
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#setParent(org.eclipse.jface.action.IContributionManager)
     */
    public void setParent(IContributionManager parent) {
        actionContributionItem.setParent(parent);
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#setVisible(boolean)
     */
    public void setVisible(boolean visible) {
        actionContributionItem.setVisible(visible);
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#update()
     */
    public void update() {
        actionContributionItem.update();
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#update(java.lang.String)
     */
    public void update(String id) {
        actionContributionItem.update(id);
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IMenuManager#updateAll(boolean)
     */
    public void updateAll(boolean force) {
        update(force);

        IContributionItem[] items = getRealItems();
        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);
                }
            }
        }
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionManager#update(boolean)
     */
    public void update(boolean force) {
        update();
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.ContributionManager#itemAdded(org.eclipse.jface.action.IContributionItem)
     */
    protected void itemAdded(IContributionItem item) {
        super.itemAdded(item);
        if (item instanceof SubContributionItem)
            item = ((SubContributionItem) item).getInnerItem();
        if (!item.isGroupMarker())
            action.setEnabled(true);
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.ContributionManager#itemRemoved(org.eclipse.jface.action.IContributionItem)
     */
    protected void itemRemoved(IContributionItem item) {
        super.itemRemoved(item);
        if (item instanceof SubContributionItem)
            item = ((SubContributionItem) item).getInnerItem();
        if (!item.isGroupMarker()) {
            action.setEnabled(false);
            IContributionItem[] items = getItems();
            for (int i = 0; i < items.length; i++)
                if (!items[i].isGroupMarker()){
                    action.setEnabled(true);
                    break;
                }
        }
    }

    /**
     * Returns the contribution items of this manager. If an item
     * is wrapper in a SubContributionItem instance it extracts the
     * real item instance
     * 
     * @return An array of real items of this contribution manager 
     */
    protected IContributionItem[] getRealItems() {
        IContributionItem[] items = getItems();
        IContributionItem[] realItems = new IContributionItem[items.length];
        for (int i = 0; i < items.length; i++) {
                if (items[i] instanceof SubContributionItem) {
                realItems[i] = ((SubContributionItem) items[i]).getInnerItem();
                } else {
                    realItems[i] = items[i];
                }
        }
        return realItems;
    }

    
    public IAction getDefaultAction() {
        return defaultAction;
    }

    
    protected void setDefaultAction(IAction defaultAction) {
        this.defaultAction = defaultAction;
    }

}