| /* |
| * Copyright (c) 2008, 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 |
| @bug 4452384 |
| @summary Tests that non-focusable windows doesn't generate any focus events when accessed. |
| @author Denis.Mikhalkin: area=awt.focus |
| @run main NoEventsTest |
| */ |
| |
| import java.awt.*; |
| import java.awt.event.*; |
| import java.util.*; |
| |
| public class NoEventsTest extends Frame { |
| public static final int DEF_WIDTH = 400, |
| DEF_HEIGHT = 300, |
| DEF_TOP = 1, |
| DEF_LEFT = 100, |
| DEF_ROW = 0, |
| DEF_COL = 0; |
| static boolean automatic = true; |
| static Window[] windows; |
| static Frame main_frame, jumpingFrame; |
| static Button focus_button; |
| static Robot robot; |
| static void pause(int timeout) { |
| Toolkit.getDefaultToolkit().sync(); |
| robot.waitForIdle(); |
| robot.delay(100); |
| } |
| static GlobalListener listener; |
| public static void main(String[] args) { |
| |
| listener = new GlobalListener(); |
| Toolkit.getDefaultToolkit().addAWTEventListener(listener, |
| AWTEvent.FOCUS_EVENT_MASK | |
| AWTEvent.WINDOW_EVENT_MASK); |
| try{ |
| robot = new Robot(); |
| } catch(Exception e) {} |
| // Create several pairs - focusable Frame with focusable component(button) and non-focusable: |
| // window, resizable frame, non-resizable frame, dialog, non-resiable dialog |
| main_frame = new Frame("focusable frame"); |
| focus_button = new Button("button to focus"); |
| main_frame.add(focus_button); |
| main_frame.pack(); |
| main_frame.setVisible(true); |
| main_frame.setLocation(10, 600); |
| main_frame.addWindowListener(new WindowAdapter() { |
| public void windowClosing(WindowEvent e) { |
| listener.report(); |
| System.exit(0); |
| } |
| }); |
| |
| jumpingFrame = new Frame("Jumping frame"); |
| jumpingFrame.setBounds(DEF_LEFT, DEF_TOP, DEF_WIDTH, DEF_HEIGHT); |
| |
| windows = new Window[7]; |
| windows[0] = new TestWindow(0, 0, false, main_frame); |
| //windows[1] = new TestWindow(2, 1, true, main_frame); |
| windows[2] = new NoEventsTest(1, 0, false, true); |
| windows[3] = new NoEventsTest(2, 0, false, false); |
| //windows[4] = new Test(3, 0, true, true); |
| windows[5] = new TestDialog(0, 1, false, true, main_frame); |
| windows[6] = new TestDialog(1, 1, false, false, main_frame); |
| if (!automatic) { |
| int windowInd; |
| for (windowInd = 0; windowInd < windows.length; windowInd++) { |
| if (windows[windowInd] != null) { |
| windows[windowInd].setVisible(true); |
| } |
| } |
| } |
| // Run the test |
| // 1. Click on all controls, check for no focus events for non-focusable, right focus events for focusable |
| // 2. Perform some action with control, check if it works |
| if (automatic) { |
| int windowInd; |
| for (windowInd = 0; windowInd < windows.length; windowInd++) { |
| if (windows[windowInd] != null) { |
| windows[windowInd].setVisible(true); |
| focus_button.requestFocus(); |
| pause(1000); |
| |
| // Verify that click on non-focusable window causes no focus lost on active window |
| performFocusClick(windows[windowInd]); |
| focus_button.requestFocus(); |
| pause(500); |
| performActionClick(windows[windowInd]); |
| |
| // Verify that toFront, toBack doesn't cause non-focusable window to become active |
| jumpingFrame.setVisible(true); |
| pause(1000); |
| jumpingFrame.toBack(); |
| pause(500); |
| jumpingFrame.toFront(); |
| pause(500); |
| windows[windowInd].toBack(); |
| pause(500); |
| windows[windowInd].toFront(); |
| pause(500); |
| |
| // Verify that iconifiyng/deiconfiying and |
| // zooming/unzooming doesn't cause non-focusable |
| // window to become active |
| if (windows[windowInd] instanceof Frame) { |
| Frame toTest = (Frame)windows[windowInd]; |
| // Deiconification currently doesn't work! |
| // toTest.setExtendedState(Frame.ICONIFIED); |
| // pause(500); |
| // toTest.setExtendedState(Frame.NORMAL); |
| pause(500); |
| toTest.setExtendedState(Frame.MAXIMIZED_BOTH); |
| pause(500); |
| toTest.setExtendedState(Frame.NORMAL); |
| } |
| |
| windows[windowInd].dispose(); |
| jumpingFrame.dispose(); |
| } |
| } |
| pause(1000); |
| System.err.println("Test finished."); |
| if (!listener.report()) { |
| throw new RuntimeException("Test Failed. See error stream output for details"); |
| } |
| } |
| } |
| static void performFocusClick(Window parent) { |
| if (parent == null) { |
| return; |
| } |
| for (int compInd = 0; compInd < parent.getComponentCount(); compInd++) { |
| Component child = parent.getComponent(compInd); |
| if (child instanceof TestPanel) { |
| TestPanel pan = (TestPanel)child; |
| pan.performFocusClicks(robot); |
| pause(100); |
| } |
| } |
| } |
| static void performActionClick(Window parent) { |
| if (parent == null) { |
| return; |
| } |
| for (int compInd = 0; compInd < parent.getComponentCount(); compInd++) { |
| Component child = parent.getComponent(compInd); |
| if (child instanceof TestPanel) { |
| TestPanel pan = (TestPanel)child; |
| pan.performActionClicks(robot); |
| pause(100); |
| } |
| } |
| } |
| public NoEventsTest(int row, int col, boolean focusable, boolean resizable) { |
| super("Frame" + row + "" + col); |
| TestPanel panel = new TestPanel(row, col); |
| if (NoEventsTest.automatic) { |
| row = NoEventsTest.DEF_ROW; |
| col = NoEventsTest.DEF_COL; |
| } |
| setName(getTitle()); |
| add("Center", panel); |
| Label l = new Label(getClass().getSuperclass().getName() + ", " + (focusable?"focusable":"non-focusable") + |
| ", " + (resizable?"resizable":"non-resizable")); |
| l.setBackground(Color.green); |
| add("North", l); |
| setBounds(NoEventsTest.DEF_LEFT + DEF_WIDTH*col, DEF_TOP + DEF_HEIGHT*row, DEF_WIDTH, DEF_HEIGHT); |
| if (!focusable) { |
| setFocusableWindowState(false); |
| } |
| if (!resizable) { |
| setResizable(false); |
| } |
| // setVisible(true); |
| } |
| } |
| class TestWindow extends Window { |
| public TestWindow(int row, int col, boolean focusable, Frame owner) { |
| super(owner); |
| setName("Window" + row + "" + col); |
| TestPanel panel = new TestPanel(row, col); |
| if (NoEventsTest.automatic) { |
| row = NoEventsTest.DEF_ROW; |
| col = NoEventsTest.DEF_COL; |
| } |
| |
| add("Center", panel); |
| Label l = new Label(getClass().getSuperclass().getName() + ", " + (focusable?"focusable":"non-focusable") + |
| ", " + (false?"resizable":"non-resizable")); |
| l.setBackground(Color.green); |
| add("North", l); |
| |
| setBounds(NoEventsTest.DEF_LEFT + NoEventsTest.DEF_WIDTH*col, NoEventsTest.DEF_TOP + NoEventsTest.DEF_HEIGHT*row, NoEventsTest.DEF_WIDTH, NoEventsTest.DEF_HEIGHT); |
| if (!focusable) { |
| setFocusableWindowState(false); |
| } |
| // setVisible(true); |
| } |
| } |
| class TestDialog extends Dialog { |
| public TestDialog(int row, int col, boolean focusable, boolean resizable, Frame owner) { |
| super(owner); |
| setName("Dialog" + row + "" + col); |
| TestPanel panel = new TestPanel(row, col); |
| if (NoEventsTest.automatic) { |
| row = NoEventsTest.DEF_ROW; |
| col = NoEventsTest.DEF_COL; |
| } |
| |
| add("Center", panel); |
| Label l = new Label(getClass().getSuperclass().getName() + ", " + (focusable?"focusable":"non-focusable") + |
| ", " + (resizable?"resizable":"non-resizable")); |
| l.setBackground(Color.green); |
| add("North", l); |
| |
| setBounds(NoEventsTest.DEF_LEFT + NoEventsTest.DEF_WIDTH*col, NoEventsTest.DEF_TOP + NoEventsTest.DEF_HEIGHT*row, NoEventsTest.DEF_WIDTH, NoEventsTest.DEF_HEIGHT); |
| if (!focusable) { |
| setFocusableWindowState(false); |
| } |
| if (!resizable) { |
| setResizable(false); |
| } |
| // setVisible(true); |
| } |
| } |
| |
| class TestPanel extends Panel { |
| |
| void clickComponent(Component comp, Robot robot) { |
| if (comp instanceof Choice) { |
| return; |
| } |
| Point compLoc = comp.getLocationOnScreen(); |
| Dimension size = comp.getSize(); |
| robot.mouseMove(compLoc.x + size.width/2, compLoc.y + size.height/2); |
| robot.mousePress(InputEvent.BUTTON1_MASK); |
| robot.mouseRelease(InputEvent.BUTTON1_MASK); |
| } |
| void performFocusClicks(Robot robot) { |
| for (int childInd = 0; childInd < getComponentCount(); childInd++) { |
| performFocusClick(getComponent(childInd), robot); |
| } |
| } |
| void performFocusClick(Component comp, Robot robot) { |
| clickComponent(comp, robot); |
| } |
| |
| void performActionClicks(Robot robot) { |
| for (int childInd = 0; childInd < getComponentCount(); childInd++) { |
| performActionClick(getComponent(childInd), robot); |
| } |
| } |
| void performActionClick(Component comp, Robot robot) { |
| } |
| |
| public TestPanel(int row, int col) { |
| setLayout(new FlowLayout()); |
| Button b; |
| add(b = new Button("press"+ row + "" + col)); |
| b.setName(b.getLabel()); |
| // b.addMouseListener(new MouseAdapter() { |
| // public void mousePressed(MouseEvent e) { |
| // System.err.println(e); |
| // } |
| // }); |
| TextField t; |
| add(t = new TextField("text" + row + "" + col)); |
| t.setName(t.getText()); |
| |
| java.awt.List list = new java.awt.List(); |
| add(list); |
| list.setName("list"); |
| list.add("one"); |
| list.add("two"); |
| list.add("three"); |
| list.setMultipleMode(true); |
| list.setName("list" + row + "" + col); |
| |
| Checkbox check = new Checkbox("checker"); |
| add(check); |
| check.setName("check" + row + "" + col); |
| |
| Choice choice = new Choice(); |
| choice.add("one"); |
| choice.add("two"); |
| choice.add("three"); |
| add(choice); |
| choice.setName("choice" + row + "" + col); |
| |
| Canvas can = new Canvas() { |
| public Dimension getPreferredSize() { |
| return new Dimension(10, 10); |
| } |
| }; |
| can.setBackground(Color.blue); |
| add(can); |
| can.setName("canvas" + row + "" + col); |
| |
| TextArea ta = new TextArea("text\ntttt\naaaa\nwwwww\nqqqqqq\neeeeee\nrrrrrr\nyyyyyy\nuuuuu", 3, 5); |
| add(ta); |
| ta.setName("textarea" + row + "" + col); |
| |
| Scrollbar bar = new Scrollbar(Scrollbar.HORIZONTAL); |
| add(bar); |
| bar.setName("scrollbar" + row + "" + col); |
| |
| CheckboxGroup group = new CheckboxGroup(); |
| Checkbox ch1 = new Checkbox("one", group, true); |
| Checkbox ch2 = new Checkbox("two", group, false); |
| add(ch1); |
| add(ch2); |
| ch1.setName("checkbox1 " + row + "" + col); |
| ch2.setName("checkbox2 " + row + "" + col); |
| |
| |
| ScrollPane pane = new ScrollPane(ScrollPane.SCROLLBARS_ALWAYS); |
| add(pane); |
| Button bigButton = new Button("abc") { |
| public Dimension getPreferredSize() { |
| return new Dimension(100, 100); |
| } |
| }; |
| pane.add(bigButton); |
| bigButton.setName("bigbutton" + row + "" + col); |
| } |
| } |
| |
| class GlobalListener implements AWTEventListener { |
| java.util.List errors = new java.util.LinkedList(); |
| public boolean report() { |
| if (errors.size() != 0) { |
| System.err.println("Test FAILED"); |
| } else { |
| System.err.println("Test PASSED"); |
| return true; |
| } |
| ListIterator iter = errors.listIterator(); |
| while (iter.hasNext()) { |
| System.err.println(iter.next()); |
| } |
| return false; |
| } |
| public GlobalListener() { |
| } |
| Window getWindowParent(Component comp) { |
| while (comp != null && !(comp instanceof Window)) { |
| comp = comp.getParent(); |
| } |
| return (Window)comp; |
| } |
| void reportError(AWTEvent e, String message) { |
| String error = "ERROR: " + message + " : " + e; |
| errors.add(error); |
| System.err.println(error); |
| } |
| public void eventDispatched(AWTEvent e) { |
| Component comp = (Component)e.getSource(); |
| Window parent = getWindowParent(comp); |
| if (!(e instanceof WindowEvent || e instanceof FocusEvent)) { |
| System.err.println("Strange event " + e); |
| } |
| |
| // Skip WINDOW_OPENED |
| if (e.getID() == WindowEvent.WINDOW_CLOSING) { |
| System.err.println(e); |
| } |
| switch (e.getID()) { |
| case WindowEvent.WINDOW_OPENED: |
| case WindowEvent.WINDOW_CLOSING: |
| case WindowEvent.WINDOW_CLOSED: |
| case WindowEvent.WINDOW_ICONIFIED: |
| case WindowEvent.WINDOW_DEICONIFIED: |
| case WindowEvent.WINDOW_STATE_CHANGED: |
| return; |
| case WindowEvent.WINDOW_LOST_FOCUS: { |
| WindowEvent we = (WindowEvent)e; |
| if (we.getOppositeWindow() != null && !we.getOppositeWindow().getFocusableWindowState()) { |
| reportError(e, "frame lost focus because of non-focusable window"); |
| } |
| break; |
| } |
| } |
| // Check that Window owner is focusable |
| if (!parent.getFocusableWindowState()) { |
| reportError(e, "focus event for component in non-focusable window " + parent.getName()); |
| } |
| if (!comp.isFocusable()) { |
| reportError(e, "focus event for non-focusable component"); |
| } |
| // if (e instanceof WindowEvent || e instanceof FocusEvent) { |
| // // System.err.println(e); |
| // } |
| } |
| } |
