bundles/org.eclipse.e4.ui.workbench.fragment/src/org/eclipse/ui/LegacyHandlerService.java - e4/org.eclipse.e4.ui - Git at Google

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

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

	}