Attachment #61932 for bug #173213

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




	 * context should also be active.
	 */
	public static final int TYPE_WINDOW = 2;
	
	/**
	 * The type used for registration indicating that the shell should be
	 * treated as a dialog. When the given shell is active, the "In Dialogs"
	 * context should also be active. The active workbench window should also be
	 * available.
	 * <p>
	 * The return value from getShellType(Shell) will be TYPE_DIALOG.
	 * </p>
	 * 
	 * @since 3.3
	 */
	public static final int TYPE_DIALOG_WITH_WORKBENCH = TYPE_DIALOG | 4;

	/**
	 * <p>




import org.eclipse.ui.contexts.IContextService;
import org.eclipse.ui.internal.Workbench;
import org.eclipse.ui.internal.WorkbenchWindow;
import org.eclipse.ui.internal.contexts.ContextService;

/**
 * A provider of notifications for when the active shell changes.

	 * <code>null</code>.
	 */
	private Shell lastActiveWorkbenchWindowShell = null;

	/**
	 * The last workbench window seen as active by this provider. This value may
	 * be null if the last call to

	 * @since 3.3
	 */
	private Boolean lastCoolbarVisibility = Boolean.FALSE;

	/**
	 * The result of the last visibility check on the perspective bar of the
	 * last active workbench window.

	 * @since 3.3
	 */
	private Boolean lastPerspectiveBarVisibility = Boolean.FALSE;

	/**
	 * The listener to individual window properties.
	 * 

							newValue);
					lastCoolbarVisibility = (Boolean) newValue;
				}
			} else if (WorkbenchWindow.PROP_PERSPECTIVEBAR_VISIBLE.equals(event
			else if (WorkbenchWindow.PROP_PERSPECTIVEBAR_VISIBLE.equals(event
					.getProperty())) {
				Object newValue = event.getNewValue();
				if (newValue == null || !(newValue instanceof Boolean))

				}
			}
		}

	};

	/**
	 * The listener to shell activations on the display.
	 */

				}
				return;
			}

			if (DEBUG) {
				logDebuggingInfo("\tASSP:lastActiveShell: " + lastActiveShell); //$NON-NLS-1$
				logDebuggingInfo("\tASSP:lastActiveWorkbenchWindowShell" + lastActiveWorkbenchWindowShell); //$NON-NLS-1$

					.get(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
			final Shell newActiveWorkbenchWindowShell = (Shell) currentState
					.get(ISources.ACTIVE_WORKBENCH_WINDOW_SHELL_NAME);

			// dont update the coolbar/perspective bar visibility unless we're
			// processing a workbench window change
			final Boolean newCoolbarVisibility = newActiveWorkbenchWindow == null ? lastCoolbarVisibility

				sourceValuesByName.put(
						ISources.ACTIVE_WORKBENCH_WINDOW_SHELL_NAME,
						newActiveWorkbenchWindowShell);
				int sourceFlags = ISources.ACTIVE_SHELL
						| ISources.ACTIVE_WORKBENCH_WINDOW;

				if (coolbarChanged) {
					sourceValuesByName
							.put(
									ISources.ACTIVE_WORKBENCH_WINDOW_IS_COOLBAR_VISIBLE_NAME,
									newCoolbarVisibility);
					sourceFlags |= ISources.ACTIVE_WORKBENCH_WINDOW_SUBORDINATE;
				}
				if (perspectiveBarChanged) {
					sourceValuesByName
							.put(
									ISources.ACTIVE_WORKBENCH_WINDOW_IS_PERSPECTIVEBAR_VISIBLE_NAME,
									newPerspectiveBarVisibility);
					sourceFlags |= ISources.ACTIVE_WORKBENCH_WINDOW_SUBORDINATE;
				}


					logDebuggingInfo("Active workbench window perspective bar visibility " //$NON-NLS-1$
							+ newPerspectiveBarVisibility);
				}

				fireSourceChanged(sourceFlags, sourceValuesByName);
				hookListener(lastActiveWorkbenchWindow,
						newActiveWorkbenchWindow);

			} else if (shellChanged) {
				if (DEBUG) {

				sourceValuesByName.put(
						ISources.ACTIVE_WORKBENCH_WINDOW_SHELL_NAME,
						newActiveWorkbenchWindowShell);

				int sourceFlags = ISources.ACTIVE_SHELL
						| ISources.ACTIVE_WORKBENCH_WINDOW;

				if (coolbarChanged) {
					sourceValuesByName
							.put(
									ISources.ACTIVE_WORKBENCH_WINDOW_IS_COOLBAR_VISIBLE_NAME,
									newCoolbarVisibility);
					sourceFlags |= ISources.ACTIVE_WORKBENCH_WINDOW_SUBORDINATE;
				}
				if (perspectiveBarChanged) {
					sourceValuesByName
							.put(
									ISources.ACTIVE_WORKBENCH_WINDOW_IS_PERSPECTIVEBAR_VISIBLE_NAME,
									newPerspectiveBarVisibility);
					sourceFlags |= ISources.ACTIVE_WORKBENCH_WINDOW_SUBORDINATE;
				}

				if (DEBUG) {
					logDebuggingInfo("Active workbench window changed to " //$NON-NLS-1$
							+ newActiveWorkbenchWindow);

							+ newPerspectiveBarVisibility);
				}

				fireSourceChanged(sourceFlags, sourceValuesByName);
				hookListener(lastActiveWorkbenchWindow,
						newActiveWorkbenchWindow);
			}

			// Update the member variables.


		/*
		 * We will fallback to the workbench window, but only if a dialog is not
		 * open or it's not a specially registered TYPE_DIALOG_WITH_WORKBENCH.
		 */
		final IContextService contextService = (IContextService) workbench
				.getService(IContextService.class);
		boolean dialogSupportsWorkbench = false;
		if (contextService instanceof ContextService) {
			dialogSupportsWorkbench = ((ContextService) contextService)
					.dialogSupportsWorkbench(newActiveShell);
		}
		final int shellType = contextService.getShellType(newActiveShell);
		if (shellType != IContextService.TYPE_DIALOG || dialogSupportsWorkbench) {
			final IWorkbenchWindow newActiveWorkbenchWindow = workbench
					.getActiveWorkbenchWindow();
			final Shell newActiveWorkbenchWindowShell;

	public final String[] getProvidedSourceNames() {
		return PROVIDED_SOURCE_NAMES;
	}

	private void hookListener(WorkbenchWindow lastActiveWorkbenchWindow,
			WorkbenchWindow newActiveWorkbenchWindow) {
		if (lastActiveWorkbenchWindow != null)
			lastActiveWorkbenchWindow
					.removePropertyChangeListener(propertyListener);

		if (newActiveWorkbenchWindow != null)
			newActiveWorkbenchWindow
					.addPropertyChangeListener(propertyListener);
	}
}

Lines 46-51 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/contexts/ContextAuthority.java (-7 / +42 lines)
46	*/	46	*/
47	final class ContextAuthority extends ExpressionAuthority {	47	final class ContextAuthority extends ExpressionAuthority {
48		48
		49	private static final String DIALOG_WITH_WORKBENCH = "org.eclipse.ui.contexts.dialog_with_workbench"; //$NON-NLS-1$
		50
49	/**	51	/**
50	* The default size of the set containing the activations to recompute. This	52	* The default size of the set containing the activations to recompute. This
51	* is more than enough to cover the average case.	53	* is more than enough to cover the average case.
Lines 177-183 Link Here
177	for (int i = 1; i <= 32; i++) {	179	for (int i = 1; i <= 32; i++) {
178	if ((sourcePriority & (1 << i)) != 0) {	180	if ((sourcePriority & (1 << i)) != 0) {
179	Set activations = activationsBySourcePriority[i];	181	Set activations = activationsBySourcePriority[i];
180	if (activations == null) {	182	if (activations == null) {
181	activations = new HashSet(1);	183	activations = new HashSet(1);
182	activationsBySourcePriority[i] = activations;	184	activationsBySourcePriority[i] = activations;
183	}	185	}
Lines 378-383 Link Here
378	return (Shell) getVariable(ISources.ACTIVE_SHELL_NAME);	380	return (Shell) getVariable(ISources.ACTIVE_SHELL_NAME);
379	}	381	}
380		382
		383	public final boolean dialogSupportsWorkbench(final Shell shell) {
		384	if (shell != null) {
		385	final Collection activations = (Collection) registeredWindows
		386	.get(shell);
		387	if (activations != null) {
		388	// The shell is registered, so check what type it was registered
		389	// as.
		390	if (activations.isEmpty()) {
		391	// It was registered as none.
		392	return false;
		393	}
		394
		395	// Look for the right type of context id.
		396	final Iterator activationItr = activations.iterator();
		397	while (activationItr.hasNext()) {
		398	final IContextActivation activation = (IContextActivation) activationItr
		399	.next();
		400	final String contextId = activation.getContextId();
		401	if (contextId == DIALOG_WITH_WORKBENCH) {
		402	return true;
		403	}
		404	}
		405	}
		406	}
		407	return false;
		408	}
		409
381	/**	410	/**
382	* Returns the shell type for the given shell.	411	* Returns the shell type for the given shell.
383	*	412	*
Lines 418-426 Link Here
418	}	447	}
419		448
420	// This shouldn't be possible.	449	// This shouldn't be possible.
421	Assert.isTrue(	450	Assert
422	false,	451	.isTrue(
423	"A registered shell should have at least one submission matching TYPE_WINDOW or TYPE_DIALOG"); //$NON-NLS-1$	452	false,
		453	"A registered shell should have at least one submission matching TYPE_WINDOW or TYPE_DIALOG"); //$NON-NLS-1$
424	return IContextService.TYPE_NONE; // not reachable	454	return IContextService.TYPE_NONE; // not reachable
425		455
426	} else if (shell.getParent() != null) {	456	} else if (shell.getParent() != null) {
Lines 504-509 Link Here
504	Expression expression;	534	Expression expression;
505	IContextActivation dialogWindowActivation;	535	IContextActivation dialogWindowActivation;
506	switch (type) {	536	switch (type) {
		537	case IContextService.TYPE_DIALOG_WITH_WORKBENCH:
		538	activations.add(new ContextActivation(DIALOG_WITH_WORKBENCH, null,
		539	contextService));
507	case IContextService.TYPE_DIALOG:	540	case IContextService.TYPE_DIALOG:
508	expression = new ActiveShellExpression(shell);	541	expression = new ActiveShellExpression(shell);
509	dialogWindowActivation = new ContextActivation(	542	dialogWindowActivation = new ContextActivation(
Lines 568-574 Link Here
568	*/	601	*/
569	public void widgetDisposed(DisposeEvent e) {	602	public void widgetDisposed(DisposeEvent e) {
570	registeredWindows.remove(shell);	603	registeredWindows.remove(shell);
571	shell.removeDisposeListener(this);	604	if (!shell.isDisposed()) {
		605	shell.removeDisposeListener(this);
		606	}
572		607
573	/*	608	/*
574	* In the case where a dispose has happened, we are expecting an	609	* In the case where a dispose has happened, we are expecting an
Lines 605-611 Link Here
605	if (DEBUG_PERFORMANCE) {	640	if (DEBUG_PERFORMANCE) {
606	startTime = System.currentTimeMillis();	641	startTime = System.currentTimeMillis();
607	}	642	}
608		643
609	/*	644	/*
610	* In this first phase, we cycle through all of the activations that	645	* In this first phase, we cycle through all of the activations that
611	* could have potentially changed. Each such activation is added to a	646	* could have potentially changed. Each such activation is added to a
Lines 662-668 Link Here
662	updateContext(contextId, false);	697	updateContext(contextId, false);
663	}	698	}
664	}	699	}
665		700
666	// If tracing performance, then print the results.	701	// If tracing performance, then print the results.
667	if (DEBUG_PERFORMANCE) {	702	if (DEBUG_PERFORMANCE) {
668	final long elapsedTime = System.currentTimeMillis() - startTime;	703	final long elapsedTime = System.currentTimeMillis() - startTime;

Lines 209-214 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/contexts/ContextService.java (+4 lines)
209	public final int getShellType(final Shell shell) {	209	public final int getShellType(final Shell shell) {
210	return contextAuthority.getShellType(shell);	210	return contextAuthority.getShellType(shell);
211	}	211	}
		212
		213	public final boolean dialogSupportsWorkbench(final Shell shell) {
		214	return contextAuthority.dialogSupportsWorkbench(shell);
		215	}
212		216
213	/*	217	/*
214	* (non-Javadoc)	218	* (non-Javadoc)

Lines 45-49 Link Here

(-)Eclipse UI Tests/org/eclipse/ui/tests/commands/CommandsTestSuite.java (+1 lines)
45	addTest(new TestSuite(CommandCallbackTest.class));	45	addTest(new TestSuite(CommandCallbackTest.class));
46	addTest(new TestSuite(CommandEnablementTest.class));	46	addTest(new TestSuite(CommandEnablementTest.class));
47	addTest(new TestSuite(CommandActionTest.class));	47	addTest(new TestSuite(CommandActionTest.class));
		48	addTest(new TestSuite(WindowDialogTest.class));
48	}	49	}
49	}	50	}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.tests.commands;

import org.eclipse.core.expressions.IEvaluationContext;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.ui.ISources;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.contexts.IContextService;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.tests.harness.util.UITestCase;

/**
 * @since 3.3
 * 
 */
public class WindowDialogTest extends UITestCase {

	/**
	 * @param testName
	 */
	public WindowDialogTest(String testName) {
		super(testName);
	}

	public void testBasicApplicationContext() throws Exception {
		IWorkbenchWindow win = openTestWindow();
		IHandlerService handlerService = (IHandlerService) win
				.getService(IHandlerService.class);
		IEvaluationContext appContext = handlerService.getCurrentState();
		Object obj = appContext
				.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
		assertEquals(win, obj);
		Dialog d = new Dialog(win.getShell()) {
		};
		try {
			d.setBlockOnOpen(false);
			d.open();
			processEvents();
			appContext = handlerService.getCurrentState();
			obj = appContext.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
		} finally {
			d.close();
		}
		processEvents();
		assertNull(obj);
		appContext = handlerService.getCurrentState();
		obj = appContext.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
		assertEquals(win, obj);
	}

	public void testDialogWithWindowRef() throws Exception {
		IWorkbenchWindow win = openTestWindow();
		IHandlerService handlerService = (IHandlerService) win
				.getService(IHandlerService.class);
		IContextService contextService = (IContextService) win
				.getService(IContextService.class);
		IEvaluationContext appContext = handlerService.getCurrentState();
		Object obj = appContext
				.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
		assertEquals(win, obj);
		Dialog d = new Dialog(win.getShell()) {
		};
		try {
			d.setBlockOnOpen(false);
			d.open();
			contextService.registerShell(d.getShell(),
					IContextService.TYPE_DIALOG_WITH_WORKBENCH);
			processEvents();
			appContext = handlerService.getCurrentState();
			obj = appContext.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
		} finally {
			d.close();
		}
		processEvents();
		assertEquals(win, obj);
		appContext = handlerService.getCurrentState();
		obj = appContext.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
		assertEquals(win, obj);
	}
}

Return to bug 173213

Lines 71-76 Link Here

(-)Eclipse UI/org/eclipse/ui/contexts/IContextService.java (+13 lines)
71	* context should also be active.	71	* context should also be active.
72	*/	72	*/
73	public static final int TYPE_WINDOW = 2;	73	public static final int TYPE_WINDOW = 2;
		74
		75	/**
		76	* The type used for registration indicating that the shell should be
		77	* treated as a dialog. When the given shell is active, the "In Dialogs"
		78	* context should also be active. The active workbench window should also be
		79	* available.
		80	* <p>
		81	* The return value from getShellType(Shell) will be TYPE_DIALOG.
		82	* </p>
		83	*
		84	* @since 3.3
		85	*/
		86	public static final int TYPE_DIALOG_WITH_WORKBENCH = TYPE_DIALOG \| 4;
74		87
75	/**	88	/**
76	* <p>	89	* <p>

Lines 27-32 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/services/ActiveShellSourceProvider.java (-35 / +53 lines)
27	import org.eclipse.ui.contexts.IContextService;	27	import org.eclipse.ui.contexts.IContextService;
28	import org.eclipse.ui.internal.Workbench;	28	import org.eclipse.ui.internal.Workbench;
29	import org.eclipse.ui.internal.WorkbenchWindow;	29	import org.eclipse.ui.internal.WorkbenchWindow;
		30	import org.eclipse.ui.internal.contexts.ContextService;
30		31
31	/**	32	/**
32	* A provider of notifications for when the active shell changes.	33	* A provider of notifications for when the active shell changes.
Lines 63-69 Link Here
63	* <code>null</code>.	64	* <code>null</code>.
64	*/	65	*/
65	private Shell lastActiveWorkbenchWindowShell = null;	66	private Shell lastActiveWorkbenchWindowShell = null;
66		67
67	/**	68	/**
68	* The last workbench window seen as active by this provider. This value may	69	* The last workbench window seen as active by this provider. This value may
69	* be null if the last call to	70	* be null if the last call to
Lines 81-87 Link Here
81	* @since 3.3	82	* @since 3.3
82	*/	83	*/
83	private Boolean lastCoolbarVisibility = Boolean.FALSE;	84	private Boolean lastCoolbarVisibility = Boolean.FALSE;
84		85
85	/**	86	/**
86	* The result of the last visibility check on the perspective bar of the	87	* The result of the last visibility check on the perspective bar of the
87	* last active workbench window.	88	* last active workbench window.
Lines 89-95 Link Here
89	* @since 3.3	90	* @since 3.3
90	*/	91	*/
91	private Boolean lastPerspectiveBarVisibility = Boolean.FALSE;	92	private Boolean lastPerspectiveBarVisibility = Boolean.FALSE;
92		93
93	/**	94	/**
94	* The listener to individual window properties.	95	* The listener to individual window properties.
95	*	96	*
Lines 110-117 Link Here
110	newValue);	111	newValue);
111	lastCoolbarVisibility = (Boolean) newValue;	112	lastCoolbarVisibility = (Boolean) newValue;
112	}	113	}
113	}	114	} else if (WorkbenchWindow.PROP_PERSPECTIVEBAR_VISIBLE.equals(event
114	else if (WorkbenchWindow.PROP_PERSPECTIVEBAR_VISIBLE.equals(event
115	.getProperty())) {	115	.getProperty())) {
116	Object newValue = event.getNewValue();	116	Object newValue = event.getNewValue();
117	if (newValue == null \|\| !(newValue instanceof Boolean))	117	if (newValue == null \|\| !(newValue instanceof Boolean))
Lines 125-133 Link Here
125	}	125	}
126	}	126	}
127	}	127	}
128		128
129	};	129	};
130		130
131	/**	131	/**
132	* The listener to shell activations on the display.	132	* The listener to shell activations on the display.
133	*/	133	*/
Lines 142-148 Link Here
142	}	142	}
143	return;	143	return;
144	}	144	}
145		145
146	if (DEBUG) {	146	if (DEBUG) {
147	logDebuggingInfo("\tASSP:lastActiveShell: " + lastActiveShell); //$NON-NLS-1$	147	logDebuggingInfo("\tASSP:lastActiveShell: " + lastActiveShell); //$NON-NLS-1$
148	logDebuggingInfo("\tASSP:lastActiveWorkbenchWindowShell" + lastActiveWorkbenchWindowShell); //$NON-NLS-1$	148	logDebuggingInfo("\tASSP:lastActiveWorkbenchWindowShell" + lastActiveWorkbenchWindowShell); //$NON-NLS-1$
Lines 155-161 Link Here
155	.get(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);	155	.get(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
156	final Shell newActiveWorkbenchWindowShell = (Shell) currentState	156	final Shell newActiveWorkbenchWindowShell = (Shell) currentState
157	.get(ISources.ACTIVE_WORKBENCH_WINDOW_SHELL_NAME);	157	.get(ISources.ACTIVE_WORKBENCH_WINDOW_SHELL_NAME);
158		158
159	// dont update the coolbar/perspective bar visibility unless we're	159	// dont update the coolbar/perspective bar visibility unless we're
160	// processing a workbench window change	160	// processing a workbench window change
161	final Boolean newCoolbarVisibility = newActiveWorkbenchWindow == null ? lastCoolbarVisibility	161	final Boolean newCoolbarVisibility = newActiveWorkbenchWindow == null ? lastCoolbarVisibility
Lines 180-195 Link Here
180	sourceValuesByName.put(	180	sourceValuesByName.put(
181	ISources.ACTIVE_WORKBENCH_WINDOW_SHELL_NAME,	181	ISources.ACTIVE_WORKBENCH_WINDOW_SHELL_NAME,
182	newActiveWorkbenchWindowShell);	182	newActiveWorkbenchWindowShell);
183	int sourceFlags = ISources.ACTIVE_SHELL \| ISources.ACTIVE_WORKBENCH_WINDOW;	183	int sourceFlags = ISources.ACTIVE_SHELL
184		184	\| ISources.ACTIVE_WORKBENCH_WINDOW;
		185
185	if (coolbarChanged) {	186	if (coolbarChanged) {
186	sourceValuesByName.put(ISources.ACTIVE_WORKBENCH_WINDOW_IS_COOLBAR_VISIBLE_NAME,	187	sourceValuesByName
187	newCoolbarVisibility);	188	.put(
		189	ISources.ACTIVE_WORKBENCH_WINDOW_IS_COOLBAR_VISIBLE_NAME,
		190	newCoolbarVisibility);
188	sourceFlags \|= ISources.ACTIVE_WORKBENCH_WINDOW_SUBORDINATE;	191	sourceFlags \|= ISources.ACTIVE_WORKBENCH_WINDOW_SUBORDINATE;
189	}	192	}
190	if (perspectiveBarChanged) {	193	if (perspectiveBarChanged) {
191	sourceValuesByName.put(ISources.ACTIVE_WORKBENCH_WINDOW_IS_PERSPECTIVEBAR_VISIBLE_NAME,	194	sourceValuesByName
192	newPerspectiveBarVisibility);	195	.put(
		196	ISources.ACTIVE_WORKBENCH_WINDOW_IS_PERSPECTIVEBAR_VISIBLE_NAME,
		197	newPerspectiveBarVisibility);
193	sourceFlags \|= ISources.ACTIVE_WORKBENCH_WINDOW_SUBORDINATE;	198	sourceFlags \|= ISources.ACTIVE_WORKBENCH_WINDOW_SUBORDINATE;
194	}	199	}
195		200
Lines 205-213 Link Here
205	logDebuggingInfo("Active workbench window perspective bar visibility " //$NON-NLS-1$	210	logDebuggingInfo("Active workbench window perspective bar visibility " //$NON-NLS-1$
206	+ newPerspectiveBarVisibility);	211	+ newPerspectiveBarVisibility);
207	}	212	}
208		213
209	fireSourceChanged(sourceFlags, sourceValuesByName);	214	fireSourceChanged(sourceFlags, sourceValuesByName);
210	hookListener(lastActiveWorkbenchWindow, newActiveWorkbenchWindow);	215	hookListener(lastActiveWorkbenchWindow,
		216	newActiveWorkbenchWindow);
211		217
212	} else if (shellChanged) {	218	} else if (shellChanged) {
213	if (DEBUG) {	219	if (DEBUG) {
Lines 224-243 Link Here
224	sourceValuesByName.put(	230	sourceValuesByName.put(
225	ISources.ACTIVE_WORKBENCH_WINDOW_SHELL_NAME,	231	ISources.ACTIVE_WORKBENCH_WINDOW_SHELL_NAME,
226	newActiveWorkbenchWindowShell);	232	newActiveWorkbenchWindowShell);
227		233
228	int sourceFlags = ISources.ACTIVE_SHELL \| ISources.ACTIVE_WORKBENCH_WINDOW;	234	int sourceFlags = ISources.ACTIVE_SHELL
229		235	\| ISources.ACTIVE_WORKBENCH_WINDOW;
		236
230	if (coolbarChanged) {	237	if (coolbarChanged) {
231	sourceValuesByName.put(ISources.ACTIVE_WORKBENCH_WINDOW_IS_COOLBAR_VISIBLE_NAME,	238	sourceValuesByName
232	newCoolbarVisibility);	239	.put(
		240	ISources.ACTIVE_WORKBENCH_WINDOW_IS_COOLBAR_VISIBLE_NAME,
		241	newCoolbarVisibility);
233	sourceFlags \|= ISources.ACTIVE_WORKBENCH_WINDOW_SUBORDINATE;	242	sourceFlags \|= ISources.ACTIVE_WORKBENCH_WINDOW_SUBORDINATE;
234	}	243	}
235	if (perspectiveBarChanged) {	244	if (perspectiveBarChanged) {
236	sourceValuesByName.put(ISources.ACTIVE_WORKBENCH_WINDOW_IS_PERSPECTIVEBAR_VISIBLE_NAME,	245	sourceValuesByName
237	newPerspectiveBarVisibility);	246	.put(
		247	ISources.ACTIVE_WORKBENCH_WINDOW_IS_PERSPECTIVEBAR_VISIBLE_NAME,
		248	newPerspectiveBarVisibility);
238	sourceFlags \|= ISources.ACTIVE_WORKBENCH_WINDOW_SUBORDINATE;	249	sourceFlags \|= ISources.ACTIVE_WORKBENCH_WINDOW_SUBORDINATE;
239	}	250	}
240		251
241	if (DEBUG) {	252	if (DEBUG) {
242	logDebuggingInfo("Active workbench window changed to " //$NON-NLS-1$	253	logDebuggingInfo("Active workbench window changed to " //$NON-NLS-1$
243	+ newActiveWorkbenchWindow);	254	+ newActiveWorkbenchWindow);
Lines 249-257 Link Here
249	+ newPerspectiveBarVisibility);	260	+ newPerspectiveBarVisibility);
250	}	261	}
251		262
252	fireSourceChanged(sourceFlags,	263	fireSourceChanged(sourceFlags, sourceValuesByName);
253	sourceValuesByName);	264	hookListener(lastActiveWorkbenchWindow,
254	hookListener(lastActiveWorkbenchWindow, newActiveWorkbenchWindow);	265	newActiveWorkbenchWindow);
255	}	266	}
256		267
257	// Update the member variables.	268	// Update the member variables.
Lines 297-308 Link Here
297		308
298	/*	309	/*
299	* We will fallback to the workbench window, but only if a dialog is not	310	* We will fallback to the workbench window, but only if a dialog is not
300	* open.	311	* open or it's not a specially registered TYPE_DIALOG_WITH_WORKBENCH.
301	*/	312	*/
302	final IContextService contextService = (IContextService) workbench	313	final IContextService contextService = (IContextService) workbench
303	.getService(IContextService.class);	314	.getService(IContextService.class);
		315	boolean dialogSupportsWorkbench = false;
		316	if (contextService instanceof ContextService) {
		317	dialogSupportsWorkbench = ((ContextService) contextService)
		318	.dialogSupportsWorkbench(newActiveShell);
		319	}
304	final int shellType = contextService.getShellType(newActiveShell);	320	final int shellType = contextService.getShellType(newActiveShell);
305	if (shellType != IContextService.TYPE_DIALOG) {	321	if (shellType != IContextService.TYPE_DIALOG \|\| dialogSupportsWorkbench) {
306	final IWorkbenchWindow newActiveWorkbenchWindow = workbench	322	final IWorkbenchWindow newActiveWorkbenchWindow = workbench
307	.getActiveWorkbenchWindow();	323	.getActiveWorkbenchWindow();
308	final Shell newActiveWorkbenchWindowShell;	324	final Shell newActiveWorkbenchWindowShell;
Lines 324-336 Link Here
324	public final String[] getProvidedSourceNames() {	340	public final String[] getProvidedSourceNames() {
325	return PROVIDED_SOURCE_NAMES;	341	return PROVIDED_SOURCE_NAMES;
326	}	342	}
327		343
328	private void hookListener(WorkbenchWindow lastActiveWorkbenchWindow,	344	private void hookListener(WorkbenchWindow lastActiveWorkbenchWindow,
329	WorkbenchWindow newActiveWorkbenchWindow) {	345	WorkbenchWindow newActiveWorkbenchWindow) {
330	if (lastActiveWorkbenchWindow != null)	346	if (lastActiveWorkbenchWindow != null)
331	lastActiveWorkbenchWindow.removePropertyChangeListener(propertyListener);	347	lastActiveWorkbenchWindow
332		348	.removePropertyChangeListener(propertyListener);
		349
333	if (newActiveWorkbenchWindow != null)	350	if (newActiveWorkbenchWindow != null)
334	newActiveWorkbenchWindow.addPropertyChangeListener(propertyListener);	351	newActiveWorkbenchWindow
		352	.addPropertyChangeListener(propertyListener);
335	}	353	}
336	}	354	}

Added Link Here

(-)Eclipse (+90 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.tests.commands;
13
14	import org.eclipse.core.expressions.IEvaluationContext;
15	import org.eclipse.jface.dialogs.Dialog;
16	import org.eclipse.ui.ISources;
17	import org.eclipse.ui.IWorkbenchWindow;
18	import org.eclipse.ui.contexts.IContextService;
19	import org.eclipse.ui.handlers.IHandlerService;
20	import org.eclipse.ui.tests.harness.util.UITestCase;
21
22	/**
23	* @since 3.3
24	*
25	*/
26	public class WindowDialogTest extends UITestCase {
27
28	/**
29	* @param testName
30	*/
31	public WindowDialogTest(String testName) {
32	super(testName);
33	}
34
35	public void testBasicApplicationContext() throws Exception {
36	IWorkbenchWindow win = openTestWindow();
37	IHandlerService handlerService = (IHandlerService) win
38	.getService(IHandlerService.class);
39	IEvaluationContext appContext = handlerService.getCurrentState();
40	Object obj = appContext
41	.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
42	assertEquals(win, obj);
43	Dialog d = new Dialog(win.getShell()) {
44	};
45	try {
46	d.setBlockOnOpen(false);
47	d.open();
48	processEvents();
49	appContext = handlerService.getCurrentState();
50	obj = appContext.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
51	} finally {
52	d.close();
53	}
54	processEvents();
55	assertNull(obj);
56	appContext = handlerService.getCurrentState();
57	obj = appContext.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
58	assertEquals(win, obj);
59	}
60
61	public void testDialogWithWindowRef() throws Exception {
62	IWorkbenchWindow win = openTestWindow();
63	IHandlerService handlerService = (IHandlerService) win
64	.getService(IHandlerService.class);
65	IContextService contextService = (IContextService) win
66	.getService(IContextService.class);
67	IEvaluationContext appContext = handlerService.getCurrentState();
68	Object obj = appContext
69	.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
70	assertEquals(win, obj);
71	Dialog d = new Dialog(win.getShell()) {
72	};
73	try {
74	d.setBlockOnOpen(false);
75	d.open();
76	contextService.registerShell(d.getShell(),
77	IContextService.TYPE_DIALOG_WITH_WORKBENCH);
78	processEvents();
79	appContext = handlerService.getCurrentState();
80	obj = appContext.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
81	} finally {
82	d.close();
83	}
84	processEvents();
85	assertEquals(win, obj);
86	appContext = handlerService.getCurrentState();
87	obj = appContext.getVariable(ISources.ACTIVE_WORKBENCH_WINDOW_NAME);
88	assertEquals(win, obj);
89	}
90	}