Java tutorial
/******************************************************************************* * Copyright (c) 2000, 2006 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.jface.action.ContributionItem; 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.SubMenuManager; import org.eclipse.jface.action.SubToolBarManager; import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem; import org.eclipse.ui.IActionBars2; import org.eclipse.ui.IWorkbenchActionConstants; import org.eclipse.ui.SubActionBars2; import org.eclipse.ui.internal.provisional.application.IActionBarConfigurer2; import org.eclipse.ui.services.IServiceLocator; /** * This class represents the action bars for an action set. */ public class ActionSetActionBars extends SubActionBars2 { private IActionBarConfigurer2 actionBarConfigurer = null; private String actionSetId; private ArrayList adjunctContributions = new ArrayList(); private IToolBarManager coolItemToolBarMgr = null; private IToolBarContributionItem toolBarContributionItem = null; /** * Constructs a new action bars object */ public ActionSetActionBars(IActionBars2 parent, IServiceLocator serviceLocator, IActionBarConfigurer2 actionBarConfigurer, String actionSetId) { super(parent, serviceLocator); this.actionSetId = actionSetId; this.actionBarConfigurer = actionBarConfigurer; } /** * Adds to the list all the actions that are part of this action set but * belong to different cool bar items. * * @param item * the item defined in this actionset but in a different tool Bar * contribution item */ /* package */void addAdjunctContribution(IContributionItem item) { adjunctContributions.add(item); } /* * (non-Javadoc) Inherited from SubActionBars. */ protected SubMenuManager createSubMenuManager(IMenuManager parent) { return new ActionSetMenuManager(parent, actionSetId); } /* * (non-Javadoc) Inherited from SubActionBars. */ protected SubToolBarManager createSubToolBarManager(IToolBarManager parent) { // return null, action sets are managed by CoolItemToolBarManagers return null; } /** * Dispose the contributions. */ public void dispose() { super.dispose(); if (coolItemToolBarMgr == null) { return; } IContributionItem[] items = coolItemToolBarMgr.getItems(); // remove the action set's items from its action bar, don't use // removeAll since other items from other actions sets may be in // the action bar's cool item for (int i = 0; i < items.length; i++) { IContributionItem item = items[i]; if (item instanceof PluginActionCoolBarContributionItem) { PluginActionCoolBarContributionItem actionSetItem = (PluginActionCoolBarContributionItem) item; if (actionSetItem.getActionSetId().equals(actionSetId)) { coolItemToolBarMgr.remove(item); item.dispose(); } } else { // leave separators and group markers intact, doing // so allows ordering to be maintained when action sets // are removed then added back } } // remove items from this action set that are in other action bars for (int i = 0; i < adjunctContributions.size(); i++) { ContributionItem item = (ContributionItem) adjunctContributions.get(i); IContributionManager parent = item.getParent(); if (parent != null) { parent.remove(item); item.dispose(); } } toolBarContributionItem = null; coolItemToolBarMgr = null; adjunctContributions = new ArrayList(); } /** * Returns the contribution item that the given contribution item should be * inserted after. * * @param startId * the location to start looking alphabetically. * @param itemId * the target item id. * @param mgr * the contribution manager. * @return the contribution item that the given items should be returned * after. * * @since 3.0 */ 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 (item.getId() != null && item.getId().equals(startId)) { 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]; String testId = item.getId(); if (item.isGroupMarker()) { break; } if (itemId != null && testId != null) { if (itemId.compareTo(testId) < 1) { break; } } insertIndex = i; } // Should be inserted at the end if (insertIndex >= items.length) { return null; } return items[insertIndex]; } /* package */String getActionSetId() { return actionSetId; } /** * Returns a tool bar manager for this Item. * * @return the tool bar manager */ public IToolBarManager getToolBarManager() { ICoolBarManager coolBarManager = getCastedParent().getCoolBarManager(); if (coolBarManager == null) { return null; } return actionBarConfigurer.createToolBarManager(); } /** * Returns the correct tool bar for the given action id. If this action is * an adjunct type the it returns the toolbar manager from the cool bar * manager. * * @param id * the id of the action * @return the tool bar manager */ public IToolBarManager getToolBarManager(String actionId) { // Check if a tool bar manager for an adjunct type is being requested String toolBarId = actionSetId; boolean isAdjunctType = false; if (!actionId.equals(actionSetId)) { // Adjunct type toolBarId = actionId; isAdjunctType = true; } // Rereive the cool bar manager ICoolBarManager coolBarManager = getCastedParent().getCoolBarManager(); if (coolBarManager == null) { return null; } // Check to see that there isn't already a tool bar created // and the tool bar being requested is not for an adjunct action if ((coolItemToolBarMgr != null) && (!isAdjunctType)) { return coolItemToolBarMgr; } // Search for toolBarId in the cool Bar manager IContributionItem cbItem = coolBarManager.find(toolBarId); // If there hasn't been a tool bar contribution item created for this // tool bar // id then create one. Otherwise retrieve the tool bar contribution // item if (cbItem instanceof IToolBarContributionItem) { IToolBarContributionItem tbcbItem = (IToolBarContributionItem) cbItem; coolItemToolBarMgr = tbcbItem.getToolBarManager(); // If this not an adjuct type then we can cashe the tool bar // contribution type if (!isAdjunctType) { toolBarContributionItem = tbcbItem; } } else { coolItemToolBarMgr = actionBarConfigurer.createToolBarManager(); // If this is not an adjunct type then create a tool bar // contribution item // we don't create one for an adjunct type because another action // set action bars contains one IContributionItem toolBarContributionItem = actionBarConfigurer .createToolBarContributionItem(coolItemToolBarMgr, toolBarId); toolBarContributionItem.setParent(coolItemToolBarMgr); toolBarContributionItem.setVisible(getActive()); coolItemToolBarMgr.markDirty(); // Now add the tool bar contribution Item to the cool bar manager IContributionItem refItem = findAlphabeticalOrder(IWorkbenchActionConstants.MB_ADDITIONS, toolBarId, coolBarManager); if (refItem != null) { coolBarManager.insertAfter(refItem.getId(), toolBarContributionItem); } else { coolBarManager.add(toolBarContributionItem); } } return coolItemToolBarMgr; } // for dynamic UI /* package */void removeAdjunctContribution(ContributionItem item) { adjunctContributions.remove(item); } /** * Activate / Deactivate the contributions. */ protected void setActive(boolean set) { super.setActive(set); ICoolBarManager coolBarManager = getCastedParent().getCoolBarManager(); if (coolBarManager == null) { return; } // 1. Need to set visibility for all non-adjunct actions if (coolItemToolBarMgr != null) { IContributionItem[] items = coolItemToolBarMgr.getItems(); for (int i = 0; i < items.length; i++) { IContributionItem item = items[i]; if (item instanceof PluginActionCoolBarContributionItem) { PluginActionCoolBarContributionItem actionSetItem = (PluginActionCoolBarContributionItem) item; // Only if the action set id for this contribution item is // the same // as this object if (actionSetItem.getActionSetId().equals(actionSetId)) { item.setVisible(set); coolItemToolBarMgr.markDirty(); if (!coolBarManager.isDirty()) { coolBarManager.markDirty(); } } } } // Update the manager coolItemToolBarMgr.update(false); if (toolBarContributionItem != null) { toolBarContributionItem.update(ICoolBarManager.SIZE); } } // 2. Need to set visibility for all adjunct actions if (adjunctContributions.size() > 0) { for (Iterator i = adjunctContributions.iterator(); i.hasNext();) { IContributionItem item = (IContributionItem) i.next(); if (item instanceof ContributionItem) { item.setVisible(set); IContributionManager manager = ((ContributionItem) item).getParent(); manager.markDirty(); manager.update(false); if (!coolBarManager.isDirty()) { coolBarManager.markDirty(); } item.update(ICoolBarManager.SIZE); } } } } }