| /******************************************************************************* |
| * Copyright (c) 2000, 2007 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.List; |
| |
| import org.eclipse.core.expressions.EvaluationContext; |
| import org.eclipse.core.expressions.EvaluationResult; |
| import org.eclipse.core.expressions.Expression; |
| import org.eclipse.core.expressions.ExpressionConverter; |
| import org.eclipse.core.expressions.IEvaluationContext; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.IConfigurationElement; |
| import org.eclipse.core.runtime.ISafeRunnable; |
| import org.eclipse.core.runtime.SafeRunner; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.SelectionEnabler; |
| import org.eclipse.ui.internal.misc.Policy; |
| import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants; |
| import org.eclipse.ui.internal.util.Util; |
| import org.eclipse.ui.model.IWorkbenchAdapter; |
| |
| /** |
| * This class describes the object contribution element within the popup menu |
| * action registry. |
| */ |
| public class ObjectActionContributor extends PluginActionBuilder implements |
| IObjectActionContributor, IAdaptable { |
| |
| private static final String P_TRUE = "true"; //$NON-NLS-1$ |
| |
| private IConfigurationElement config; |
| |
| private boolean configRead = false; |
| |
| private boolean adaptable = false; |
| |
| private String objectClass; |
| |
| /** |
| * The constructor. |
| * |
| * @param config the element |
| */ |
| public ObjectActionContributor(IConfigurationElement config) { |
| this.config = config; |
| this.adaptable = P_TRUE.equalsIgnoreCase(config |
| .getAttribute(IWorkbenchRegistryConstants.ATT_ADAPTABLE)); |
| this.objectClass = config.getAttribute(IWorkbenchRegistryConstants.ATT_OBJECTCLASS); |
| } |
| |
| /* (non-Javadoc) |
| * Method declared on IObjectContributor. |
| */ |
| public boolean canAdapt() { |
| return adaptable; |
| } |
| |
| /** |
| * Return the object class for this contributor. |
| * |
| * @return the object class |
| */ |
| public String getObjectClass() { |
| return objectClass; |
| } |
| |
| /* (non-Javadoc) |
| * Method declared on IObjectActionContributor. |
| */ |
| public void contributeObjectActionIdOverrides(List actionIdOverrides) { |
| if (!configRead) { |
| readConfigElement(); |
| } |
| |
| // Easy case out if no actions |
| if (currentContribution.actions != null) { |
| for (int i = 0; i < currentContribution.actions.size(); i++) { |
| ActionDescriptor ad = (ActionDescriptor) currentContribution.actions |
| .get(i); |
| String id = ad.getAction().getOverrideActionId(); |
| if (id != null) { |
| actionIdOverrides.add(id); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Contributes actions applicable for the current selection. |
| */ |
| public boolean contributeObjectActions(final IWorkbenchPart part, |
| IMenuManager menu, ISelectionProvider selProv, |
| List actionIdOverrides) { |
| if (!configRead) { |
| readConfigElement(); |
| } |
| |
| // Easy case out if no actions |
| if (currentContribution.actions == null) { |
| return false; |
| } |
| |
| // Get a structured selection. |
| ISelection sel = selProv.getSelection(); |
| if ((sel == null) || !(sel instanceof IStructuredSelection)) { |
| return false; |
| } |
| IStructuredSelection ssel = (IStructuredSelection) sel; |
| |
| if(canAdapt()) { |
| IStructuredSelection newSelection = LegacyResourceSupport.adaptSelection(ssel, getObjectClass()); |
| if(newSelection.size() != ssel.size()) { |
| if (Policy.DEBUG_CONTRIBUTIONS) { |
| WorkbenchPlugin.log("Error adapting selection to " + getObjectClass() + //$NON-NLS-1$ |
| ". Contribution " + getID(config) + " is being ignored"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| return false; |
| } |
| ssel = newSelection; |
| } |
| |
| final IStructuredSelection selection = ssel; |
| |
| // Generate menu. |
| for (int i = 0; i < currentContribution.actions.size(); i++) { |
| ActionDescriptor ad = (ActionDescriptor) currentContribution.actions |
| .get(i); |
| if (!actionIdOverrides.contains(ad.getId())) { |
| currentContribution.contributeMenuAction(ad, menu, true); |
| // Update action for the current selection and part. |
| if (ad.getAction() instanceof ObjectPluginAction) { |
| final ObjectPluginAction action = (ObjectPluginAction) ad |
| .getAction(); |
| ISafeRunnable runnable = new ISafeRunnable() { |
| public void handleException(Throwable exception) { |
| WorkbenchPlugin.log("Failed to update action " //$NON-NLS-1$ |
| + action.getId(), exception); |
| } |
| |
| public void run() throws Exception { |
| action.setActivePart(part); |
| action.selectionChanged(selection); |
| } |
| }; |
| SafeRunner.run(runnable); |
| } |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Contributes menus applicable for the current selection. |
| */ |
| public boolean contributeObjectMenus(IMenuManager menu, |
| ISelectionProvider selProv) { |
| if (!configRead) { |
| readConfigElement(); |
| } |
| |
| // Easy case out if no menus |
| if (currentContribution.menus == null) { |
| return false; |
| } |
| |
| // Get a structured selection. |
| ISelection sel = selProv.getSelection(); |
| if ((sel == null) || !(sel instanceof IStructuredSelection)) { |
| return false; |
| } |
| |
| // Generate menu. |
| for (int i = 0; i < currentContribution.menus.size(); i++) { |
| IConfigurationElement menuElement = (IConfigurationElement) currentContribution.menus |
| .get(i); |
| currentContribution.contributeMenu(menuElement, menu, true); |
| } |
| return true; |
| } |
| |
| /* (non-Javadoc) |
| * Method declared on PluginActionBuilder. |
| */ |
| protected ActionDescriptor createActionDescriptor( |
| IConfigurationElement element) { |
| return new ActionDescriptor(element, ActionDescriptor.T_POPUP); |
| } |
| |
| /* (non-Javadoc) |
| * Method declared on PluginActionBuilder. |
| */ |
| protected BasicContribution createContribution() { |
| return new ObjectContribution(); |
| } |
| |
| /** |
| * Returns true if name filter is not specified for the contribution |
| * or the current selection matches the filter. |
| */ |
| public boolean isApplicableTo(Object object) { |
| if (!configRead) { |
| readConfigElement(); |
| } |
| |
| // Perform all tests with an instance of the objectClass and not |
| // the actual selected object. |
| if (canAdapt()) { |
| Object adapted = LegacyResourceSupport.getAdapter(object, getObjectClass()); |
| if (adapted == null) { |
| if (Policy.DEBUG_CONTRIBUTIONS) { |
| WorkbenchPlugin |
| .log("Error adapting " + object.getClass().getName() + //$NON-NLS-1$ |
| " to " //$NON-NLS-1$ |
| + getObjectClass() |
| + ". Contribution " + getID(config) + " is being ignored"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } else { |
| object = adapted; |
| } |
| } |
| |
| if (!testName(object)) { |
| return false; |
| } |
| |
| return ((ObjectContribution) currentContribution) |
| .isApplicableTo(object); |
| } |
| |
| /** |
| * Reads the configuration element and all the children. |
| * This creates an action descriptor for every action in the extension. |
| */ |
| private void readConfigElement() { |
| currentContribution = createContribution(); |
| readElementChildren(config); |
| configRead = true; |
| } |
| |
| /* (non-Javadoc) |
| * Method declared on PluginActionBuilder. |
| */ |
| protected boolean readElement(IConfigurationElement element) { |
| String tag = element.getName(); |
| |
| // Found visibility sub-element |
| if (tag.equals(IWorkbenchRegistryConstants.TAG_VISIBILITY)) { |
| ((ObjectContribution) currentContribution) |
| .setVisibilityTest(element); |
| return true; |
| } |
| |
| // Found filter sub-element |
| if (tag.equals(IWorkbenchRegistryConstants.TAG_FILTER)) { |
| ((ObjectContribution) currentContribution).addFilterTest(element); |
| return true; |
| } |
| |
| if (tag.equals(IWorkbenchRegistryConstants.TAG_ENABLEMENT)) { |
| ((ObjectContribution) currentContribution) |
| .setEnablementTest(element); |
| return true; |
| } |
| |
| return super.readElement(element); |
| } |
| |
| /** |
| * Returns whether the current selection matches the contribution name filter. |
| */ |
| private boolean testName(Object object) { |
| String nameFilter = config.getAttribute(IWorkbenchRegistryConstants.ATT_NAME_FILTER); |
| if (nameFilter == null) { |
| return true; |
| } |
| String objectName = null; |
| IWorkbenchAdapter de = (IWorkbenchAdapter)Util.getAdapter(object, IWorkbenchAdapter.class); |
| if (de != null) { |
| objectName = de.getLabel(object); |
| } |
| if (objectName == null) { |
| objectName = object.toString(); |
| } |
| return SelectionEnabler.verifyNameMatch(objectName, nameFilter); |
| } |
| |
| /** |
| * Helper class to collect the menus and actions defined within a |
| * contribution element. |
| */ |
| private static class ObjectContribution extends BasicContribution { |
| private ObjectFilterTest filterTest; |
| |
| private ActionExpression visibilityTest; |
| |
| private Expression enablement; |
| |
| /** |
| * Add a filter test. |
| * |
| * @param element the element |
| */ |
| public void addFilterTest(IConfigurationElement element) { |
| if (filterTest == null) { |
| filterTest = new ObjectFilterTest(); |
| } |
| filterTest.addFilterElement(element); |
| } |
| |
| /** |
| * Set the visibility test. |
| * |
| * @param element the element |
| */ |
| public void setVisibilityTest(IConfigurationElement element) { |
| visibilityTest = new ActionExpression(element); |
| } |
| |
| /** |
| * Set the enablement test. |
| * |
| * @param element the element |
| */ |
| public void setEnablementTest(IConfigurationElement element) { |
| try { |
| enablement = ExpressionConverter.getDefault().perform(element); |
| } catch (CoreException e) { |
| WorkbenchPlugin.log(e); |
| } |
| } |
| |
| /** |
| * Returns true if name filter is not specified for the contribution |
| * or the current selection matches the filter. |
| * |
| * @param object the object to test |
| * @return whether we're applicable |
| */ |
| public boolean isApplicableTo(Object object) { |
| boolean result = true; |
| if (visibilityTest != null) { |
| result = result && visibilityTest.isEnabledFor(object); |
| if (!result) { |
| return result; |
| } |
| } else if (filterTest != null) { |
| result = result && filterTest.matches(object, true); |
| if (!result) { |
| return result; |
| } |
| } |
| if (enablement != null) { |
| try { |
| IEvaluationContext context = new EvaluationContext(null, |
| object); |
| context.setAllowPluginActivation(true); |
| context.addVariable("selection", object); //$NON-NLS-1$ |
| EvaluationResult evalResult = enablement.evaluate(context); |
| if (evalResult == EvaluationResult.FALSE) { |
| return false; |
| } |
| } catch (CoreException e) { |
| enablement = null; |
| WorkbenchPlugin.log(e); |
| result = false; |
| } |
| } |
| return result; |
| } |
| } |
| |
| /** |
| * Debugging helper that will print out the contribution names for this |
| * contributor. |
| */ |
| public String toString() { |
| StringBuffer buffer = new StringBuffer(); |
| IConfigurationElement[] children = config.getChildren(); |
| for (int i = 0; i < children.length; i++) { |
| IConfigurationElement element = children[i]; |
| String label = element.getAttribute(IWorkbenchRegistryConstants.ATT_LABEL); |
| if(label != null) { |
| buffer.append(label); |
| buffer.append('\n'); |
| } |
| } |
| return buffer.toString(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class) |
| */ |
| public Object getAdapter(Class adapter) { |
| if (adapter.equals(IConfigurationElement.class)) { |
| return config; |
| } |
| return null; |
| } |
| } |
