Attachment #66535 for bug #185523

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 61-66 Link Here

(-)src/org/eclipse/jface/bindings/CachedBindingSet.java (+14 lines)
61	* This value may be <code>null</code> if it has not yet been initialized.	61	* This value may be <code>null</code> if it has not yet been initialized.
62	*/	62	*/
63	private Map bindingsByTrigger = null;	63	private Map bindingsByTrigger = null;
		64
		65	private Map conflictsByTrigger = null;
64		66
65	/**	67	/**
66	* The hash code for this object. This value is computed lazily, and marked	68	* The hash code for this object. This value is computed lazily, and marked
Lines 229-234 Link Here
229	final Map getBindingsByTrigger() {	231	final Map getBindingsByTrigger() {
230	return bindingsByTrigger;	232	return bindingsByTrigger;
231	}	233	}
		234
		235	final Map getConflictsByTrigger() {
		236	return conflictsByTrigger;
		237	}
232		238
233	/**	239	/**
234	* Returns the map of prefixes to a map of trigger sequence to command	240	* Returns the map of prefixes to a map of trigger sequence to command
Lines 294-299 Link Here
294		300
295	this.bindingsByTrigger = commandIdsByTrigger;	301	this.bindingsByTrigger = commandIdsByTrigger;
296	}	302	}
		303
		304	final void setConflictsByTrigger(final Map c) {
		305	if (c == null) {
		306	throw new NullPointerException(
		307	"Cannot set a null binding conflicts"); //$NON-NLS-1$
		308	}
		309	conflictsByTrigger = c;
		310	}
297		311
298	/**	312	/**
299	* Sets the map of prefixes to a map of trigger sequence to command	313	* Sets the map of prefixes to a map of trigger sequence to command

Lines 42-47 Link Here

(-)src/org/eclipse/jface/bindings/BindingManager.java (-11 / +24 lines)
42	import org.eclipse.jface.bindings.keys.KeyLookupFactory;	42	import org.eclipse.jface.bindings.keys.KeyLookupFactory;
43	import org.eclipse.jface.bindings.keys.KeyStroke;	43	import org.eclipse.jface.bindings.keys.KeyStroke;
44	import org.eclipse.jface.contexts.IContextIds;	44	import org.eclipse.jface.contexts.IContextIds;
		45	import org.eclipse.jface.internal.InternalPolicy;
45	import org.eclipse.jface.util.Policy;	46	import org.eclipse.jface.util.Policy;
46	import org.eclipse.jface.util.Util;	47	import org.eclipse.jface.util.Util;
47	import org.eclipse.swt.SWT;	48	import org.eclipse.swt.SWT;
Lines 181-186 Link Here
181	* Otherwise, this value may be empty.	182	* Otherwise, this value may be empty.
182	*/	183	*/
183	private Map activeBindingsByParameterizedCommand = null;	184	private Map activeBindingsByParameterizedCommand = null;
		185
		186	private Set triggerConflicts = new HashSet();
184		187
185	/**	188	/**
186	* The scheme that is currently active. An active scheme is the one that is	189	* The scheme that is currently active. An active scheme is the one that is
Lines 272-279 Link Here
272	*/	275	*/
273	private Map prefixTable = null;	276	private Map prefixTable = null;
274		277
275	private Set triggerConflicts = new HashSet();
276
277	/**	278	/**
278	* <p>	279	* <p>
279	* Constructs a new instance of <code>BindingManager</code>.	280	* Constructs a new instance of <code>BindingManager</code>.
Lines 438-444 Link Here
438	* This method completes in <code>O(1)</code>.	439	* This method completes in <code>O(1)</code>.
439	*/	440	*/
440	private final void clearSolution() {	441	private final void clearSolution() {
441	setActiveBindings(null, null, null);	442	setActiveBindings(null, null, null, null);
442	}	443	}
443		444
444	/**	445	/**
Lines 511-517 Link Here
511	* computed).	512	* computed).
512	*/	513	*/
513	private final void computeBindings(final Map activeContextTree,	514	private final void computeBindings(final Map activeContextTree,
514	final Map bindingsByTrigger, final Map triggersByCommandId) {	515	final Map bindingsByTrigger, final Map triggersByCommandId,
		516	final Map conflictsByTrigger) {
515	/*	517	/*
516	* FIRST PASS: Remove all of the bindings that are marking deletions.	518	* FIRST PASS: Remove all of the bindings that are marking deletions.
517	*/	519	*/
Lines 632-637 Link Here
632	activeContextTree);	634	activeContextTree);
633	if (winner == null) {	635	if (winner == null) {
634	// warn once ... so as not to flood the logs	636	// warn once ... so as not to flood the logs
		637	conflictsByTrigger.put(trigger, match);
635	if (triggerConflicts.add(trigger)) {	638	if (triggerConflicts.add(trigger)) {
636	final StringWriter sw = new StringWriter();	639	final StringWriter sw = new StringWriter();
637	final BufferedWriter buffer = new BufferedWriter(sw);	640	final BufferedWriter buffer = new BufferedWriter(sw);
Lines 997-1006 Link Here
997	// Compute the active bindings.	1000	// Compute the active bindings.
998	commandIdsByTrigger = new HashMap();	1001	commandIdsByTrigger = new HashMap();
999	final Map triggersByParameterizedCommand = new HashMap();	1002	final Map triggersByParameterizedCommand = new HashMap();
		1003	final Map conflictsByTrigger = new HashMap();
1000	computeBindings(null, commandIdsByTrigger,	1004	computeBindings(null, commandIdsByTrigger,
1001	triggersByParameterizedCommand);	1005	triggersByParameterizedCommand, conflictsByTrigger);
1002	existingCache.setBindingsByTrigger(commandIdsByTrigger);	1006	existingCache.setBindingsByTrigger(commandIdsByTrigger);
1003	existingCache.setTriggersByCommandId(triggersByParameterizedCommand);	1007	existingCache.setTriggersByCommandId(triggersByParameterizedCommand);
		1008	existingCache.setConflictsByTrigger(conflictsByTrigger);
1004	return Collections.unmodifiableMap(commandIdsByTrigger);	1009	return Collections.unmodifiableMap(commandIdsByTrigger);
1005	}	1010	}
1006		1011
Lines 1057-1067 Link Here
1057		1062
1058	// Compute the active bindings.	1063	// Compute the active bindings.
1059	final Map commandIdsByTrigger = new HashMap();	1064	final Map commandIdsByTrigger = new HashMap();
		1065	final Map conflictsByTrigger = new HashMap();
1060	triggersByParameterizedCommand = new HashMap();	1066	triggersByParameterizedCommand = new HashMap();
1061	computeBindings(null, commandIdsByTrigger,	1067	computeBindings(null, commandIdsByTrigger,
1062	triggersByParameterizedCommand);	1068	triggersByParameterizedCommand, conflictsByTrigger);
1063	existingCache.setBindingsByTrigger(commandIdsByTrigger);	1069	existingCache.setBindingsByTrigger(commandIdsByTrigger);
1064	existingCache.setTriggersByCommandId(triggersByParameterizedCommand);	1070	existingCache.setTriggersByCommandId(triggersByParameterizedCommand);
		1071	existingCache.setConflictsByTrigger(conflictsByTrigger);
1065		1072
1066	return Collections.unmodifiableMap(triggersByParameterizedCommand);	1073	return Collections.unmodifiableMap(triggersByParameterizedCommand);
1067	}	1074	}
Lines 1703-1709 Link Here
1703	if (bindings == null) {	1710	if (bindings == null) {
1704	// Not yet initialized. This is happening too early. Do nothing.	1711	// Not yet initialized. This is happening too early. Do nothing.
1705	setActiveBindings(Collections.EMPTY_MAP, Collections.EMPTY_MAP,	1712	setActiveBindings(Collections.EMPTY_MAP, Collections.EMPTY_MAP,
1706	Collections.EMPTY_MAP);	1713	Collections.EMPTY_MAP, Collections.EMPTY_MAP);
1707	return;	1714	return;
1708	}	1715	}
1709		1716
Lines 1732-1738 Link Here
1732	Tracing.printTrace("BINDINGS", "Cache hit"); //$NON-NLS-1$ //$NON-NLS-2$	1739	Tracing.printTrace("BINDINGS", "Cache hit"); //$NON-NLS-1$ //$NON-NLS-2$
1733	}	1740	}
1734	setActiveBindings(commandIdsByTrigger, existingCache	1741	setActiveBindings(commandIdsByTrigger, existingCache
1735	.getTriggersByCommandId(), existingCache.getPrefixTable());	1742	.getTriggersByCommandId(), existingCache.getPrefixTable(),
		1743	existingCache.getConflictsByTrigger());
1736	return;	1744	return;
1737	}	1745	}
1738		1746
Lines 1744-1755 Link Here
1744	// Compute the active bindings.	1752	// Compute the active bindings.
1745	commandIdsByTrigger = new HashMap();	1753	commandIdsByTrigger = new HashMap();
1746	final Map triggersByParameterizedCommand = new HashMap();	1754	final Map triggersByParameterizedCommand = new HashMap();
		1755	final Map conflictsByTrigger = new HashMap();
1747	computeBindings(activeContextTree, commandIdsByTrigger,	1756	computeBindings(activeContextTree, commandIdsByTrigger,
1748	triggersByParameterizedCommand);	1757	triggersByParameterizedCommand, conflictsByTrigger);
1749	existingCache.setBindingsByTrigger(commandIdsByTrigger);	1758	existingCache.setBindingsByTrigger(commandIdsByTrigger);
1750	existingCache.setTriggersByCommandId(triggersByParameterizedCommand);	1759	existingCache.setTriggersByCommandId(triggersByParameterizedCommand);
		1760	existingCache.setConflictsByTrigger(conflictsByTrigger);
1751	setActiveBindings(commandIdsByTrigger, triggersByParameterizedCommand,	1761	setActiveBindings(commandIdsByTrigger, triggersByParameterizedCommand,
1752	buildPrefixTable(commandIdsByTrigger));	1762	buildPrefixTable(commandIdsByTrigger),
		1763	conflictsByTrigger);
1753	existingCache.setPrefixTable(prefixTable);	1764	existingCache.setPrefixTable(prefixTable);
1754	}	1765	}
1755		1766
Lines 2153-2163 Link Here
2153	* solution.	2164	* solution.
2154	*/	2165	*/
2155	private final void setActiveBindings(final Map activeBindings,	2166	private final void setActiveBindings(final Map activeBindings,
2156	final Map activeBindingsByCommandId, final Map prefixTable) {	2167	final Map activeBindingsByCommandId, final Map prefixTable,
		2168	final Map conflicts) {
2157	this.activeBindings = activeBindings;	2169	this.activeBindings = activeBindings;
2158	final Map previousBindingsByParameterizedCommand = this.activeBindingsByParameterizedCommand;	2170	final Map previousBindingsByParameterizedCommand = this.activeBindingsByParameterizedCommand;
2159	this.activeBindingsByParameterizedCommand = activeBindingsByCommandId;	2171	this.activeBindingsByParameterizedCommand = activeBindingsByCommandId;
2160	this.prefixTable = prefixTable;	2172	this.prefixTable = prefixTable;
		2173	InternalPolicy.currentConflicts = conflicts;
2161		2174
2162	fireBindingManagerChanged(new BindingManagerEvent(this, true,	2175	fireBindingManagerChanged(new BindingManagerEvent(this, true,
2163	previousBindingsByParameterizedCommand, false, null, false,	2176	previousBindingsByParameterizedCommand, false, null, false,

Lines 10-15 Link Here

(-)src/org/eclipse/jface/internal/InternalPolicy.java (+8 lines)
10	******************************************************************************/	10	******************************************************************************/
11	package org.eclipse.jface.internal;	11	package org.eclipse.jface.internal;
12		12
		13	import java.util.HashMap;
		14	import java.util.Map;
		15
13	/**	16	/**
14	* Internal class used for non-API debug flags.	17	* Internal class used for non-API debug flags.
15	*	18	*
Lines 25-28 Link Here
25	*/	28	*/
26	public static boolean DEBUG_LOG_REENTRANT_VIEWER_CALLS = false;	29	public static boolean DEBUG_LOG_REENTRANT_VIEWER_CALLS = false;
27		30
		31	/**
		32	* (NON-API) Instead of logging current conflicts they can be
		33	* held here. If there is a problem, they can be reported then.
		34	*/
		35	public static Map currentConflicts = new HashMap();
28	}	36	}




package org.eclipse.ui.internal.keys;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ResourceBundle;

import org.eclipse.jface.bindings.keys.KeyStroke;
import org.eclipse.jface.bindings.keys.ParseException;
import org.eclipse.jface.bindings.keys.SWTKeySupport;
import org.eclipse.jface.internal.InternalPolicy;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.widgets.Combo;

		}

		try {
			final IHandlerService handlerService = (IHandlerService) workbench
					.getService(IHandlerService.class);
			handlerService.executeCommand(parameterizedCommand, trigger);
		} catch (final NotDefinedException e) {
			// The command is not defined. Forwarded to the IExecutionListener.

	 */
	private Binding getPerfectMatch(KeySequence keySequence) {
		if (bindingService == null) {
			bindingService = (IBindingService) workbench
					.getService(IBindingService.class);
		}
		return bindingService.getPerfectMatch(keySequence);
	}

	final KeySequence getBuffer() {
		return state.getCurrentSequence();
	}

	 */
	private boolean isPartialMatch(KeySequence keySequence) {
		if (bindingService == null) {
			bindingService = (IBindingService) workbench
					.getService(IBindingService.class);
		}
		return bindingService.isPartialMatch(keySequence);
	}

	 */
	private boolean isPerfectMatch(KeySequence keySequence) {
		if (bindingService == null) {
			bindingService = (IBindingService) workbench
					.getService(IBindingService.class);
		}
		return bindingService.isPerfectMatch(keySequence);
	}

		}
		keyAssistDialog.open();
	}
	
	public final void openKeyAssistShell(Collection bindings) {
		if (keyAssistDialog == null) {
			keyAssistDialog = new KeyAssistDialog(workbench, this, state);
		}
		if (keyAssistDialog.getShell() == null) {
			keyAssistDialog.setParentShell(Util.getShellToParentOn());
		}
		keyAssistDialog.open(bindings);
	}

	/**
	 * Processes a key press with respect to the key binding architecture. This

			final Widget widget = event.widget;

			// Update the contexts.
			final ContextService contextService = (ContextService) workbench
					.getService(IContextService.class);
			if ((widget instanceof Control) && (!widget.isDisposed())) {
				final Shell shell = ((Control) widget).getShell();
				contextService.updateShellKludge(shell);

			}

			// Update the handlers.
			final HandlerService handlerService = (HandlerService) workbench
					.getService(IHandlerService.class);
			if ((widget instanceof Control) && (!widget.isDisposed())) {
				final Shell shell = ((Control) widget).getShell();
				handlerService.updateShellKludge(shell);

			}
		}

		KeySequence errorSequence = null;
		Collection errorMatch = null;

		KeySequence sequenceBeforeKeyStroke = state.getCurrentSequence();
		for (Iterator iterator = potentialKeyStrokes.iterator(); iterator
				.hasNext();) {

				// We don't want to swallow keyboard navigation keys.
				return false;

			} else {
				Collection match = (InternalPolicy.currentConflicts==null?null:(Collection) InternalPolicy.currentConflicts
						.get(sequenceAfterKeyStroke));
				if (match != null) {
					errorSequence = sequenceAfterKeyStroke;
					errorMatch = match;
				}
			}
		}

		resetState(true);
		if (sequenceBeforeKeyStroke.isEmpty() && errorSequence != null) {
			openKeyAssistShell(errorMatch);
		}
		return !sequenceBeforeKeyStroke.isEmpty();
	}


Lines 11-18 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/keys/KeyAssistDialog.java (-2 / +51 lines)
11		11
12	package org.eclipse.ui.internal.keys;	12	package org.eclipse.ui.internal.keys;
13		13
14	import com.ibm.icu.text.MessageFormat;
15	import java.util.ArrayList;	14	import java.util.ArrayList;
		15	import java.util.Collection;
16	import java.util.Comparator;	16	import java.util.Comparator;
17	import java.util.Iterator;	17	import java.util.Iterator;
18	import java.util.List;	18	import java.util.List;
Lines 55-60 Link Here
55	import org.eclipse.ui.internal.util.Util;	55	import org.eclipse.ui.internal.util.Util;
56	import org.eclipse.ui.keys.IBindingService;	56	import org.eclipse.ui.keys.IBindingService;
57		57
		58	import com.ibm.icu.text.MessageFormat;
		59
58	/**	60	/**
59	* <p>	61	* <p>
60	* A dialog displaying a list of key bindings. The dialog will execute a command	62	* A dialog displaying a list of key bindings. The dialog will execute a command
Lines 142-147 Link Here
142	*/	144	*/
143	private final WorkbenchKeyboard workbenchKeyboard;	145	private final WorkbenchKeyboard workbenchKeyboard;
144		146
		147	private SortedMap conflictMatches;
		148
145	/**	149	/**
146	* Constructs a new instance of <code>KeyAssistDialog</code>. When the	150	* Constructs a new instance of <code>KeyAssistDialog</code>. When the
147	* dialog is first constructed, it contains no widgets. The dialog is first	151	* dialog is first constructed, it contains no widgets. The dialog is first
Lines 419-425 Link Here
419	composite.setBackground(parent.getBackground());	423	composite.setBackground(parent.getBackground());
420		424
421	// Layout the partial matches.	425	// Layout the partial matches.
422	final SortedMap partialMatches = getPartialMatches();	426	final SortedMap partialMatches;
		427	if (conflictMatches!=null) {
		428	partialMatches = conflictMatches;
		429	conflictMatches=null;
		430	} else {
		431	partialMatches = getPartialMatches();
		432	}
		433
423	if (partialMatches.isEmpty()) {	434	if (partialMatches.isEmpty()) {
424	createEmptyDialogArea(composite);	435	createEmptyDialogArea(composite);
425	} else {	436	} else {
Lines 640-645 Link Here
640	// Call the super method.	651	// Call the super method.
641	return super.open();	652	return super.open();
642	}	653	}
		654
		655	public final int open(Collection bindings) {
		656	conflictMatches = new TreeMap(new Comparator() {
		657	public final int compare(final Object a, final Object b) {
		658	final Binding bindingA = (Binding) a;
		659	final Binding bindingB = (Binding) b;
		660	final ParameterizedCommand commandA = bindingA
		661	.getParameterizedCommand();
		662	final ParameterizedCommand commandB = bindingB
		663	.getParameterizedCommand();
		664	try {
		665	return commandA.getName().compareTo(commandB.getName());
		666	} catch (final NotDefinedException e) {
		667	// should not happen
		668	return 0;
		669	}
		670	}
		671	});
		672	Iterator i = bindings.iterator();
		673	while (i.hasNext()) {
		674	Binding b = (Binding) i.next();
		675	conflictMatches.put(b, b.getTriggerSequence());
		676	}
		677
		678	// If the dialog is already open, dispose the shell and recreate it.
		679	final Shell shell = getShell();
		680	if (shell != null) {
		681	close(false, false);
		682	}
		683	create();
		684
		685	// Configure the size and location.
		686	final Point size = configureSize();
		687	configureLocation(size);
		688
		689	// Call the super method.
		690	return super.open();
		691	}
643		692
644	/**	693	/**
645	* Registers the shell as the same type as its parent with the context	694	* Registers the shell as the same type as its parent with the context

Return to bug 185523