1/*
2 * Copyright 2012 Red Hat, Inc.  All Rights Reserved.
3 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25
26/*
27  @test
28  @bug      7043963
29  @summary  Tests  that the screen location of windows is
30            updated properly after a maximize.
31  @requires (os.family == "linux" | os.family == "solaris")
32  @modules java.desktop/sun.awt.X11
33  @author   Denis Lila
34  @library  ../../regtesthelpers
35  @build    Util
36  @run      main MutterMaximizeTest
37*/
38
39import java.awt.AWTException;
40import java.awt.Dimension;
41import java.awt.Frame;
42import java.awt.Point;
43import java.awt.Robot;
44import java.awt.Window;
45import java.awt.event.InputEvent;
46import java.awt.event.WindowAdapter;
47import java.awt.event.WindowEvent;
48
49import test.java.awt.regtesthelpers.Util;
50
51@SuppressWarnings("serial")
52public class MutterMaximizeTest extends Frame {
53
54    public static void main(String[] args) throws InterruptedException {
55        if (Util.getWMID() != Util.MUTTER_WM) {
56            System.out.println("This test is only useful on Mutter");
57            return;
58        }
59        MutterMaximizeTest frame = new MutterMaximizeTest();
60        frame.addWindowListener(Util.getClosingWindowAdapter());
61
62        //Display the window.
63        frame.setSize(500, 500);
64        Util.showWindowWait(frame);
65        runRobotTest(frame);
66    }
67
68    private static void runRobotTest(Frame frame) {
69        try {
70            Thread robotThread = startRegTest(frame);
71            robotThread.start();
72            waitForThread(robotThread);
73        } finally {
74            frame.dispose();
75        }
76    }
77
78    private static void waitForThread(Thread t) {
79        while (t.isAlive()) {
80            try {
81                t.join();
82            } catch (InterruptedException e) {
83            }
84        }
85    }
86
87    private static void sleepFor(long millis) {
88        long dT = 0;
89        long start = System.nanoTime();
90        while (dT < millis) {
91            try {
92                long toSleep = millis - dT/1000000;
93                if (toSleep > 0) {
94                    Thread.sleep(toSleep);
95                }
96                // if this ends without an interrupted exception,
97                // that's good enough.
98                break;
99            } catch (InterruptedException e) {
100                long now = System.nanoTime();
101                dT = now - start;
102            }
103        }
104    }
105
106    private static void rmove(Robot robot, Point p) {
107        robot.mouseMove(p.x, p.y);
108    }
109    private static void rdown(Robot robot) {
110        robot.mousePress(InputEvent.BUTTON1_MASK);
111        robot.delay(50);
112    }
113    private static void rup(Robot robot) {
114        robot.mouseRelease(InputEvent.BUTTON1_MASK);
115        robot.delay(50);
116    }
117
118    public static void click(Robot robot) {
119        rdown(robot);
120        rup(robot);
121    }
122
123    public static void doubleClick(Robot robot) {
124        click(robot);
125        click(robot);
126    }
127
128    private static void dragWindow(Window w, int dx, int dy, Robot robot) {
129        Point p = Util.getTitlePoint(w);
130        rmove(robot, p);
131        rdown(robot);
132        p.translate(dx, dy);
133        rmove(robot, p);
134        rup(robot);
135    }
136
137    // f must be visible
138    private static Thread startRegTest(final Frame f) {
139        Thread robot = new Thread(new Runnable() {
140            public void run() {
141                Robot r = Util.createRobot();
142                dragWindow(f, 100, 100, r);
143                // wait for the location to be set.
144                sleepFor(2000);
145
146                final Point l2 = f.getLocationOnScreen();
147
148                // double click should maximize the frame
149                doubleClick(r);
150
151                // wait for location again.
152                sleepFor(2000);
153                final Point l3 = f.getLocationOnScreen();
154                if (l3.equals(l2)) {
155                    throw new RuntimeException("Bad location after maximize. Window location has not moved");
156                }
157            }
158        });
159        return robot;
160    }
161}
162
163