/*******************************************************************************
 * Copyright (c) 2000, 2009 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;

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

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.dynamichelpers.IExtensionTracker;
import org.eclipse.jface.action.AbstractGroupMarker;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.GroupMarker;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IContributionManager;
import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.internal.registry.ActionSetRegistry;
import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;
import org.eclipse.ui.services.IDisposable;

/**
 * This builder reads the actions for an action set from the registry.
 */
public class PluginActionSetBuilder extends PluginActionBuilder {

    private PluginActionSet actionSet;

    private IWorkbenchWindow window;

    private ArrayList adjunctContributions = new ArrayList(0);
    
    /**
     * Used by the workbench window extension handler to unhook action sets from
     * their associated window.
     * 
     * @since 3.1
     */
	public static class Binding implements IDisposable {
        PluginActionSetBuilder builder;
        PluginActionSet set;
        IWorkbenchWindow window;
		IExtensionTracker tracker;

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.ui.services.IDisposable#dispose()
		 */
		public void dispose() {
			if (tracker != null) {
				tracker.unregisterObject(set.getConfigElement()
						.getDeclaringExtension(), this);
				tracker = null;
			}
		}
    }

    /**
     * Constructs a new builder.
     */
    public PluginActionSetBuilder() {
    }

    /**
     * Read the actions within a config element. Called by customize perspective
     * 
     * @param set the action set
     * @param window the window to contribute to
     */
    public void buildMenuAndToolBarStructure(PluginActionSet set,
            IWorkbenchWindow window) {
        this.actionSet = set;
        this.window = window;
        cache = null;
        currentContribution = null;
        targetID = null;
        targetContributionTag = IWorkbenchRegistryConstants.TAG_ACTION_SET;

        readElements(new IConfigurationElement[] { set.getConfigElement() });

        if (cache != null) {
            for (int i = 0; i < cache.size(); i++) {
                ActionSetContribution contribution = (ActionSetContribution) cache
                        .get(i);
                contribution.contribute(actionSet.getBars(), true, true);
                if (contribution.isAdjunctContributor()) {
                    adjunctContributions.add(contribution);
                }
            }
        }
        for (int i = 0; i < adjunctContributions.size(); i++) {
            ActionSetContribution contribution = (ActionSetContribution) adjunctContributions
                    .get(i);
            ActionSetActionBars bars = actionSet.getBars();
            for (int j = 0; j < contribution.adjunctActions.size(); j++) {
                ActionDescriptor adjunctAction = (ActionDescriptor) contribution.adjunctActions
                        .get(j);
                contribution
                        .contributeAdjunctCoolbarAction(adjunctAction, bars);
            }
        }
        
        registerBinding(set);
    }

    /* (non-Javadoc)
     * Method declared on PluginActionBuilder.
     */
    protected ActionDescriptor createActionDescriptor(
            IConfigurationElement element) {
        // As of 2.1, the "pulldown" attribute was deprecated and replaced by
        // the attribute "style". See doc for more details.
        boolean pullDownStyle = false;
        String style = element.getAttribute(IWorkbenchRegistryConstants.ATT_STYLE);
        if (style != null) {
            pullDownStyle = style.equals(ActionDescriptor.STYLE_PULLDOWN);
        } else {
            String pulldown = element.getAttribute(ActionDescriptor.STYLE_PULLDOWN);
            pullDownStyle = pulldown != null && pulldown.equals("true"); //$NON-NLS-1$
        }

        ActionDescriptor desc = null;
        if (pullDownStyle) {
			desc = new ActionDescriptor(element,
                    ActionDescriptor.T_WORKBENCH_PULLDOWN, window);
		} else {
			desc = new ActionDescriptor(element, ActionDescriptor.T_WORKBENCH,
                    window);
		}
        WWinPluginAction action = (WWinPluginAction) desc.getAction();
        action.setActionSetId(actionSet.getDesc().getId());
        actionSet.addPluginAction(action);
        return desc;
    }

    /* (non-Javadoc)
     * Method declared on PluginActionBuilder.
     */
    protected BasicContribution createContribution() {
        return new ActionSetContribution(actionSet.getDesc().getId(), window);
    }

    /**
     * Returns the insertion point for a new contribution item.  Clients should
     * use this item as a reference point for insertAfter.
     *
     * @param startId the reference id for insertion
     * @param sortId the sorting id for the insertion.  If null then the item
     *		will be inserted at the end of all action sets.
     * @param mgr the target menu manager.
     * @param startVsEnd if <code>true</code> the items are added at the start of
     *		action with the same id; else they are added to the end
     * @return the insertion point, or null if not found.
     */
    public static IContributionItem findInsertionPoint(String startId,
            String sortId, IContributionManager mgr, boolean startVsEnd) {
        // Get items.
        IContributionItem[] items = mgr.getItems();

        // Find the reference item.
        int insertIndex = 0;
        while (insertIndex < items.length) {
            if (startId.equals(items[insertIndex].getId())) {
				break;
			}
            ++insertIndex;
        }
        if (insertIndex >= items.length) {
			return null;
		}

        // Calculate startVsEnd comparison value.
        int compareMetric = 0;
        if (startVsEnd) {
			compareMetric = 1;
		}

        // Find the insertion point for the new item.
        // We do this by iterating through all of the previous
        // action set contributions define within the current group.
        for (int nX = insertIndex + 1; nX < items.length; nX++) {
            IContributionItem item = items[nX];
            if (item.isSeparator() || item.isGroupMarker()) {
                // Fix for bug report 18357
                break;
            }
            if (item instanceof IActionSetContributionItem) {
                if (sortId != null) {
                    String testId = ((IActionSetContributionItem) item)
                            .getActionSetId();
                    if (sortId.compareTo(testId) < compareMetric) {
						break;
					}
                }
                insertIndex = nX;
            } else {
                break;
            }
        }
        // Return item.
        return items[insertIndex];
    }

    /**
     */
    /* package */static void processActionSets(ArrayList pluginActionSets,
            WorkbenchWindow window) {
        // Process the action sets in two passes.  On the first pass the pluginActionSetBuilder
        // will process base contributions and cache adjunct contributions.  On the second
        // pass the adjunct contributions will be processed.
        PluginActionSetBuilder[] builders = new PluginActionSetBuilder[pluginActionSets
                .size()];
        for (int i = 0; i < pluginActionSets.size(); i++) {
            PluginActionSet set = (PluginActionSet) pluginActionSets.get(i);
            PluginActionSetBuilder builder = new PluginActionSetBuilder();
            builder.readActionExtensions(set, window);
            builders[i] = builder;
        }
        for (int i = 0; i < builders.length; i++) {
            PluginActionSetBuilder builder = builders[i];
            builder.processAdjunctContributions();
        }
    }

    /**
     */
    protected void processAdjunctContributions() {
        // Contribute the adjunct contributions.
        for (int i = 0; i < adjunctContributions.size(); i++) {
            ActionSetContribution contribution = (ActionSetContribution) adjunctContributions
                    .get(i);
            ActionSetActionBars bars = actionSet.getBars();
            for (int j = 0; j < contribution.adjunctActions.size(); j++) {
                ActionDescriptor adjunctAction = (ActionDescriptor) contribution.adjunctActions
                        .get(j);
                contribution
                        .contributeAdjunctCoolbarAction(adjunctAction, bars);
            }
        }
    }

    /**
     * Read the actions within a config element.
     */
    protected void readActionExtensions(PluginActionSet set,
            IWorkbenchWindow window) {
        this.actionSet = set;
        this.window = window;
        cache = null;
        currentContribution = null;
        targetID = null;
        targetContributionTag = IWorkbenchRegistryConstants.TAG_ACTION_SET;

        readElements(new IConfigurationElement[] { set.getConfigElement() });

        if (cache != null) {
            // for dynamic UI - save cache for future removal lf actionset extensions
            //        Don't call addCache -- it's broken, and is only used for dynamic plugin removal,
            //        which the workbench doesn't currently support.
            //        See bug 66374 for more details.
            //			WorkbenchPlugin.getDefault().getActionSetRegistry().addCache(set.getDesc().getId(), cache);
            for (int i = 0; i < cache.size(); i++) {
                ActionSetContribution contribution = (ActionSetContribution) cache
                        .get(i);
                contribution.contribute(actionSet.getBars(), true, true);
                if (contribution.isAdjunctContributor()) {
                    adjunctContributions.add(contribution);
                }
            }
            
            registerBinding(set);
            
        } else {
            WorkbenchPlugin
                    .log("Action Set is empty: " + set.getDesc().getId()); //$NON-NLS-1$
        }
    }
    
    private void registerBinding(final PluginActionSet set) {
    	final IExtensionTracker tracker = window.getExtensionTracker();
    	 
    	// register the new binding
    	final Binding binding = new Binding();
        binding.builder = this;
        binding.set = set;
        binding.window = window;
		binding.tracker = tracker;
        tracker.registerObject(
                set.getConfigElement().getDeclaringExtension(), binding,
                IExtensionTracker.REF_STRONG);
		set.setBuilder(binding);
    }

    /**
     * Helper class to collect the menus and actions defined within a
     * contribution element.
     */
    private static class ActionSetContribution extends BasicContribution {
        private String actionSetId;

        private WorkbenchWindow window;

        protected ArrayList adjunctActions = new ArrayList(0);

        /**
         * Create a new instance of <code>ActionSetContribution</code>.
         * 
         * @param id the id
         * @param window the window to contribute to
         */
        public ActionSetContribution(String id, IWorkbenchWindow window) {
            super();
            actionSetId = id;
            this.window = (WorkbenchWindow) window;
        }

        /**
         * This implementation inserts the group into the action set additions group.  
         */
        protected void addGroup(IContributionManager mgr, String name) {
            IContributionItem refItem = findInsertionPoint(
                    IWorkbenchActionConstants.MB_ADDITIONS, actionSetId, mgr,
                    true);
            // Insert the new group marker.
            ActionSetSeparator group = new ActionSetSeparator(name, actionSetId);
            if (refItem == null) {
                mgr.add(group);
            } else {
                mgr.insertAfter(refItem.getId(), group);
            }
        }

        /**
         * Contributes submenus and/or actions into the provided menu and tool bar
         * managers.
         * 
         * @param bars the action bars to contribute to
         * @param menuAppendIfMissing append to the menubar if missing
         * @param toolAppendIfMissing append to the toolbar if missing
         */
        public void contribute(IActionBars bars, boolean menuAppendIfMissing,
                boolean toolAppendIfMissing) {

            IMenuManager menuMgr = bars.getMenuManager();
            IToolBarManager toolBarMgr = bars.getToolBarManager();
            if (menus != null && menuMgr != null) {
                for (int i = 0; i < menus.size(); i++) {
                    IConfigurationElement menuElement = (IConfigurationElement) menus
                            .get(i);
                    contributeMenu(menuElement, menuMgr, menuAppendIfMissing);
                }
            }

            if (actions != null) {
                for (int i = 0; i < actions.size(); i++) {
                    ActionDescriptor ad = (ActionDescriptor) actions.get(i);
                    if (menuMgr != null) {
						contributeMenuAction(ad, menuMgr, menuAppendIfMissing);
					}
                    if (toolBarMgr != null) {
                        if (bars instanceof ActionSetActionBars) {
                            contributeCoolbarAction(ad,
                                    (ActionSetActionBars) bars);
                        } else {
                            contributeToolbarAction(ad, toolBarMgr,
                                    toolAppendIfMissing);
                        }
                    }
                }
            }
        }

        /**
         * Contributes action from the action descriptor into the cool bar manager.
         */
        protected void contributeAdjunctCoolbarAction(ActionDescriptor ad,
                ActionSetActionBars bars) {
            String toolBarId = ad.getToolbarId();
            String toolGroupId = ad.getToolbarGroupId();

            String contributingId = bars.getActionSetId();
            ICoolBarManager coolBarMgr = bars.getCoolBarManager();
            if (coolBarMgr == null) {
                return;
            }

            PluginAction action = ad.getAction();
            ActionContributionItem actionContribution = new PluginActionCoolBarContributionItem(
                    action);
            actionContribution.setMode(ad.getMode());

            bars.addAdjunctContribution(actionContribution);

            // create a coolitem for the toolbar id if it does not yet exist				
            IToolBarManager toolBarManager = bars.getToolBarManager(toolBarId);

            // Check to see if the group already exists
            IContributionItem groupMarker = toolBarManager.find(toolGroupId);
            // Add a group marker if one does not exist
            if (groupMarker == null) {
                toolBarManager.add(new Separator(toolGroupId));
            }
            IContributionItem refItem = findAlphabeticalOrder(toolGroupId,
                    contributingId, toolBarManager);
            if (refItem != null && refItem.getId() != null) {
                toolBarManager.insertAfter(refItem.getId(), actionContribution);
            } else {
                toolBarManager.add(actionContribution);
            }
            toolBarManager.update(false);

        }

        /**
         * Contributes action from the action descriptor into the cool bar manager.
         */
        protected void contributeCoolbarAction(ActionDescriptor ad,
                ActionSetActionBars bars) {
            String toolBarId = ad.getToolbarId();
            String toolGroupId = ad.getToolbarGroupId();
            if (toolBarId == null && toolGroupId == null) {
				return;
			}

            String contributingId = bars.getActionSetId();

            if (toolBarId == null || toolBarId.equals("")) { //$NON-NLS-1$ 
                // the item is being added to the coolitem for its action set
                toolBarId = contributingId;
            }

            if (!toolBarId.equals(contributingId)) {
                // adding to another action set, validate the id
                if (!isValidCoolItemId(toolBarId, window)) {
                    // toolbarid not valid, add the item to the coolitem for its action set
                    toolBarId = contributingId;
                } else {
                    adjunctActions.add(ad);
                    return;
                }
            }

            // Create the action
            PluginAction action = ad.getAction();
            ActionContributionItem actionContribution = new PluginActionCoolBarContributionItem(
                    action);
            actionContribution.setMode(ad.getMode());

            // retreive the toolbar from the action bars.
            IToolBarManager toolBar = bars.getToolBarManager(toolBarId);

            // Check to see if the group already exists
            IContributionItem groupMarker = toolBar.find(toolGroupId);
            // Add a group marker if one does not exist
            if (groupMarker == null) {
                // @issue should this be a GroupMarker?
                toolBar.add(new Separator(toolGroupId));
            }
            toolBar.prependToGroup(toolGroupId, actionContribution);
            toolBar.update(false);

        }

        /**
         * Checks to see if the cool item id is in the given window.
         */
        private boolean isValidCoolItemId(String id, WorkbenchWindow window) {
            ActionSetRegistry registry = WorkbenchPlugin.getDefault()
                    .getActionSetRegistry();
            if (registry.findActionSet(id) != null) {
				return true;
			}
            if (window != null) {
                return window.isWorkbenchCoolItemId(id);
            }
            return false;
        }

        /* (non-Javadoc)
         * Method declared on Basic Contribution.
         */
        protected void insertMenuGroup(IMenuManager menu,
                AbstractGroupMarker marker) {
            if (actionSetId != null) {
                IContributionItem[] items = menu.getItems();
                // Loop thru all the current groups looking for the first
                // group whose id > than the current action set id. Insert
                // current marker just before this item then.
                for (int i = 0; i < items.length; i++) {
                    IContributionItem item = items[i];
                    if (item.isSeparator() || item.isGroupMarker()) {
                        if (item instanceof IActionSetContributionItem) {
                            String testId = ((IActionSetContributionItem) item)
                                    .getActionSetId();
                            if (actionSetId.compareTo(testId) < 0) {
                                menu.insertBefore(items[i].getId(), marker);
                                return;
                            }
                        }
                    }
                }
            }

            menu.add(marker);
        }

        private IContributionItem findAlphabeticalOrder(String startId,
                String itemId, IContributionManager mgr) {
            IContributionItem[] items = mgr.getItems();
            int insertIndex = 0;

            // look for starting point
            while (insertIndex < items.length) {
                IContributionItem item = items[insertIndex];
                if (startId != null && startId.equals(item.getId())) {
					break;
				}
                ++insertIndex;
            }

            // Find the index that this item should be inserted in
            for (int i = insertIndex + 1; i < items.length; i++) {
                IContributionItem item = items[i];
                if (item.isGroupMarker()) {
					break;
				}

                String testId = null;
                if (item instanceof PluginActionCoolBarContributionItem) {
                    testId = ((PluginActionCoolBarContributionItem) item)
                            .getActionSetId();
                }
                if (testId == null) {
                    break;
                }

                if (itemId != null && testId != null) {
                    if (itemId.compareTo(testId) < 1) {
						break;
					}
                }
                insertIndex = i;
            }
            if (insertIndex >= items.length) {
                return null;
            }
            return items[insertIndex];
        }

        /**
         * Returns whether the contributor is an adjunct contributor.
         * 
         * @return whether the contributor is an adjunct contributor
         */
        public boolean isAdjunctContributor() {
            return adjunctActions.size() > 0;
        }

        /* (non-Javadoc)
         * Method declared on Basic Contribution.
         */
        protected void insertAfter(IContributionManager mgr, String refId,
                IContributionItem item) {
            IContributionItem refItem = findInsertionPoint(refId, actionSetId,
                    mgr, true);
            if (refItem != null) {
                mgr.insertAfter(refItem.getId(), item);
            } else {
                WorkbenchPlugin
                        .log("Reference item " + refId + " not found for action " + item.getId()); //$NON-NLS-1$ //$NON-NLS-2$
            }
        }

        //for dynamic UI
        protected void revokeContribution(WorkbenchWindow window,
                IActionBars bars, String id) {
            revokeActionSetFromMenu(window.getMenuManager(), id);
            //			IMenuManager menuMgr = bars.getMenuManager();
            //			if (menuMgr != null) 
            //				revokeActionSetFromMenu(menuMgr, id);

            revokeActionSetFromCoolbar(window.getCoolBarManager2(), id);
            //			IToolBarManager toolBarMgr = bars.getToolBarManager();
            //			if (toolBarMgr != null && toolBarMgr instanceof CoolItemToolBarManager) 
            //				revokeActionSetFromToolbar(toolBarMgr, id);
        }

        //for dynamic UI
        protected void revokeAdjunctCoolbarAction(ActionDescriptor ad,
                ActionSetActionBars bars) {
            String toolBarId = ad.getToolbarId();
//            String toolGroupId = ad.getToolbarGroupId();
//
//            String contributingId = bars.getActionSetId();
            ICoolBarManager coolBarMgr = bars.getCoolBarManager();
            //				((CoolItemToolBarManager)bars.getToolBarManager()).getParentManager();
            PluginAction action = ad.getAction();
            PluginActionCoolBarContributionItem actionContribution = new PluginActionCoolBarContributionItem(
                    action);
            actionContribution.setMode(ad.getMode());

            bars.removeAdjunctContribution(actionContribution);

            // remove a coolitem for the toolbar id if it exists 			
            IContributionItem cbItem = coolBarMgr.find(toolBarId);
            if (cbItem != null) {
				coolBarMgr.remove(cbItem);
			}

            //			activeManager = cbItem.getToolBarManager();	
            //			activeManager.remove(contributingId);	
            //			IContributionItem groupMarker = activeManager.find(toolGroupId);
            //			if (groupMarker != null) {
            //				int idx = activeManager.indexOf(toolGroupId);
            //				IContributionItem[] items = activeManager.getItems();
            //				if (items.length == idx+1 || 
            //						((items.length > idx && items[idx+1] instanceof Separator)))
            //					if (activeManager.find(toolGroupId) != null)
            //						activeManager.remove(toolGroupId);
            //			} 			
            //			activeManager.addAdjunctItemToGroup(toolGroupId, contributingId, actionContribution);		 
        }

        //for dynamic UI
        private void revokeActionSetFromMenu(IMenuManager menuMgr,
                String actionsetId) {
            IContributionItem[] items = menuMgr.getItems();
            ArrayList itemsToRemove = new ArrayList();
            String id;
            for (int i = 0; i < items.length; i++) {
				if (items[i] instanceof IMenuManager) {
                    revokeActionSetFromMenu((IMenuManager) items[i],
                            actionsetId);
                } else if (items[i] instanceof ActionSetContributionItem) {
                    id = ((ActionSetContributionItem) items[i])
                            .getActionSetId();
                    if (actionsetId.equals(id)) {
						itemsToRemove.add(items[i]);
					}
                } else if (items[i] instanceof Separator) {
                    id = ((Separator) items[i]).getId();
                    if (actionsetId.equals(id)) {
						itemsToRemove.add(items[i]);
					}
                } else if (items[i] instanceof GroupMarker) {
                    id = ((GroupMarker) items[i]).getId();
                    if (actionsetId.equals(id)) {
						itemsToRemove.add(items[i]);
					}
                }
			}
            Iterator iter = itemsToRemove.iterator();
            while (iter.hasNext()) {
                IContributionItem item = (IContributionItem) iter.next();
                menuMgr.remove(item);
            }
            menuMgr.update(true);
        }

        // for dynamic UI
        private void revokeActionSetFromCoolbar(ICoolBarManager coolbarMgr,
                String actionsetId) {
            IContributionItem[] items = coolbarMgr.getItems();
            ArrayList itemsToRemove = new ArrayList();
            String id;
            for (int i = 0; i < items.length; i++) {
                id = items[i].getId();
                if (actionsetId.equals(id)) {
                    itemsToRemove.add(items[i]);
                    continue;
                }
                if (items[i] instanceof IToolBarManager) {
                    revokeActionSetFromToolbar((IToolBarManager) items[i],
                            actionsetId);
                } else if (items[i] instanceof IToolBarContributionItem) {
                    id = ((IToolBarContributionItem) items[i]).getId();
                    if (actionsetId.equals(id)) {
						itemsToRemove.add(items[i]);
					}
                } else if (items[i] instanceof GroupMarker) {
                    id = ((GroupMarker) items[i]).getId();
                    if (actionsetId.equals(id)) {
						itemsToRemove.add(items[i]);
					}
                }
            }
            Iterator iter = itemsToRemove.iterator();
            while (iter.hasNext()) {
				coolbarMgr.remove((IContributionItem) iter.next());
			}
            coolbarMgr.update(true);
        }

        // for dynamic UI
        private void revokeActionSetFromToolbar(IToolBarManager toolbarMgr,
                String actionsetId) {
            IContributionItem[] items = toolbarMgr.getItems();
            ArrayList itemsToRemove = new ArrayList();
            String id;
            for (int i = 0; i < items.length; i++) {
                id = items[i].getId();
                if (id.equals(actionsetId)) {
                    itemsToRemove.add(items[i]);
                    continue;
                }
                if (items[i] instanceof PluginActionCoolBarContributionItem) {
                    id = ((PluginActionCoolBarContributionItem) items[i])
                            .getActionSetId();
                    if (actionsetId.equals(id)) {
						itemsToRemove.add(items[i]);
					}
                } else if (items[i] instanceof ActionContributionItem) {
                    id = ((ActionContributionItem) items[i]).getId();
                    if (actionsetId.equals(id)) {
						itemsToRemove.add(items[i]);
					}
                } else if (items[i] instanceof GroupMarker) {
                    id = ((GroupMarker) items[i]).getId();
                    if (actionsetId.equals(id)) {
						itemsToRemove.add(items[i]);
					}
                }
            }
            Iterator iter = itemsToRemove.iterator();
            while (iter.hasNext()) {
				toolbarMgr.remove((IContributionItem) iter.next());
			}
            toolbarMgr.update(true);
        }
    }


    /**
     * Remove the given action set from the window.
     * 
     * @param set the set to remove
     * @param window the window to remove from
     */
    protected void removeActionExtensions(PluginActionSet set,
            IWorkbenchWindow window) {
        this.actionSet = set;
        this.window = window;
        currentContribution = null;
        targetID = null;
        targetContributionTag = IWorkbenchRegistryConstants.TAG_ACTION_SET;
        String id = set.getDesc().getId();
        
        if (cache != null) {
            for (int i = 0; i < cache.size(); i++) {
                ActionSetContribution contribution = (ActionSetContribution) cache
                        .get(i);
                contribution.revokeContribution((WorkbenchWindow) window,
                        actionSet.getBars(), id);
                if (contribution.isAdjunctContributor()) {
                    for (int j = 0; j < contribution.adjunctActions.size(); j++) {
                        ActionDescriptor adjunctAction = (ActionDescriptor) contribution.adjunctActions
                                .get(j);
                        contribution.revokeAdjunctCoolbarAction(adjunctAction,
                                actionSet.getBars());
                    }
                }
            }
        }
    }
}
