/* * Copyright (c) 2007, 2018, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ /* @test @key headful @bug 6187066 @summary Tests the Window.autoRequestFocus property for the Window.setVisible() method. @author anton.tarasov: area=awt.focus @library ../../regtesthelpers @build Util @run main AutoRequestFocusSetVisibleTest */ import java.awt.*; import java.awt.event.*; import java.applet.Applet; import java.util.concurrent.atomic.AtomicBoolean; import java.lang.reflect.InvocationTargetException; import test.java.awt.regtesthelpers.Util; public class AutoRequestFocusSetVisibleTest extends Applet { static Frame focusedFrame; static Button focusOwner; static Frame frame; static Button frameButton; static Frame frame2; static Button frameButton2; static Window window; static Button winButton; static Window ownedWindow; static Button ownWinButton; static Dialog ownedDialog; static Button ownDlgButton; static Dialog dialog; static Button dlgButton; static String toolkitClassName; static Robot robot = Util.createRobot(); public static void main(String[] args) { AutoRequestFocusSetVisibleTest app = new AutoRequestFocusSetVisibleTest(); app.init(); app.start(); } public void init() { // Create instructions for the user here, as well as set up // the environment -- set the layout manager, add buttons, // etc. this.setLayout (new BorderLayout ()); toolkitClassName = Toolkit.getDefaultToolkit().getClass().getName(); } void recreateGUI() { if (focusedFrame != null) { focusedFrame.dispose(); frame.dispose(); frame2.dispose(); window.dispose(); ownedWindow.dispose(); ownedDialog.dispose(); dialog.dispose(); } focusedFrame = new Frame("Base Frame"); focusOwner = new Button("button"); frame = new Frame("Test Frame"); frameButton = new Button("button"); frame2 = new Frame("Test Frame"); frameButton2 = new Button("button"); window = new Window(focusedFrame); winButton = new Button("button"); ownedWindow = new Window(frame) { /* * When 'frame' is shown along with the 'ownedWindow' * (i.e. showWithParent==true) then it can appear * that the 'ownedWindow' is shown too early and * it can't be focused due to its owner can't be * yet activated. So, to avoid this race, we pospone * a little the showing of the 'ownedWindow'. */ public void show() { robot.delay(100); super.show(); } }; ownWinButton = new Button("button"); ownedDialog = new Dialog(frame2); ownDlgButton = new Button("button"); dialog = new Dialog(focusedFrame, "Test Dialog"); dlgButton = new Button("button"); focusedFrame.add(focusOwner); focusedFrame.setBounds(100, 100, 300, 300); frame.setBounds(140, 140, 220, 220); frame.add(frameButton); frame2.setBounds(140, 140, 220, 220); frame2.add(frameButton2); window.setBounds(140, 140, 220, 220); window.add(winButton); ownedWindow.setBounds(180, 180, 140, 140); ownedWindow.add(ownWinButton); ownedDialog.setBounds(180, 180, 140, 140); ownedDialog.add(ownDlgButton); dialog.setBounds(140, 140, 220, 220); dialog.add(dlgButton); } public void start() { /////////////////////////////////////////////////////// // 1. Show Frame with owned modal Dialog without delay. // Check that the Dialog takes focus. /////////////////////////////////////////////////////// recreateGUI(); System.out.println("Stage 1 in progress..."); dialog.setModal(true); dialog.setAutoRequestFocus(false); setVisible(focusedFrame, true); TestHelper.invokeLaterAndWait(new Runnable() { public void run() { dialog.setVisible(true); } }, robot); if (focusOwner.hasFocus()) { throw new TestFailedException("the modal dialog must gain focus but it didn't!"); } setVisible(dialog, false); ////////////////////////////////////////////////// // 2. Show Frame, activate, auto hide, auto show. // Check that the Frame takes focus. ////////////////////////////////////////////////// recreateGUI(); System.out.println("Stage 2 in progress..."); setVisible(focusedFrame, false); focusedFrame.setAutoRequestFocus(false); setVisible(focusedFrame, true); Util.clickOnTitle(focusedFrame, robot); Util.waitForIdle(robot); if (!focusedFrame.isFocused()) { throw new Error("Test error: the frame couldn't be focused."); } focusedFrame.setExtendedState(Frame.ICONIFIED); Util.waitForIdle(robot); focusedFrame.setExtendedState(Frame.NORMAL); Util.waitForIdle(robot); if (!focusedFrame.isFocused()) { throw new TestFailedException("the restored frame must gain focus but it didn't!"); } //////////////////////// // 3.1 Show Frame normal. //////////////////////// recreateGUI(); test("Stage 3.1 in progress...", frame, frameButton); // 3.2. Show Frame maximized both. ///////////////////////////////// if (!Toolkit.getDefaultToolkit().isFrameStateSupported(Frame.MAXIMIZED_BOTH)) { System.out.println("Stage 3.2: Frame.MAXIMIZED_BOTH not supported. Skipping."); } else { frame.setExtendedState(Frame.MAXIMIZED_BOTH); test("Stage 3.2 in progress...", frame, frameButton); } // 3.3. Show Frame maximized vertically. /////////////////////////////////////// if (!Toolkit.getDefaultToolkit().isFrameStateSupported(Frame.MAXIMIZED_VERT)) { System.out.println("Stage 3.3: Frame.MAXIMIZED_VERT not supported. Skipping."); } else { frame.setExtendedState(Frame.MAXIMIZED_VERT); test("Stage 3.3 in progress...", frame, frameButton); } // 3.4. Show Frame maximized horizontally. ///////////////////////////////////////// if (!Toolkit.getDefaultToolkit().isFrameStateSupported(Frame.MAXIMIZED_HORIZ)) { System.out.println("Stage 3.4: Frame.MAXIMIZED_HORIZ not supported. Skipping."); } else { frame.setExtendedState(Frame.MAXIMIZED_HORIZ); test("Stage 3.4 in progress...", frame, frameButton); } // 3.5. Show Frame iconified. //////////////////////////// if (!Toolkit.getDefaultToolkit().isFrameStateSupported(Frame.ICONIFIED)) { System.out.println("Stage 3.5: Frame.ICONIFIED not supported. Skipping."); } else { frame.setExtendedState(Frame.ICONIFIED); test("Stage 3.5 in progress...", frame, frameButton); } /////////////////// // 4.1 Show Window. /////////////////// recreateGUI(); test("Stage 4.1 in progress...", window, winButton); // 4.2 Show Dialog. ////////////////// test("Stage 4.2 in progress...", dialog, dlgButton); // 4.3. Show modal Dialog. ///////////////////////// dialog.setModal(true); test("Stage 4.3 in progress...", dialog, dlgButton, true); /////////////////////////////////// // 5.1 Show Frame with owned Window. /////////////////////////////////// // On Windows, an owned Window will not be focused on its showing // if the owner is not currently active. if ("sun.awt.windows.WToolkit".equals(toolkitClassName)) { System.out.println("Stage 5.1 - Skiping."); } else { setVisible(ownedWindow, true); setVisible(frame, false); // 'ownedWindow' will be shown along with the owner. test("Stage 5.1 in progress...", frame, ownedWindow, ownWinButton, true); } // 5.2 Show Frame with owned Dialog. /////////////////////////////////// setVisible(ownedDialog, true); setVisible(frame2, false); // 'ownedDialog' will be shown along with the owner. test("Stage 5.2 in progress...", frame2, ownedDialog, ownDlgButton, true); /////////////////////////////////// // 6. Show unblocking modal Dialog. /////////////////////////////////// if ("sun.awt.motif.MToolkit".equals(toolkitClassName)) { System.out.println("Stage 6 - Skiping."); } else { System.out.println("Stage 6 in progress..."); // --- // Testing the bug of activating invisible modal Dialog (awt_Window::SetAndActivateModalBlocker). // Having some window not excluded from modality, so that it would be blocked. Frame f = new Frame("Aux. Frame"); f.setSize(100, 100); setVisible(f, true); // --- setVisible(focusedFrame, true); if (!focusOwner.hasFocus()) { Util.clickOnComp(focusOwner, robot); Util.waitForIdle(robot); if (!focusOwner.hasFocus()) { throw new Error("Test error: the frame couldn't be focused."); } } dialog.setModal(true); dialog.setAutoRequestFocus(false); focusedFrame.setModalExclusionType(Dialog.ModalExclusionType.APPLICATION_EXCLUDE); TestHelper.invokeLaterAndWait(new Runnable() { public void run() { dialog.setVisible(true); } }, robot); if (dialog.isFocused()) { throw new TestFailedException("the unblocking dialog shouldn't gain focus but it did!"); } setVisible(dialog, false); } System.out.println("Test passed."); } /* * @param msg notifies test stage number * @param showWindow a window to show/test (if ownedWindow == null) * @param ownedWindow an owned window to show/test, or null if showWindow should be tested * @param clickButton a button of the window (owner or owned) expected to be on the top of stack order * @param shouldFocusChange true the test window should gain focus */ void test(String msg, final Window showWindow, Window ownedWindow, final Button clickButton, boolean shouldFocusChange) { Window testWindow = (ownedWindow == null ? showWindow : ownedWindow); System.out.println(msg); if (showWindow.isVisible()) { showWindow.dispose(); Util.waitForIdle(robot); } if (!focusedFrame.isVisible()) { setVisible(focusedFrame, true); } if (!focusOwner.hasFocus()) { Util.clickOnComp(focusOwner, robot); Util.waitForIdle(robot); if (!focusOwner.hasFocus()) { throw new Error("Test error: the frame couldn't be focused."); } } ////////////////////////////////////////// // Test focus change on showing the window ////////////////////////////////////////// final Runnable showAction = new Runnable() { public void run() { showWindow.setAutoRequestFocus(false); showWindow.setVisible(true); } }; final Runnable trackerAction = new Runnable() { public void run() { if (showWindow instanceof Dialog && ((Dialog)showWindow).isModal()) { TestHelper.invokeLaterAndWait(showAction, robot); } else { showAction.run(); } } }; if (shouldFocusChange) { trackerAction.run(); Util.waitForIdle(robot); if (!testWindow.isFocused()) { throw new TestFailedException("the window must gain focus but it didn't!"); } } else if (TestHelper.trackFocusChangeFor(trackerAction, robot)) { throw new TestFailedException("the window shouldn't gain focus but it did!"); } //////////////////////////////////////////// // Test that the window was shown on the top. // Test that it can be focused. //////////////////////////////////////////// if (!(testWindow instanceof Frame) || ((Frame)testWindow).getExtendedState() != Frame.ICONIFIED) { boolean performed = Util.trackActionPerformed(clickButton, new Runnable() { public void run() { /* * If 'showWindow' is not on the top then * 'focusOwner' button completely overlaps 'clickButton' * and we won't catch the action. */ Util.clickOnComp(clickButton, robot); } }, 1000, false); if (!performed) { // In case of loosing ACTION_PERFORMED, try once more. System.out.println("(ACTION_EVENT was not generated. One more attemp.)"); performed = Util.trackActionPerformed(clickButton, new Runnable() { public void run() { Util.clickOnComp(clickButton, robot); } }, 1000, false); if (!performed) { throw new TestFailedException("the window shown is not on the top!"); } } } recreateGUI(); } void test(String msg, final Window showWindow, Button clickButton) { test(msg, showWindow, null, clickButton, false); } void test(String msg, final Window showWindow, Button clickButton, boolean shouldFocusChange) { test(msg, showWindow, null, clickButton, shouldFocusChange); } void test(String msg, final Window showWindow, Window ownedWindow, Button clickButton) { test(msg, showWindow, ownedWindow, clickButton, false); } private static void setVisible(Window w, boolean b) { w.setVisible(b); try { Util.waitForIdle(robot); } catch (RuntimeException rte) { // InfiniteLoop rte.printStackTrace(); } robot.delay(200); } } class TestFailedException extends RuntimeException { TestFailedException(String msg) { super("Test failed: " + msg); } }