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