/*******************************************************************************
* 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.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;
/**
* 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 {
PluginActionSetBuilder builder;
PluginActionSet set;
IWorkbenchWindow window;
}
/**
* 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);
}
}
Binding binding = new Binding();
binding.builder = this;
binding.set = set;
binding.window = window;
window.getExtensionTracker().registerObject(
set.getConfigElement().getDeclaringExtension(), binding,
IExtensionTracker.REF_STRONG);
}
/* (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);
}
}
Binding binding = new Binding();
binding.builder = this;
binding.set = set;
binding.window = window;
window.getExtensionTracker().registerObject(
set.getConfigElement().getDeclaringExtension(), binding,
IExtensionTracker.REF_STRONG);
} else {
WorkbenchPlugin
.log("Action Set is empty: " + set.getDesc().getId()); //$NON-NLS-1$
}
}
/**
* 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);
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);
// 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);
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());
}
}
}
}
}
}