| /******************************************************************************* |
| * Copyright (c) 2000, 2006 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 java.util.Map; |
| |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.commands.AbstractHandler; |
| import org.eclipse.ui.commands.ExecutionException; |
| import org.eclipse.ui.commands.HandlerSubmission; |
| import org.eclipse.ui.commands.ICommand; |
| import org.eclipse.ui.commands.IHandler; |
| import org.eclipse.ui.commands.IWorkbenchCommandSupport; |
| import org.eclipse.ui.commands.NotHandledException; |
| import org.eclipse.ui.commands.Priority; |
| import org.eclipse.ui.tests.harness.util.UITestCase; |
| |
| /** |
| * Tests that dialogs will inherit the handlers from the workbench window, if |
| * none is defined for the dialog itself. It tests all of the various |
| * combinations of this situation. |
| * |
| * @since 3.0 |
| */ |
| public final class Bug66182Test extends UITestCase { |
| |
| /** |
| * Constructor for Bug66182Test. |
| * |
| * @param name |
| * The name of the test |
| */ |
| public Bug66182Test(final String name) { |
| super(name); |
| } |
| |
| /** |
| * Tests that the dialog handlers will take priority. The set-up is a |
| * workbench window with a handler registered for the command to test. Then |
| * there is a dialog opened with a handler for the same command. The test is |
| * to see that the dialog's handler gets priority. |
| * |
| * @throws ExecutionException |
| * This should never happen, and indicates a problem with the |
| * test. |
| * @throws NotHandledException |
| * Indicates that no handler was found where one should have |
| * been found. |
| */ |
| public final void testDialogHandlers() throws ExecutionException, |
| NotHandledException { |
| // Open a test window. |
| // final IWorkbenchWindow window = openTestWindow(); |
| // |
| // // Define a handler for some random command identifier. |
| // final Object windowResult = new Object(); |
| // final IHandler windowHandler = new AbstractHandler() { |
| // |
| // public Object execute(Map parameterValuesByName) |
| // throws ExecutionException { |
| // // Do nothing. |
| // return windowResult; |
| // } |
| // }; |
| // final IWorkbenchCommandSupport commandSupport = fWorkbench |
| // .getCommandSupport(); |
| // final String commandId = "org.eclipse.ui.tests.Bug66182"; |
| // final Shell windowShell = window.getShell(); |
| // final HandlerSubmission windowSubmission = new HandlerSubmission(null, |
| // windowShell, null, commandId, windowHandler, Priority.MEDIUM); |
| // commandSupport.addHandlerSubmission(windowSubmission); |
| // |
| // // Open a dialog. |
| // final Shell dialogShell = new Shell(windowShell); |
| // dialogShell.pack(); |
| // dialogShell.open(); |
| // final Display display = dialogShell.getDisplay(); |
| // while (display.readAndDispatch()) |
| // ; |
| // |
| // /* |
| // * Define a handler for the same command identifier, but for this |
| // * dialog. |
| // */ |
| // final Object dialogResult = new Object(); |
| // final IHandler dialogHandler = new AbstractHandler() { |
| // |
| // public Object execute(Map parameterValuesByName) |
| // throws ExecutionException { |
| // // Do nothing. |
| // return dialogResult; |
| // } |
| // }; |
| // final HandlerSubmission dialogSubmission = new HandlerSubmission(null, |
| // dialogShell, null, commandId, dialogHandler, Priority.MEDIUM); |
| // commandSupport.addHandlerSubmission(dialogSubmission); |
| // |
| // // Check to see which handler is the right handler. |
| // final ICommand command = commandSupport.getCommandManager().getCommand( |
| // commandId); |
| // assertSame( |
| // "The active shell must be the dialog. If you are activating other shells while this test is running, then this test will fail", |
| // dialogShell, display.getActiveShell()); |
| // assertSame( |
| // "The active workbench window must be the window created in this test. If you are activating other workbench windows, then this test will fail", |
| // windowShell, fWorkbench.getActiveWorkbenchWindow().getShell()); |
| // final Object result = command.execute(Collections.EMPTY_MAP); |
| // assertSame( |
| // "The dialog handler was not chosen when both a window and dialog handler were defined.", |
| // dialogResult, result); |
| // |
| // // Close the dialog and let the event loop spin. |
| // commandSupport.removeHandlerSubmission(windowSubmission); |
| // commandSupport.removeHandlerSubmission(dialogSubmission); |
| // dialogShell.close(); |
| // while (display.readAndDispatch()) |
| // ; |
| } |
| |
| /** |
| * Tests that, in the absence of a dialog handler, that the window handler |
| * will be given a chance to take over. The set-up is a workbench window |
| * with a handler registered for the command to test. Then there is a dialog |
| * opened, but with no handler. The test is to see that the window's handler |
| * is active. |
| * |
| * @throws ExecutionException |
| * This should never happen, and indicates a problem with the |
| * test. |
| * @throws NotHandledException |
| * Indicates that no handler was found where one should have |
| * been found. |
| */ |
| public final void testFallbackToWindow() throws ExecutionException, |
| NotHandledException { |
| // Open a test window. |
| // final IWorkbenchWindow window = openTestWindow(); |
| // |
| // // Define a handler for some random command identifier. |
| // final Object windowResult = new Object(); |
| // final IHandler windowHandler = new AbstractHandler() { |
| // |
| // public Object execute(Map parameterValuesByName) |
| // throws ExecutionException { |
| // // Do nothing. |
| // return windowResult; |
| // } |
| // }; |
| // final IWorkbenchCommandSupport commandSupport = fWorkbench |
| // .getCommandSupport(); |
| // final String commandId = "org.eclipse.ui.tests.Bug66182"; |
| // final Shell windowShell = window.getShell(); |
| // final HandlerSubmission windowSubmission = new HandlerSubmission(null, |
| // windowShell, null, commandId, windowHandler, Priority.MEDIUM); |
| // commandSupport.addHandlerSubmission(windowSubmission); |
| // |
| // // Open a dialog. |
| // final Shell dialogShell = new Shell(windowShell); |
| // final IWorkbenchContextSupport contextSupport = fWorkbench |
| // .getContextSupport(); |
| // contextSupport.registerShell(dialogShell, |
| // IWorkbenchContextSupport.TYPE_WINDOW); |
| // dialogShell.pack(); |
| // dialogShell.open(); |
| // final Display display = dialogShell.getDisplay(); |
| // while (display.readAndDispatch()) |
| // ; |
| // |
| // // Check to see which handler is the right handler. |
| // final ICommand command = commandSupport.getCommandManager().getCommand( |
| // commandId); |
| // assertSame( |
| // "The active shell must be the dialog. If you are activating other shells while this test is running, then this test will fail", |
| // dialogShell, display.getActiveShell()); |
| // assertSame( |
| // "The active workbench window must be the window created in this test. If you are activating other workbench windows, then this test will fail", |
| // windowShell, fWorkbench.getActiveWorkbenchWindow().getShell()); |
| // final Object result = command.execute(new HashMap()); |
| // assertSame( |
| // "The window handler was not chosen when both a dialog was open with no handler, but the active workbench window did have a handler.", |
| // windowResult, result); |
| // |
| // // Close the dialog and let the event loop spin. |
| // commandSupport.removeHandlerSubmission(windowSubmission); |
| // contextSupport.unregisterShell(dialogShell); |
| // dialogShell.close(); |
| // while (display.readAndDispatch()) |
| // ; |
| } |
| |
| /** |
| * Tests that if a dialog is open, that the application will not fall back |
| * to the dialog. The set-up is a workbench window with a handler registered |
| * for the command to test. Then there is a dialog opened, but with no |
| * handler. The test is to see that no handler is active. |
| * |
| * @throws ExecutionException |
| * This should never happen, and indicates a problem with the |
| * test. |
| * @throws NotHandledException |
| * Indicates that no handler was found where one should have |
| * been found. |
| */ |
| public final void testFallbackToWindowBlockedByDialog() |
| throws ExecutionException, NotHandledException { |
| // Open a test window. |
| final IWorkbenchWindow window = openTestWindow(); |
| |
| // Define a handler for some random command identifier. |
| final Object windowResult = new Object(); |
| final IHandler windowHandler = new AbstractHandler() { |
| |
| public Object execute(Map parameterValuesByName) |
| throws ExecutionException { |
| // Do nothing. |
| return windowResult; |
| } |
| }; |
| final IWorkbenchCommandSupport commandSupport = fWorkbench |
| .getCommandSupport(); |
| final String commandId = "org.eclipse.ui.tests.Bug66182"; |
| final Shell windowShell = window.getShell(); |
| final HandlerSubmission windowSubmission = new HandlerSubmission(null, |
| windowShell, null, commandId, windowHandler, Priority.MEDIUM); |
| commandSupport.addHandlerSubmission(windowSubmission); |
| |
| // Open a dialog. |
| final Shell dialogShell = new Shell(windowShell); |
| dialogShell.pack(); |
| dialogShell.open(); |
| final Display display = dialogShell.getDisplay(); |
| while (display.readAndDispatch()) |
| ; |
| |
| // Check to see which handler is the right handler. |
| final ICommand command = commandSupport.getCommandManager().getCommand( |
| commandId); |
| assertSame( |
| "The active shell must be the dialog. If you are activating other shells while this test is running, then this test will fail", |
| dialogShell, display.getActiveShell()); |
| assertSame( |
| "The active workbench window must be the window created in this test. If you are activating other workbench windows, then this test will fail", |
| windowShell, fWorkbench.getActiveWorkbenchWindow().getShell()); |
| assertTrue( |
| "When a dialog is open, it should not fall back to the active workbench window.", |
| !command.isHandled()); |
| |
| // Close the dialog and let the event loop spin. |
| commandSupport.removeHandlerSubmission(windowSubmission); |
| dialogShell.close(); |
| while (display.readAndDispatch()) |
| ; |
| } |
| |
| /** |
| * Tests that if the workbench window is the active shell, that its handlers |
| * will take priority. The scenario has two handlers defined: one for the |
| * workbench window, and one for a dialog that is not open. The workbench |
| * window handler should be the active handler. |
| * |
| * @throws ExecutionException |
| * This should never happen, and indicates a problem with the |
| * test. |
| * @throws NotHandledException |
| * Indicates that no handler was found where one should have |
| * been found. |
| */ |
| public final void testWindow() throws ExecutionException, |
| NotHandledException { |
| // Open a test window. |
| // final IWorkbenchWindow window = openTestWindow(); |
| // |
| // // Define a handler for some random command identifier. |
| // final Object windowResult = new Object(); |
| // final IHandler windowHandler = new AbstractHandler() { |
| // |
| // public Object execute(Map parameterValuesByName) |
| // throws ExecutionException { |
| // // Do nothing. |
| // return windowResult; |
| // } |
| // }; |
| // final IWorkbenchCommandSupport commandSupport = fWorkbench |
| // .getCommandSupport(); |
| // final String commandId = "org.eclipse.ui.tests.Bug66182"; |
| // final Shell windowShell = window.getShell(); |
| // final HandlerSubmission windowSubmission = new HandlerSubmission(null, |
| // windowShell, null, commandId, windowHandler, Priority.MEDIUM); |
| // commandSupport.addHandlerSubmission(windowSubmission); |
| // |
| // // Create a dialog. |
| // final Shell dialogShell = new Shell(windowShell); |
| // |
| // /* |
| // * Define a handler for the same command identifier, but for this |
| // * dialog. |
| // */ |
| // final Object dialogResult = new Object(); |
| // final IHandler dialogHandler = new AbstractHandler() { |
| // |
| // public Object execute(Map parameterValuesByName) |
| // throws ExecutionException { |
| // // Do nothing. |
| // return dialogResult; |
| // } |
| // }; |
| // final HandlerSubmission dialogSubmission = new HandlerSubmission(null, |
| // dialogShell, null, commandId, dialogHandler, Priority.MEDIUM); |
| // commandSupport.addHandlerSubmission(dialogSubmission); |
| // |
| // // Check to see which handler is the right handler. |
| // final ICommand command = commandSupport.getCommandManager().getCommand( |
| // commandId); |
| // assertSame( |
| // "The active shell must be the dialog. If you are activating other shells while this test is running, then this test will fail", |
| // windowShell, fWorkbench.getDisplay().getActiveShell()); |
| // assertSame( |
| // "The active workbench window must be the window created in this test. If you are activating other workbench windows, then this test will fail", |
| // windowShell, fWorkbench.getActiveWorkbenchWindow().getShell()); |
| // final Object result = command.execute(new HashMap()); |
| // assertSame( |
| // "The window handler was not chosen when both a dialog was open with no handler, but the active workbench window did have a handler.", |
| // windowResult, result); |
| // |
| // // Close the dialog and let the event loop spin. |
| // commandSupport.removeHandlerSubmission(windowSubmission); |
| // dialogShell.dispose(); |
| } |
| } |
