bundles/org.eclipse.ui.workbench/Eclipse UI/org/eclipse/ui/internal/services/EvaluationAuthority.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2008 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.services;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.core.commands.util.Tracing;
 import org.eclipse.core.expressions.Expression;
 import org.eclipse.core.expressions.ExpressionInfo;
 import org.eclipse.core.runtime.ISafeRunnable;
 import org.eclipse.core.runtime.ListenerList;
 import org.eclipse.core.runtime.SafeRunner;
 import org.eclipse.jface.util.IPropertyChangeListener;
 import org.eclipse.jface.util.PropertyChangeEvent;
 import org.eclipse.swt.widgets.Shell;
 import org.eclipse.ui.ISources;
 import org.eclipse.ui.internal.WorkbenchPlugin;
 import org.eclipse.ui.internal.misc.Policy;
 import org.eclipse.ui.services.IEvaluationReference;
 import org.eclipse.ui.services.IEvaluationService;

 /**
  * @since 3.3
  *
  */
 public class EvaluationAuthority extends ExpressionAuthority {

 	/**
 	 *
 	 */
 	private static final String COMPONENT = "EVALUATION"; //$NON-NLS-1$

 	/**
 	 * A bucket sort of the evaluation references based on source priority. Each
 	 * reference will appear only once per set, but may appear in multiple sets.
 	 * If no references are defined for a particular priority level, then the
 	 * array at that index will only contain <code>null</code>.
 	 */
 	private final Map cachesBySourceName = new HashMap();
 	private ListenerList serviceListeners = new ListenerList();
 	private int notifying = 0;

 	// private final Map cachesByExpression = new HashMap();

 	public void addEvaluationListener(IEvaluationReference ref) {
 		// we update the source priority bucket sort of activations.
 		String[] sourceNames = getNames(ref);
 		for (int i = 0; i < sourceNames.length; i++) {
 			Map cachesByExpression = (HashMap) cachesBySourceName
 					.get(sourceNames[i]);
 			if (cachesByExpression == null) {
 				cachesByExpression = new HashMap(1);
 				cachesBySourceName.put(sourceNames[i], cachesByExpression);
 			}
 			final Expression expression = ref.getExpression();
 			Set caches = (Set) cachesByExpression.get(expression);
 			if (caches == null) {
 				caches = new HashSet();
 				cachesByExpression.put(expression, caches);
 			}
 			caches.add(ref);
 		}

 		boolean result = evaluate(ref);
 		firePropertyChange(ref, null, valueOf(result));
 	}

 	private Boolean valueOf(boolean result) {
 		return result ? Boolean.TRUE : Boolean.FALSE;
 	}

 	private String[] getNames(IEvaluationReference ref) {
 		ExpressionInfo info = new ExpressionInfo();
 		ref.getExpression().collectExpressionInfo(info);
 		ArrayList allNames = new ArrayList(Arrays.asList(info
 				.getAccessedVariableNames()));
 		if (info.hasDefaultVariableAccess()) {
 			allNames.add(ISources.ACTIVE_CURRENT_SELECTION_NAME);
 		}
 		allNames.addAll(Arrays.asList(info.getAccessedPropertyNames()));
 		return (String[]) allNames.toArray(new String[allNames.size()]);
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.ui.internal.services.ExpressionAuthority#sourceChanged(int)
 	 */
 	protected void sourceChanged(int sourcePriority) {
 		// no-op, we want the other one
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.ui.internal.services.ExpressionAuthority#sourceChanged(java.lang.String[])
 	 */
 	protected void sourceChanged(String[] sourceNames) {
 		startSourceChange(sourceNames);
 		try {
 			// evaluations to recompute
 			for (int i = 0; i < sourceNames.length; i++) {
 				Map cachesByExpression = (HashMap) cachesBySourceName
 						.get(sourceNames[i]);
 				if (cachesByExpression != null) {
 					Collection v = cachesByExpression.values();
 					Set[] expressionCaches = (Set[]) v
 							.toArray(new Set[v.size()]);
 					for (int j = 0; j < expressionCaches.length; j++) {
 						if (expressionCaches[j].size() > 0) {
 							EvaluationReference[] refs = (EvaluationReference[]) expressionCaches[j]
 									.toArray(new EvaluationReference[expressionCaches[j]
 											.size()]);
 							refsWithSameExpression(refs);
 						}
 					}
 				}
 			}
 		} finally {
 			endSourceChange(sourceNames);
 		}
 	}

 	/**
 	 * This will evaluate all refs with the same expression.
 	 *
 	 * @param refs
 	 */
 	private void refsWithSameExpression(EvaluationReference[] refs) {
 		int k = 0;
 		while (k < refs.length && !refs[k].isPostingChanges()) {
 			k++;
 		}
 		if (k >= refs.length) {
 			return;
 		}
 		EvaluationReference ref = refs[k];
 		boolean oldValue = evaluate(ref);
 		ref.clearResult();
 		final boolean newValue = evaluate(ref);
 		if (oldValue != newValue) {
 			firePropertyChange(ref, valueOf(oldValue), valueOf(newValue));
 		}
 		for (k++; k < refs.length; k++) {
 			ref = refs[k];
 			// this is not as expensive as it looks
 			if (ref.isPostingChanges()) {
 				oldValue = evaluate(ref);
 				if (oldValue != newValue) {
 					ref.setResult(newValue);
 					firePropertyChange(ref, valueOf(oldValue),
 							valueOf(newValue));
 				}
 			}
 		}
 	}

 	/**
 	 * @param sourceNames
 	 */
 	private void startSourceChange(final String[] sourceNames) {
 		if (Policy.DEBUG_SOURCES) {
 			Tracing.printTrace(COMPONENT, "start source changed: " //$NON-NLS-1$
 					+ Arrays.asList(sourceNames));
 		}
 		notifying++;
 		if (notifying == 1) {
 			fireServiceChange(IEvaluationService.PROP_NOTIFYING, Boolean.FALSE,
 					Boolean.TRUE);
 		}
 	}

 	/**
 	 * @param sourceNames
 	 */
 	private void endSourceChange(final String[] sourceNames) {
 		if (Policy.DEBUG_SOURCES) {
 			Tracing.printTrace(COMPONENT, "end source changed: " //$NON-NLS-1$
 					+ Arrays.asList(sourceNames));
 		}
 		if (notifying == 1) {
 			fireServiceChange(IEvaluationService.PROP_NOTIFYING, Boolean.TRUE,
 					Boolean.FALSE);
 		}
 		notifying--;
 	}

 	/**
 	 * @param ref
 	 */
 	public void removeEvaluationListener(IEvaluationReference ref) {
 		// Next we update the source priority bucket sort of activations.
 		String[] sourceNames = getNames(ref);
 		for (int i = 0; i < sourceNames.length; i++) {
 			Map cachesByExpression = (HashMap) cachesBySourceName
 					.get(sourceNames[i]);
 			if (cachesByExpression != null) {
 				Set caches = (Set) cachesByExpression.get(ref.getExpression());
 				if (caches != null) {
 					caches.remove(ref);
 					if (caches.isEmpty()) {
 						cachesByExpression.remove(ref.getExpression());
 					}
 				}
 				if (cachesByExpression.isEmpty()) {
 					cachesBySourceName.remove(sourceNames[i]);
 				}
 			}
 		}
 		boolean result = evaluate(ref);
 		firePropertyChange(ref, valueOf(result), null);
 	}

 	/**
 	 * @param ref
 	 * @param oldValue
 	 * @param newValue
 	 */
 	private void firePropertyChange(IEvaluationReference ref, Object oldValue,
 			Object newValue) {
 		ref.getListener().propertyChange(
 				new PropertyChangeEvent(ref, ref.getProperty(), oldValue,
 						newValue));
 	}

 	private void fireServiceChange(final String property,
 			final Object oldValue, final Object newValue) {
 		Object[] listeners = serviceListeners.getListeners();
 		for (int i = 0; i < listeners.length; i++) {
 			final IPropertyChangeListener listener = (IPropertyChangeListener) listeners[i];
 			SafeRunner.run(new ISafeRunnable() {
 				public void handleException(Throwable exception) {
 					WorkbenchPlugin.log(exception);
 				}

 				public void run() throws Exception {
 					listener.propertyChange(new PropertyChangeEvent(
 							EvaluationAuthority.this, property, oldValue,
 							newValue));
 				}
 			});
 		}
 	}

 	/**
 	 * @param listener
 	 */
 	public void addServiceListener(IPropertyChangeListener listener) {
 		serviceListeners.add(listener);
 	}

 	/**
 	 * @param listener
 	 */
 	public void removeServiceListener(IPropertyChangeListener listener) {
 		serviceListeners.remove(listener);
 	}

 	/**
 	 * <p>
 	 * Bug 95792. A mechanism by which the key binding architecture can force an
 	 * update of the handlers (based on the active shell) before trying to
 	 * execute a command. This mechanism is required for GTK+ only.
 	 * </p>
 	 * <p>
 	 * DO NOT CALL THIS METHOD.
 	 * </p>
 	 */
 	final void updateShellKludge() {
 		updateCurrentState();
 		sourceChanged(new String[] { ISources.ACTIVE_SHELL_NAME });
 	}

 	/**
 	 * Returns the currently active shell.
 	 *
 	 * @return The currently active shell; may be <code>null</code>.
 	 */
 	final Shell getActiveShell() {
 		return (Shell) getVariable(ISources.ACTIVE_SHELL_NAME);
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2007, 2008 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.services;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.core.commands.util.Tracing;
	import org.eclipse.core.expressions.Expression;
	import org.eclipse.core.expressions.ExpressionInfo;
	import org.eclipse.core.runtime.ISafeRunnable;
	import org.eclipse.core.runtime.ListenerList;
	import org.eclipse.core.runtime.SafeRunner;
	import org.eclipse.jface.util.IPropertyChangeListener;
	import org.eclipse.jface.util.PropertyChangeEvent;
	import org.eclipse.swt.widgets.Shell;
	import org.eclipse.ui.ISources;
	import org.eclipse.ui.internal.WorkbenchPlugin;
	import org.eclipse.ui.internal.misc.Policy;
	import org.eclipse.ui.services.IEvaluationReference;
	import org.eclipse.ui.services.IEvaluationService;

	/**
	* @since 3.3
	*
	*/
	public class EvaluationAuthority extends ExpressionAuthority {

	/**
	*
	*/
	private static final String COMPONENT = "EVALUATION"; //$NON-NLS-1$

	/**
	* A bucket sort of the evaluation references based on source priority. Each
	* reference will appear only once per set, but may appear in multiple sets.
	* If no references are defined for a particular priority level, then the
	* array at that index will only contain <code>null</code>.
	*/
	private final Map cachesBySourceName = new HashMap();
	private ListenerList serviceListeners = new ListenerList();
	private int notifying = 0;

	// private final Map cachesByExpression = new HashMap();

	public void addEvaluationListener(IEvaluationReference ref) {
	// we update the source priority bucket sort of activations.
	String[] sourceNames = getNames(ref);
	for (int i = 0; i < sourceNames.length; i++) {
	Map cachesByExpression = (HashMap) cachesBySourceName
	.get(sourceNames[i]);
	if (cachesByExpression == null) {
	cachesByExpression = new HashMap(1);
	cachesBySourceName.put(sourceNames[i], cachesByExpression);
	}
	final Expression expression = ref.getExpression();
	Set caches = (Set) cachesByExpression.get(expression);
	if (caches == null) {
	caches = new HashSet();
	cachesByExpression.put(expression, caches);
	}
	caches.add(ref);
	}

	boolean result = evaluate(ref);
	firePropertyChange(ref, null, valueOf(result));
	}

	private Boolean valueOf(boolean result) {
	return result ? Boolean.TRUE : Boolean.FALSE;
	}

	private String[] getNames(IEvaluationReference ref) {
	ExpressionInfo info = new ExpressionInfo();
	ref.getExpression().collectExpressionInfo(info);
	ArrayList allNames = new ArrayList(Arrays.asList(info
	.getAccessedVariableNames()));
	if (info.hasDefaultVariableAccess()) {
	allNames.add(ISources.ACTIVE_CURRENT_SELECTION_NAME);
	}
	allNames.addAll(Arrays.asList(info.getAccessedPropertyNames()));
	return (String[]) allNames.toArray(new String[allNames.size()]);
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.ui.internal.services.ExpressionAuthority#sourceChanged(int)
	*/
	protected void sourceChanged(int sourcePriority) {
	// no-op, we want the other one
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.ui.internal.services.ExpressionAuthority#sourceChanged(java.lang.String[])
	*/
	protected void sourceChanged(String[] sourceNames) {
	startSourceChange(sourceNames);
	try {
	// evaluations to recompute
	for (int i = 0; i < sourceNames.length; i++) {
	Map cachesByExpression = (HashMap) cachesBySourceName
	.get(sourceNames[i]);
	if (cachesByExpression != null) {
	Collection v = cachesByExpression.values();
	Set[] expressionCaches = (Set[]) v
	.toArray(new Set[v.size()]);
	for (int j = 0; j < expressionCaches.length; j++) {
	if (expressionCaches[j].size() > 0) {
	EvaluationReference[] refs = (EvaluationReference[]) expressionCaches[j]
	.toArray(new EvaluationReference[expressionCaches[j]
	.size()]);
	refsWithSameExpression(refs);
	}
	}
	}
	}
	} finally {
	endSourceChange(sourceNames);
	}
	}

	/**
	* This will evaluate all refs with the same expression.
	*
	* @param refs
	*/
	private void refsWithSameExpression(EvaluationReference[] refs) {
	int k = 0;
	while (k < refs.length && !refs[k].isPostingChanges()) {
	k++;
	}
	if (k >= refs.length) {
	return;
	}
	EvaluationReference ref = refs[k];
	boolean oldValue = evaluate(ref);
	ref.clearResult();
	final boolean newValue = evaluate(ref);
	if (oldValue != newValue) {
	firePropertyChange(ref, valueOf(oldValue), valueOf(newValue));
	}
	for (k++; k < refs.length; k++) {
	ref = refs[k];
	// this is not as expensive as it looks
	if (ref.isPostingChanges()) {
	oldValue = evaluate(ref);
	if (oldValue != newValue) {
	ref.setResult(newValue);
	firePropertyChange(ref, valueOf(oldValue),
	valueOf(newValue));
	}
	}
	}
	}

	/**
	* @param sourceNames
	*/
	private void startSourceChange(final String[] sourceNames) {
	if (Policy.DEBUG_SOURCES) {
	Tracing.printTrace(COMPONENT, "start source changed: " //$NON-NLS-1$
	+ Arrays.asList(sourceNames));
	}
	notifying++;
	if (notifying == 1) {
	fireServiceChange(IEvaluationService.PROP_NOTIFYING, Boolean.FALSE,
	Boolean.TRUE);
	}
	}

	/**
	* @param sourceNames
	*/
	private void endSourceChange(final String[] sourceNames) {
	if (Policy.DEBUG_SOURCES) {
	Tracing.printTrace(COMPONENT, "end source changed: " //$NON-NLS-1$
	+ Arrays.asList(sourceNames));
	}
	if (notifying == 1) {
	fireServiceChange(IEvaluationService.PROP_NOTIFYING, Boolean.TRUE,
	Boolean.FALSE);
	}
	notifying--;
	}

	/**
	* @param ref
	*/
	public void removeEvaluationListener(IEvaluationReference ref) {
	// Next we update the source priority bucket sort of activations.
	String[] sourceNames = getNames(ref);
	for (int i = 0; i < sourceNames.length; i++) {
	Map cachesByExpression = (HashMap) cachesBySourceName
	.get(sourceNames[i]);
	if (cachesByExpression != null) {
	Set caches = (Set) cachesByExpression.get(ref.getExpression());
	if (caches != null) {
	caches.remove(ref);
	if (caches.isEmpty()) {
	cachesByExpression.remove(ref.getExpression());
	}
	}
	if (cachesByExpression.isEmpty()) {
	cachesBySourceName.remove(sourceNames[i]);
	}
	}
	}
	boolean result = evaluate(ref);
	firePropertyChange(ref, valueOf(result), null);
	}

	/**
	* @param ref
	* @param oldValue
	* @param newValue
	*/
	private void firePropertyChange(IEvaluationReference ref, Object oldValue,
	Object newValue) {
	ref.getListener().propertyChange(
	new PropertyChangeEvent(ref, ref.getProperty(), oldValue,
	newValue));
	}

	private void fireServiceChange(final String property,
	final Object oldValue, final Object newValue) {
	Object[] listeners = serviceListeners.getListeners();
	for (int i = 0; i < listeners.length; i++) {
	final IPropertyChangeListener listener = (IPropertyChangeListener) listeners[i];
	SafeRunner.run(new ISafeRunnable() {
	public void handleException(Throwable exception) {
	WorkbenchPlugin.log(exception);
	}

	public void run() throws Exception {
	listener.propertyChange(new PropertyChangeEvent(
	EvaluationAuthority.this, property, oldValue,
	newValue));
	}
	});
	}
	}

	/**
	* @param listener
	*/
	public void addServiceListener(IPropertyChangeListener listener) {
	serviceListeners.add(listener);
	}

	/**
	* @param listener
	*/
	public void removeServiceListener(IPropertyChangeListener listener) {
	serviceListeners.remove(listener);
	}

	/**
	* <p>
	* Bug 95792. A mechanism by which the key binding architecture can force an
	* update of the handlers (based on the active shell) before trying to
	* execute a command. This mechanism is required for GTK+ only.
	* </p>
	* <p>
	* DO NOT CALL THIS METHOD.
	* </p>
	*/
	final void updateShellKludge() {
	updateCurrentState();
	sourceChanged(new String[] { ISources.ACTIVE_SHELL_NAME });
	}

	/**
	* Returns the currently active shell.
	*
	* @return The currently active shell; may be <code>null</code>.
	*/
	final Shell getActiveShell() {
	return (Shell) getVariable(ISources.ACTIVE_SHELL_NAME);
	}

	}