bundles/org.eclipse.ui.workbench/Eclipse UI/org/eclipse/ui/internal/ActionSetActionBars.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * 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);
 				}

 			}

 		}
 	}

 }
	/*******************************************************************************
	* 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);
	}

	}

	}
	}

	}