| /******************************************************************************* |
| * Copyright (c) 2009 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; |
| |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Map; |
| import org.eclipse.core.commands.Command; |
| import org.eclipse.core.commands.ExecutionEvent; |
| import org.eclipse.core.commands.ExecutionException; |
| import org.eclipse.core.commands.IHandler; |
| import org.eclipse.core.commands.NotEnabledException; |
| import org.eclipse.core.commands.NotHandledException; |
| import org.eclipse.core.commands.ParameterizedCommand; |
| import org.eclipse.core.commands.common.NotDefinedException; |
| import org.eclipse.core.expressions.ElementHandler; |
| 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.IConfigurationElement; |
| import org.eclipse.e4.core.commands.ECommandService; |
| import org.eclipse.e4.core.commands.EHandlerService; |
| import org.eclipse.e4.core.services.context.EclipseContextFactory; |
| import org.eclipse.e4.core.services.context.IEclipseContext; |
| import org.eclipse.e4.extensions.ExtensionUtils; |
| import org.eclipse.e4.ui.model.application.MContext; |
| import org.eclipse.e4.ui.workbench.swt.internal.AbstractPartRenderer; |
| import org.eclipse.e4.workbench.ui.internal.Activator; |
| import org.eclipse.e4.workbench.ui.internal.Policy; |
| import org.eclipse.e4.workbench.ui.internal.UISchedulerStrategy; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.ui.handlers.IHandlerActivation; |
| import org.eclipse.ui.handlers.IHandlerService; |
| import org.eclipse.ui.internal.expressions.AndExpression; |
| import org.eclipse.ui.internal.expressions.WorkbenchWindowExpression; |
| import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants; |
| import org.eclipse.ui.internal.services.SourcePriorityNameMapping; |
| |
| public class LegacyHandlerService implements IHandlerService { |
| private static final String PARM_MAP = "legacyParameterMap"; //$NON-NLS-1$ |
| private static final String HANDLER_PREFIX = "HDL_"; //$NON-NLS-1$ |
| |
| public static class HandlerProxy { |
| IHandler handler = null; |
| Command command; |
| EHandlerActivation activation = null; |
| |
| public HandlerProxy(Command command, IHandler handler) { |
| this.command = command; |
| this.handler = handler; |
| } |
| |
| public boolean canExecute(IEclipseContext context) { |
| return handler.isEnabled(); |
| } |
| |
| public void execute(IEclipseContext context) { |
| Activator.trace(Policy.DEBUG_CMDS, "execute " + command + " and " //$NON-NLS-1$ //$NON-NLS-2$ |
| + handler + " with: " + context, null); //$NON-NLS-1$ |
| LegacyEvalContext legacy = new LegacyEvalContext(context); |
| ExecutionEvent event = new ExecutionEvent(command, (Map) context |
| .get(PARM_MAP), null, legacy); |
| try { |
| handler.execute(event); |
| } catch (ExecutionException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| |
| public IHandler getHandler() { |
| return handler; |
| } |
| } |
| |
| static class EHandlerActivation implements IHandlerActivation, Runnable { |
| |
| IEclipseContext context; |
| private String commandId; |
| private IHandler handler; |
| HandlerProxy proxy; |
| Expression activeWhen; |
| boolean active; |
| int sourcePriority; |
| boolean participating = true; |
| |
| /** |
| * @param context |
| * @param cmdId |
| * @param handler |
| * @param handlerProxy |
| */ |
| public EHandlerActivation(IEclipseContext context, String cmdId, |
| IHandler handler, HandlerProxy handlerProxy, Expression expr) { |
| this.context = context; |
| this.commandId = cmdId; |
| this.handler = handler; |
| this.proxy = handlerProxy; |
| this.activeWhen = expr; |
| this.sourcePriority = SourcePriorityNameMapping |
| .computeSourcePriority(activeWhen); |
| proxy.activation = this; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.handlers.IHandlerActivation#clearActive() |
| */ |
| public void clearActive() { |
| active = true; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.handlers.IHandlerActivation#getCommandId() |
| */ |
| public String getCommandId() { |
| return commandId; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.handlers.IHandlerActivation#getDepth() |
| */ |
| public int getDepth() { |
| // TODO Auto-generated method stub |
| return 0; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.handlers.IHandlerActivation#getHandler() |
| */ |
| public IHandler getHandler() { |
| return handler; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.handlers.IHandlerActivation#getHandlerService() |
| */ |
| public IHandlerService getHandlerService() { |
| return (IHandlerService) context.get(IHandlerService.class |
| .getName()); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerActivation#isActive(org.eclipse.core |
| * .expressions.IEvaluationContext) |
| */ |
| public boolean isActive(IEvaluationContext context) { |
| return active; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.internal.services.IEvaluationResultCache#clearResult() |
| */ |
| public void clearResult() { |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.internal.services.IEvaluationResultCache#evaluate( |
| * org.eclipse.core.expressions.IEvaluationContext) |
| */ |
| public boolean evaluate(IEvaluationContext context) { |
| if (activeWhen == null) { |
| active = true; |
| } else { |
| try { |
| active = activeWhen.evaluate(context) != EvaluationResult.FALSE; |
| } catch (CoreException e) { |
| Activator.trace(Policy.DEBUG_CMDS, |
| "Failed to calculate active", e); //$NON-NLS-1$ |
| } |
| } |
| return active; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.internal.services.IEvaluationResultCache#getExpression |
| * () |
| */ |
| public Expression getExpression() { |
| return activeWhen; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.internal.services.IEvaluationResultCache#getSourcePriority |
| * () |
| */ |
| public int getSourcePriority() { |
| return sourcePriority; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.internal.services.IEvaluationResultCache#setResult |
| * (boolean) |
| */ |
| public void setResult(boolean result) { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see java.lang.Comparable#compareTo(java.lang.Object) |
| */ |
| public int compareTo(Object o) { |
| EHandlerActivation activation = (EHandlerActivation) o; |
| int difference; |
| |
| // Check the priorities |
| int thisPriority = this.getSourcePriority(); |
| int thatPriority = activation.getSourcePriority(); |
| |
| // rogue bit problem - ISources.ACTIVE_MENU |
| int thisLsb = 0; |
| int thatLsb = 0; |
| |
| if (((thisPriority & ISources.ACTIVE_MENU) | (thatPriority & ISources.ACTIVE_MENU)) != 0) { |
| thisLsb = thisPriority & 1; |
| thisPriority = (thisPriority >> 1) & 0x7fffffff; |
| thatLsb = thatPriority & 1; |
| thatPriority = (thatPriority >> 1) & 0x7fffffff; |
| } |
| |
| difference = thisPriority - thatPriority; |
| if (difference != 0) { |
| return difference; |
| } |
| |
| // if all of the higher bits are the same, check the |
| // difference of the LSB |
| difference = thisLsb - thatLsb; |
| if (difference != 0) { |
| return difference; |
| } |
| |
| // Check depth |
| final int thisDepth = this.getDepth(); |
| final int thatDepth = activation.getDepth(); |
| difference = thisDepth - thatDepth; |
| return difference; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see java.lang.Object#toString() |
| */ |
| @Override |
| public String toString() { |
| return "EHA: " + active + ":" + sourcePriority + ":" + commandId + ": " + proxy //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ |
| + ": " + handler + ": " + context; //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see java.lang.Runnable#run() |
| */ |
| public void run() { |
| if (!participating) { |
| return; |
| } |
| final EHandlerService hs = (EHandlerService) context |
| .get(EHandlerService.class.getName()); |
| Object obj = context.get(HANDLER_PREFIX + commandId); |
| |
| if (evaluate(new LegacyEvalContext(context))) { |
| if (obj instanceof HandlerProxy) { |
| final EHandlerActivation bestActivation = ((HandlerProxy) obj).activation; |
| final int comparison = bestActivation.compareTo(this); |
| if (comparison < 0) { |
| hs.activateHandler(commandId, proxy); |
| } |
| } else if (obj == null) { |
| hs.activateHandler(commandId, proxy); |
| } |
| } else { |
| if (obj == proxy) { |
| hs.deactivateHandler(commandId, proxy); |
| } |
| } |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.application.IActionBarConfigurer#registerGlobalAction( |
| * org.eclipse.jface.action.IAction) |
| */ |
| public static IHandlerActivation registerLegacyHandler( |
| final IEclipseContext context, String id, final String cmdId, |
| IHandler handler, Expression activeWhen) { |
| |
| ECommandService cs = (ECommandService) context |
| .get(ECommandService.class.getName()); |
| Command command = cs.getCommand(cmdId); |
| HandlerProxy handlerProxy = new HandlerProxy(command, handler); |
| final EHandlerActivation activation = new EHandlerActivation(context, |
| cmdId, handler, handlerProxy, activeWhen); |
| context.runAndTrack(activation); |
| return activation; |
| } |
| |
| private IEclipseContext eclipseContext; |
| private IEvaluationContext evalContext; |
| private Expression defaultExpression = null; |
| |
| public LegacyHandlerService(IEclipseContext context) { |
| eclipseContext = context; |
| evalContext = new LegacyEvalContext(eclipseContext); |
| IWorkbenchWindow window = (IWorkbenchWindow) eclipseContext |
| .get(IWorkbenchWindow.class.getName()); |
| if (window != null) { |
| defaultExpression = new WorkbenchWindowExpression(window); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#activateHandler(org.eclipse.ui |
| * .handlers.IHandlerActivation) |
| */ |
| public IHandlerActivation activateHandler(IHandlerActivation activation) { |
| EHandlerActivation eActivation = (EHandlerActivation) activation; |
| eActivation.participating = true; |
| eActivation.context.runAndTrack(eActivation); |
| return activation; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#activateHandler(java.lang.String, |
| * org.eclipse.core.commands.IHandler) |
| */ |
| public IHandlerActivation activateHandler(String commandId, IHandler handler) { |
| return registerLegacyHandler(eclipseContext, commandId, commandId, |
| handler, defaultExpression); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#activateHandler(java.lang.String, |
| * org.eclipse.core.commands.IHandler, |
| * org.eclipse.core.expressions.Expression) |
| */ |
| public IHandlerActivation activateHandler(String commandId, |
| IHandler handler, Expression expression) { |
| return activateHandler(commandId, handler, expression, false); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#activateHandler(java.lang.String, |
| * org.eclipse.core.commands.IHandler, |
| * org.eclipse.core.expressions.Expression, boolean) |
| */ |
| public IHandlerActivation activateHandler(String commandId, |
| IHandler handler, Expression expression, boolean global) { |
| if (global || defaultExpression == null) { |
| return registerLegacyHandler(eclipseContext, commandId, commandId, |
| handler, expression); |
| } |
| AndExpression andExpr = new AndExpression(); |
| andExpr.add(expression); |
| andExpr.add(defaultExpression); |
| return registerLegacyHandler(eclipseContext, commandId, commandId, |
| handler, andExpr); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#activateHandler(java.lang.String, |
| * org.eclipse.core.commands.IHandler, |
| * org.eclipse.core.expressions.Expression, int) |
| */ |
| public IHandlerActivation activateHandler(String commandId, |
| IHandler handler, Expression expression, int sourcePriorities) { |
| return activateHandler(commandId, handler, expression, false); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#createContextSnapshot(boolean) |
| */ |
| public IEvaluationContext createContextSnapshot(boolean includeSelection) { |
| return new LegacyEvalContext(EclipseContextFactory.create( |
| getFocusContext(PlatformUI.getWorkbench().getDisplay()), |
| UISchedulerStrategy.getInstance())); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#createExecutionEvent(org.eclipse |
| * .core.commands.Command, org.eclipse.swt.widgets.Event) |
| */ |
| public ExecutionEvent createExecutionEvent(Command command, Event event) { |
| LegacyEvalContext legacy = new LegacyEvalContext( |
| getFocusContext(PlatformUI.getWorkbench().getDisplay())); |
| ExecutionEvent e = new ExecutionEvent(command, Collections.EMPTY_MAP, |
| event, legacy); |
| return e; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#createExecutionEvent(org.eclipse |
| * .core.commands.ParameterizedCommand, org.eclipse.swt.widgets.Event) |
| */ |
| public ExecutionEvent createExecutionEvent(ParameterizedCommand command, |
| Event event) { |
| LegacyEvalContext legacy = new LegacyEvalContext( |
| getFocusContext(PlatformUI.getWorkbench().getDisplay())); |
| ExecutionEvent e = new ExecutionEvent(command.getCommand(), command |
| .getParameterMap(), event, legacy); |
| return e; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#deactivateHandler(org.eclipse |
| * .ui.handlers.IHandlerActivation) |
| */ |
| public void deactivateHandler(IHandlerActivation activation) { |
| EHandlerActivation eActivation = (EHandlerActivation) activation; |
| eActivation.participating = false; |
| EHandlerService hs = (EHandlerService) eActivation.context |
| .get(EHandlerService.class.getName()); |
| hs.deactivateHandler(eActivation.getCommandId(), eActivation.proxy); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#deactivateHandlers(java.util. |
| * Collection) |
| */ |
| public void deactivateHandlers(Collection activations) { |
| Object[] array = activations.toArray(); |
| for (int i = 0; i < array.length; i++) { |
| deactivateHandler((IHandlerActivation) array[i]); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#executeCommand(java.lang.String, |
| * org.eclipse.swt.widgets.Event) |
| */ |
| public Object executeCommand(String commandId, Event event) |
| throws ExecutionException, NotDefinedException, |
| NotEnabledException, NotHandledException { |
| ECommandService cs = (ECommandService) getFocusContext( |
| PlatformUI.getWorkbench().getDisplay()).get( |
| ECommandService.class.getName()); |
| final Command command = cs.getCommand(commandId); |
| return executeCommand(ParameterizedCommand.generateCommand(command, |
| null), event); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#executeCommand(org.eclipse.core |
| * .commands.ParameterizedCommand, org.eclipse.swt.widgets.Event) |
| */ |
| public Object executeCommand(ParameterizedCommand command, Event event) |
| throws ExecutionException, NotDefinedException, |
| NotEnabledException, NotHandledException { |
| EHandlerService hs = (EHandlerService) getFocusContext( |
| PlatformUI.getWorkbench().getDisplay()).get( |
| EHandlerService.class.getName()); |
| hs.getContext().set(PARM_MAP, command.getParameterMap()); |
| return hs.executeHandler(command); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#executeCommandInContext(org.eclipse |
| * .core.commands.ParameterizedCommand, org.eclipse.swt.widgets.Event, |
| * org.eclipse.core.expressions.IEvaluationContext) |
| */ |
| public Object executeCommandInContext(ParameterizedCommand command, |
| Event event, IEvaluationContext context) throws ExecutionException, |
| NotDefinedException, NotEnabledException, NotHandledException { |
| if (context instanceof LegacyEvalContext) { |
| EHandlerService hs = (EHandlerService) ((LegacyEvalContext) context).eclipseContext |
| .get(EHandlerService.class.getName()); |
| return hs.executeHandler(command); |
| } |
| return executeCommand(command, event); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.handlers.IHandlerService#getCurrentState() |
| */ |
| public IEvaluationContext getCurrentState() { |
| return evalContext; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.handlers.IHandlerService#readRegistry() |
| */ |
| public void readRegistry() { |
| readDefaultHandlers(); |
| readHandlers(); |
| } |
| |
| private void readHandlers() { |
| IConfigurationElement[] elements = ExtensionUtils |
| .getExtensions(IWorkbenchRegistryConstants.PL_HANDLERS); |
| for (IConfigurationElement configElement : elements) { |
| String commandId = configElement |
| .getAttribute(IWorkbenchRegistryConstants.ATT_COMMAND_ID); |
| if (commandId == null || commandId.length() == 0) { |
| continue; |
| } |
| String defaultHandler = configElement |
| .getAttribute(IWorkbenchRegistryConstants.ATT_CLASS); |
| if ((defaultHandler == null) |
| && (configElement |
| .getChildren(IWorkbenchRegistryConstants.TAG_CLASS).length == 0)) { |
| continue; |
| } |
| Expression activeWhen = null; |
| final IConfigurationElement[] awChildren = configElement |
| .getChildren(IWorkbenchRegistryConstants.TAG_ACTIVE_WHEN); |
| if (awChildren.length > 0) { |
| final IConfigurationElement[] subChildren = awChildren[0] |
| .getChildren(); |
| if (subChildren.length != 1) { |
| Activator.trace(Policy.DEBUG_CMDS, |
| "Incorrect activeWhen element " + commandId, null); //$NON-NLS-1$ |
| continue; |
| } |
| final ElementHandler elementHandler = ElementHandler |
| .getDefault(); |
| final ExpressionConverter converter = ExpressionConverter |
| .getDefault(); |
| try { |
| activeWhen = elementHandler.create(converter, |
| subChildren[0]); |
| } catch (CoreException e) { |
| Activator.trace(Policy.DEBUG_CMDS, |
| "Incorrect activeWhen element " + commandId, e); //$NON-NLS-1$ |
| } |
| } |
| registerLegacyHandler(eclipseContext, commandId, commandId, |
| new org.eclipse.ui.internal.handlers.HandlerProxy( |
| commandId, configElement, |
| IWorkbenchRegistryConstants.ATT_CLASS), activeWhen); |
| } |
| } |
| |
| private void readDefaultHandlers() { |
| IConfigurationElement[] elements = ExtensionUtils |
| .getExtensions(IWorkbenchRegistryConstants.PL_COMMANDS); |
| for (IConfigurationElement configElement : elements) { |
| String id = configElement |
| .getAttribute(IWorkbenchRegistryConstants.ATT_ID); |
| if (id == null || id.length() == 0) { |
| continue; |
| } |
| String defaultHandler = configElement |
| .getAttribute(IWorkbenchRegistryConstants.ATT_DEFAULT_HANDLER); |
| if ((defaultHandler == null) |
| && (configElement |
| .getChildren(IWorkbenchRegistryConstants.TAG_DEFAULT_HANDLER).length == 0)) { |
| continue; |
| } |
| registerLegacyHandler(eclipseContext, id, id, |
| new org.eclipse.ui.internal.handlers.HandlerProxy(id, |
| configElement, |
| IWorkbenchRegistryConstants.ATT_DEFAULT_HANDLER), |
| null); |
| |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.handlers.IHandlerService#setHelpContextId(org.eclipse. |
| * core.commands.IHandler, java.lang.String) |
| */ |
| public void setHelpContextId(IHandler handler, String helpContextId) { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.services.IServiceWithSources#addSourceProvider(org.eclipse |
| * .ui.ISourceProvider) |
| */ |
| public void addSourceProvider(ISourceProvider provider) { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ui.services.IServiceWithSources#removeSourceProvider(org. |
| * eclipse.ui.ISourceProvider) |
| */ |
| public void removeSourceProvider(ISourceProvider provider) { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.services.IDisposable#dispose() |
| */ |
| public void dispose() { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| private IEclipseContext getFocusContext(Display display) { |
| // find the first useful part in the model |
| Control control = display.getFocusControl(); |
| Object modelObj = null; |
| while (control != null) { |
| modelObj = control.getData(AbstractPartRenderer.OWNING_ME); |
| if (modelObj instanceof MContext) |
| return ((MContext) modelObj).getContext(); |
| control = control.getParent(); |
| } |
| return eclipseContext; |
| } |
| |
| } |