1 /*
2 * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.javafx.tk.quantum;
27
28 import com.sun.glass.events.WindowEvent;
29 import com.sun.glass.ui.Application;
30 import com.sun.glass.ui.Screen;
31 import com.sun.glass.ui.Window;
32 import com.sun.glass.ui.Window.Level;
33
34 import com.sun.javafx.tk.FocusCause;
35
36 import java.security.AccessControlContext;
37 import java.security.AccessController;
38 import java.security.PrivilegedAction;
39
40 class GlassWindowEventHandler extends Window.EventHandler implements PrivilegedAction<Void> {
41
42 private final WindowStage stage;
43
44 private Window window;
45 private int type;
46
47 public GlassWindowEventHandler(WindowStage stage) {
48 this.stage = stage;
49 }
50
51 @Override
52 public Void run() {
53 if (stage == null || stage.stageListener == null) {
54 return null;
55 }
56 switch (type) {
57 case WindowEvent.MINIMIZE:
58 stage.stageListener.changedIconified(true);
59 break;
60 case WindowEvent.MAXIMIZE:
61 stage.stageListener.changedMaximized(true);
62 break;
63 case WindowEvent.RESTORE:
64 stage.stageListener.changedIconified(false);
65 stage.stageListener.changedMaximized(false);
66 break;
67 case WindowEvent.MOVE: {
68 float wx = window.getX();
69 float wy = window.getY();
70 Screen screen = window.getScreen();
71 float newx, newy;
72 if (screen != null) {
73 float pScaleX = screen.getPlatformScaleX();
74 float pScaleY = screen.getPlatformScaleY();
75 float sx = screen.getX();
76 float sy = screen.getY();
77 float px = screen.getPlatformX();
78 float py = screen.getPlatformY();
79 newx = sx + (wx - px) / pScaleX;
80 newy = sy + (wy - py) / pScaleY;
81 } else {
82 newx = wx;
83 newy = wy;
84 }
85 stage.stageListener.changedLocation(newx, newy);
86 //We need to sync the new x,y for painting
87 if (!Application.GetApplication().hasWindowManager()) {
88 QuantumToolkit.runWithRenderLock(() -> {
89 GlassScene scene = stage.getScene();
90 if (scene != null) {
91 scene.updateSceneState();
92 }
93 return null;
94 });
95 }
96 break;
97 }
98 case WindowEvent.RESIZE: {
99 float pScaleX = window.getPlatformScaleX();
100 float pScaleY = window.getPlatformScaleY();
101 stage.stageListener.changedSize(window.getWidth() / pScaleX,
102 window.getHeight() / pScaleY);
103 break;
104 }
105 case WindowEvent.RESCALE: {
106 float outScaleX = window.getOutputScaleX();
107 float outScaleY = window.getOutputScaleY();
108 stage.stageListener.changedScale(outScaleX, outScaleY);
109 // We need to sync the new scales for painting
110 QuantumToolkit.runWithRenderLock(() -> {
111 GlassScene scene = stage.getScene();
112 if (scene != null) {
113 scene.entireSceneNeedsRepaint();
114 scene.updateSceneState();
115 }
116 return null;
117 });
118 break;
119 }
120 case WindowEvent.FOCUS_GAINED:
121 WindowStage.addActiveWindow(stage);
122 stage.stageListener.changedFocused(true, FocusCause.ACTIVATED);
123 break;
124 case WindowEvent.FOCUS_LOST:
125 stage.stageListener.changedFocused(false, FocusCause.DEACTIVATED);
126 break;
127 case WindowEvent.FOCUS_UNGRAB:
128 stage.stageListener.focusUngrab();
129 break;
130 case WindowEvent.FOCUS_GAINED_FORWARD:
131 WindowStage.addActiveWindow(stage);
132 stage.stageListener.changedFocused(true, FocusCause.TRAVERSED_FORWARD);
133 break;
134 case WindowEvent.FOCUS_GAINED_BACKWARD:
135 WindowStage.addActiveWindow(stage);
136 stage.stageListener.changedFocused(true, FocusCause.TRAVERSED_BACKWARD);
137 break;
138 case WindowEvent.FOCUS_DISABLED:
139 stage.handleFocusDisabled();
140 break;
141 case WindowEvent.DESTROY:
142 stage.setPlatformWindowClosed();
143 stage.stageListener.closed();
144 break;
145 case WindowEvent.CLOSE:
146 stage.stageListener.closing();
147 break;
148 default:
149 if (QuantumToolkit.verbose) {
150 System.err.println("GlassWindowEventHandler: unknown type: " + type);
151 }
152 break;
153 }
154 return null;
155 }
156
157 @Override
158 public void handleLevelEvent(int level) {
159 QuantumToolkit.runWithoutRenderLock(() -> {
160 AccessControlContext acc = stage.getAccessControlContext();
161 return AccessController.doPrivileged((PrivilegedAction<Void>)() -> {
162 stage.stageListener.changedAlwaysOnTop(level != Level.NORMAL);
163 return (Void)null;
164 } , acc);
165 });
166 }
167
168 @Override
169 public void handleWindowEvent(final Window window, final long time, final int type) {
170 this.window = window;
171 this.type = type;
172
173 QuantumToolkit.runWithoutRenderLock(() -> {
174 AccessControlContext acc = stage.getAccessControlContext();
175 return AccessController.doPrivileged(this, acc);
176 });
177 }
178
179 @Override
180 public void handleScreenChangedEvent(Window window, long time, Screen oldScreen, Screen newScreen) {
181 GlassScene scene = stage.getScene();
182 if (scene != null) {
183 QuantumToolkit.runWithRenderLock(() -> {
184 scene.entireSceneNeedsRepaint();
185 scene.updateSceneState();
186 return null;
187 });
188 }
189
190 QuantumToolkit.runWithoutRenderLock(() -> {
191 AccessControlContext acc = stage.getAccessControlContext();
192 return AccessController.doPrivileged((PrivilegedAction<Void>)() -> {
193 stage.stageListener.changedScreen(oldScreen, newScreen);
194 return (Void)null;
195 } , acc);
196 });
197 }
198 }