author | prr |
Sat, 19 Sep 2015 15:45:59 -0700 | |
changeset 32865 | f9cb6e427f9e |
parent 25859 | 3317bb8137f4 |
child 34395 | 2ac7e99f7f4a |
permissions | -rw-r--r-- |
2 | 1 |
/* |
22584
eed64ee05369
8032733: Fix cast lint warnings in client libraries
darcy
parents:
18178
diff
changeset
|
2 |
* Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved. |
2 | 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 |
|
5506 | 7 |
* published by the Free Software Foundation. Oracle designates this |
2 | 8 |
* particular file as subject to the "Classpath" exception as provided |
5506 | 9 |
* by Oracle in the LICENSE file that accompanied this code. |
2 | 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 |
* |
|
5506 | 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. |
|
2 | 24 |
*/ |
25 |
||
26 |
package sun.awt.X11; |
|
27 |
||
28 |
import java.awt.*; |
|
29 |
import sun.awt.*; |
|
30 |
import java.util.*; |
|
3938
ef327bd847c0
6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents:
3288
diff
changeset
|
31 |
import sun.util.logging.PlatformLogger; |
2 | 32 |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
33 |
public class XBaseWindow { |
3938
ef327bd847c0
6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents:
3288
diff
changeset
|
34 |
private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XBaseWindow"); |
ef327bd847c0
6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents:
3288
diff
changeset
|
35 |
private static final PlatformLogger insLog = PlatformLogger.getLogger("sun.awt.X11.insets.XBaseWindow"); |
ef327bd847c0
6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents:
3288
diff
changeset
|
36 |
private static final PlatformLogger eventLog = PlatformLogger.getLogger("sun.awt.X11.event.XBaseWindow"); |
ef327bd847c0
6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents:
3288
diff
changeset
|
37 |
private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.awt.X11.focus.XBaseWindow"); |
ef327bd847c0
6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents:
3288
diff
changeset
|
38 |
private static final PlatformLogger grabLog = PlatformLogger.getLogger("sun.awt.X11.grab.XBaseWindow"); |
2 | 39 |
|
40 |
public static final String |
|
41 |
PARENT_WINDOW = "parent window", // parent window, Long |
|
42 |
BOUNDS = "bounds", // bounds of the window, Rectangle |
|
43 |
OVERRIDE_REDIRECT = "overrideRedirect", // override_redirect setting, Boolean |
|
44 |
EVENT_MASK = "event mask", // event mask, Integer |
|
45 |
VALUE_MASK = "value mask", // value mask, Long |
|
46 |
BORDER_PIXEL = "border pixel", // border pixel value, Integer |
|
47 |
COLORMAP = "color map", // color map, Long |
|
48 |
DEPTH = "visual depth", // depth, Integer |
|
49 |
VISUAL_CLASS = "visual class", // visual class, Integer |
|
50 |
VISUAL = "visual", // visual, Long |
|
51 |
EMBEDDED = "embedded", // is embedded?, Boolean |
|
52 |
DELAYED = "delayed", // is creation delayed?, Boolean |
|
53 |
PARENT = "parent", // parent peer |
|
54 |
BACKGROUND_PIXMAP = "pixmap", // background pixmap |
|
55 |
VISIBLE = "visible", // whether it is visible by default |
|
56 |
SAVE_UNDER = "save under", // save content under this window |
|
57 |
BACKING_STORE = "backing store", // enables double buffering |
|
58 |
BIT_GRAVITY = "bit gravity"; // copy old content on geometry change |
|
59 |
private XCreateWindowParams delayedParams; |
|
60 |
||
61 |
Set<Long> children = new HashSet<Long>(); |
|
62 |
long window; |
|
63 |
boolean visible; |
|
64 |
boolean mapped; |
|
65 |
boolean embedded; |
|
66 |
Rectangle maxBounds; |
|
67 |
volatile XBaseWindow parentWindow; |
|
68 |
||
69 |
private boolean disposed; |
|
70 |
||
71 |
private long screen; |
|
72 |
private XSizeHints hints; |
|
73 |
private XWMHints wmHints; |
|
74 |
||
32865
f9cb6e427f9e
8136783: Run blessed-modifier-order script on java.desktop
prr
parents:
25859
diff
changeset
|
75 |
static final int MIN_SIZE = 1; |
f9cb6e427f9e
8136783: Run blessed-modifier-order script on java.desktop
prr
parents:
25859
diff
changeset
|
76 |
static final int DEF_LOCATION = 1; |
2 | 77 |
|
78 |
private static XAtom wm_client_leader; |
|
79 |
||
80 |
static enum InitialiseState { |
|
81 |
INITIALISING, |
|
82 |
NOT_INITIALISED, |
|
83 |
INITIALISED, |
|
84 |
FAILED_INITIALISATION |
|
85 |
}; |
|
86 |
||
87 |
private InitialiseState initialising; |
|
88 |
||
89 |
int x; |
|
90 |
int y; |
|
91 |
int width; |
|
92 |
int height; |
|
93 |
||
94 |
void awtLock() { |
|
95 |
XToolkit.awtLock(); |
|
96 |
} |
|
97 |
||
98 |
void awtUnlock() { |
|
99 |
XToolkit.awtUnlock(); |
|
100 |
} |
|
101 |
||
102 |
void awtLockNotifyAll() { |
|
103 |
XToolkit.awtLockNotifyAll(); |
|
104 |
} |
|
105 |
||
106 |
void awtLockWait() throws InterruptedException { |
|
107 |
XToolkit.awtLockWait(); |
|
108 |
} |
|
109 |
||
110 |
// To prevent errors from overriding obsolete methods |
|
111 |
protected final void init(long parentWindow, Rectangle bounds) {} |
|
112 |
protected final void preInit() {} |
|
113 |
protected final void postInit() {} |
|
114 |
||
115 |
// internal lock for synchronizing state changes and paint calls, initialized in preInit. |
|
116 |
// the order with other locks: AWTLock -> stateLock |
|
117 |
static class StateLock extends Object { } |
|
118 |
protected StateLock state_lock; |
|
119 |
||
120 |
/** |
|
121 |
* Called for delayed inits during construction |
|
122 |
*/ |
|
123 |
void instantPreInit(XCreateWindowParams params) { |
|
124 |
state_lock = new StateLock(); |
|
125 |
initialising = InitialiseState.NOT_INITIALISED; |
|
126 |
} |
|
127 |
||
128 |
/** |
|
129 |
* Called before window creation, descendants should override to initialize the data, |
|
130 |
* initialize params. |
|
131 |
*/ |
|
132 |
void preInit(XCreateWindowParams params) { |
|
133 |
state_lock = new StateLock(); |
|
134 |
initialising = InitialiseState.NOT_INITIALISED; |
|
135 |
embedded = Boolean.TRUE.equals(params.get(EMBEDDED)); |
|
136 |
visible = Boolean.TRUE.equals(params.get(VISIBLE)); |
|
137 |
||
138 |
Object parent = params.get(PARENT); |
|
139 |
if (parent instanceof XBaseWindow) { |
|
140 |
parentWindow = (XBaseWindow)parent; |
|
141 |
} else { |
|
142 |
Long parentWindowID = (Long)params.get(PARENT_WINDOW); |
|
143 |
if (parentWindowID != null) { |
|
144 |
parentWindow = XToolkit.windowToXWindow(parentWindowID); |
|
145 |
} |
|
146 |
} |
|
147 |
||
148 |
Long eventMask = (Long)params.get(EVENT_MASK); |
|
149 |
if (eventMask != null) { |
|
150 |
long mask = eventMask.longValue(); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
151 |
mask |= XConstants.SubstructureNotifyMask; |
2 | 152 |
params.put(EVENT_MASK, mask); |
153 |
} |
|
154 |
||
155 |
screen = -1; |
|
156 |
} |
|
157 |
||
158 |
/** |
|
159 |
* Called after window creation, descendants should override to initialize Window |
|
160 |
* with class-specific values and perform post-initialization actions. |
|
161 |
*/ |
|
162 |
void postInit(XCreateWindowParams params) { |
|
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
163 |
if (log.isLoggable(PlatformLogger.Level.FINE)) { |
16839
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
164 |
log.fine("WM name is " + getWMName()); |
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
165 |
} |
2 | 166 |
updateWMName(); |
167 |
||
168 |
// Set WM_CLIENT_LEADER property |
|
169 |
initClientLeader(); |
|
170 |
} |
|
171 |
||
172 |
/** |
|
173 |
* Creates window using parameters <code>params</code> |
|
174 |
* If params contain flag DELAYED doesn't do anything. |
|
175 |
* Note: Descendants can call this method to create the window |
|
176 |
* at the time different to instance construction. |
|
177 |
*/ |
|
178 |
protected final void init(XCreateWindowParams params) { |
|
179 |
awtLock(); |
|
180 |
initialising = InitialiseState.INITIALISING; |
|
181 |
awtUnlock(); |
|
182 |
||
183 |
try { |
|
184 |
if (!Boolean.TRUE.equals(params.get(DELAYED))) { |
|
185 |
preInit(params); |
|
186 |
create(params); |
|
187 |
postInit(params); |
|
188 |
} else { |
|
189 |
instantPreInit(params); |
|
190 |
delayedParams = params; |
|
191 |
} |
|
192 |
awtLock(); |
|
193 |
initialising = InitialiseState.INITIALISED; |
|
194 |
awtLockNotifyAll(); |
|
195 |
awtUnlock(); |
|
196 |
} catch (RuntimeException re) { |
|
197 |
awtLock(); |
|
198 |
initialising = InitialiseState.FAILED_INITIALISATION; |
|
199 |
awtLockNotifyAll(); |
|
200 |
awtUnlock(); |
|
201 |
throw re; |
|
202 |
} catch (Throwable t) { |
|
3938
ef327bd847c0
6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents:
3288
diff
changeset
|
203 |
log.warning("Exception during peer initialization", t); |
2 | 204 |
awtLock(); |
205 |
initialising = InitialiseState.FAILED_INITIALISATION; |
|
206 |
awtLockNotifyAll(); |
|
207 |
awtUnlock(); |
|
208 |
} |
|
209 |
} |
|
210 |
||
211 |
public boolean checkInitialised() { |
|
212 |
awtLock(); |
|
213 |
try { |
|
214 |
switch (initialising) { |
|
215 |
case INITIALISED: |
|
216 |
return true; |
|
217 |
case INITIALISING: |
|
218 |
try { |
|
219 |
while (initialising != InitialiseState.INITIALISED) { |
|
220 |
awtLockWait(); |
|
221 |
} |
|
222 |
} catch (InterruptedException ie) { |
|
223 |
return false; |
|
224 |
} |
|
225 |
return true; |
|
226 |
case NOT_INITIALISED: |
|
227 |
case FAILED_INITIALISATION: |
|
228 |
return false; |
|
229 |
default: |
|
230 |
return false; |
|
231 |
} |
|
232 |
} finally { |
|
233 |
awtUnlock(); |
|
234 |
} |
|
235 |
} |
|
236 |
||
237 |
/* |
|
238 |
* Creates an invisible InputOnly window without an associated Component. |
|
239 |
*/ |
|
240 |
XBaseWindow() { |
|
241 |
this(new XCreateWindowParams()); |
|
242 |
} |
|
243 |
||
244 |
/** |
|
245 |
* Creates normal child window |
|
246 |
*/ |
|
247 |
XBaseWindow(long parentWindow, Rectangle bounds) { |
|
248 |
this(new XCreateWindowParams(new Object[] { |
|
249 |
BOUNDS, bounds, |
|
250 |
PARENT_WINDOW, Long.valueOf(parentWindow)})); |
|
251 |
} |
|
252 |
||
253 |
/** |
|
254 |
* Creates top-level window |
|
255 |
*/ |
|
256 |
XBaseWindow(Rectangle bounds) { |
|
257 |
this(new XCreateWindowParams(new Object[] { |
|
258 |
BOUNDS, bounds |
|
259 |
})); |
|
260 |
} |
|
261 |
||
262 |
public XBaseWindow (XCreateWindowParams params) { |
|
263 |
init(params); |
|
264 |
} |
|
265 |
||
266 |
/* This create is used by the XEmbeddedFramePeer since it has to create the window |
|
267 |
as a child of the netscape window. This netscape window is passed in as wid */ |
|
268 |
XBaseWindow(long parentWindow) { |
|
269 |
this(new XCreateWindowParams(new Object[] { |
|
270 |
PARENT_WINDOW, Long.valueOf(parentWindow), |
|
271 |
EMBEDDED, Boolean.TRUE |
|
272 |
})); |
|
273 |
} |
|
274 |
||
275 |
/** |
|
276 |
* Verifies that all required parameters are set. If not, sets them to default values. |
|
277 |
* Verifies values of critical parameters, adjust their values when needed. |
|
278 |
* @throws IllegalArgumentException if params is null |
|
279 |
*/ |
|
280 |
protected void checkParams(XCreateWindowParams params) { |
|
281 |
if (params == null) { |
|
282 |
throw new IllegalArgumentException("Window creation parameters are null"); |
|
283 |
} |
|
284 |
params.putIfNull(PARENT_WINDOW, Long.valueOf(XToolkit.getDefaultRootWindow())); |
|
285 |
params.putIfNull(BOUNDS, new Rectangle(DEF_LOCATION, DEF_LOCATION, MIN_SIZE, MIN_SIZE)); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
286 |
params.putIfNull(DEPTH, Integer.valueOf((int)XConstants.CopyFromParent)); |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
287 |
params.putIfNull(VISUAL, Long.valueOf(XConstants.CopyFromParent)); |
22584
eed64ee05369
8032733: Fix cast lint warnings in client libraries
darcy
parents:
18178
diff
changeset
|
288 |
params.putIfNull(VISUAL_CLASS, Integer.valueOf(XConstants.InputOnly)); |
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
289 |
params.putIfNull(VALUE_MASK, Long.valueOf(XConstants.CWEventMask)); |
2 | 290 |
Rectangle bounds = (Rectangle)params.get(BOUNDS); |
291 |
bounds.width = Math.max(MIN_SIZE, bounds.width); |
|
292 |
bounds.height = Math.max(MIN_SIZE, bounds.height); |
|
293 |
||
294 |
Long eventMaskObj = (Long)params.get(EVENT_MASK); |
|
295 |
long eventMask = eventMaskObj != null ? eventMaskObj.longValue() : 0; |
|
296 |
// We use our own synthetic grab see XAwtState.getGrabWindow() |
|
297 |
// (see X vol. 1, 8.3.3.2) |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
298 |
eventMask |= XConstants.PropertyChangeMask | XConstants.OwnerGrabButtonMask; |
2 | 299 |
params.put(EVENT_MASK, Long.valueOf(eventMask)); |
300 |
} |
|
301 |
||
302 |
/** |
|
303 |
* Creates window with parameters specified by <code>params</code> |
|
304 |
* @see #init |
|
305 |
*/ |
|
306 |
private final void create(XCreateWindowParams params) { |
|
307 |
XToolkit.awtLock(); |
|
308 |
try { |
|
309 |
XSetWindowAttributes xattr = new XSetWindowAttributes(); |
|
310 |
try { |
|
311 |
checkParams(params); |
|
312 |
||
313 |
long value_mask = ((Long)params.get(VALUE_MASK)).longValue(); |
|
314 |
||
315 |
Long eventMask = (Long)params.get(EVENT_MASK); |
|
316 |
xattr.set_event_mask(eventMask.longValue()); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
317 |
value_mask |= XConstants.CWEventMask; |
2 | 318 |
|
319 |
Long border_pixel = (Long)params.get(BORDER_PIXEL); |
|
320 |
if (border_pixel != null) { |
|
321 |
xattr.set_border_pixel(border_pixel.longValue()); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
322 |
value_mask |= XConstants.CWBorderPixel; |
2 | 323 |
} |
324 |
||
325 |
Long colormap = (Long)params.get(COLORMAP); |
|
326 |
if (colormap != null) { |
|
327 |
xattr.set_colormap(colormap.longValue()); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
328 |
value_mask |= XConstants.CWColormap; |
2 | 329 |
} |
330 |
Long background_pixmap = (Long)params.get(BACKGROUND_PIXMAP); |
|
331 |
if (background_pixmap != null) { |
|
332 |
xattr.set_background_pixmap(background_pixmap.longValue()); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
333 |
value_mask |= XConstants.CWBackPixmap; |
2 | 334 |
} |
335 |
||
336 |
Long parentWindow = (Long)params.get(PARENT_WINDOW); |
|
337 |
Rectangle bounds = (Rectangle)params.get(BOUNDS); |
|
338 |
Integer depth = (Integer)params.get(DEPTH); |
|
339 |
Integer visual_class = (Integer)params.get(VISUAL_CLASS); |
|
340 |
Long visual = (Long)params.get(VISUAL); |
|
341 |
Boolean overrideRedirect = (Boolean)params.get(OVERRIDE_REDIRECT); |
|
342 |
if (overrideRedirect != null) { |
|
343 |
xattr.set_override_redirect(overrideRedirect.booleanValue()); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
344 |
value_mask |= XConstants.CWOverrideRedirect; |
2 | 345 |
} |
346 |
||
347 |
Boolean saveUnder = (Boolean)params.get(SAVE_UNDER); |
|
348 |
if (saveUnder != null) { |
|
349 |
xattr.set_save_under(saveUnder.booleanValue()); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
350 |
value_mask |= XConstants.CWSaveUnder; |
2 | 351 |
} |
352 |
||
353 |
Integer backingStore = (Integer)params.get(BACKING_STORE); |
|
354 |
if (backingStore != null) { |
|
355 |
xattr.set_backing_store(backingStore.intValue()); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
356 |
value_mask |= XConstants.CWBackingStore; |
2 | 357 |
} |
358 |
||
359 |
Integer bitGravity = (Integer)params.get(BIT_GRAVITY); |
|
360 |
if (bitGravity != null) { |
|
361 |
xattr.set_bit_gravity(bitGravity.intValue()); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
362 |
value_mask |= XConstants.CWBitGravity; |
2 | 363 |
} |
364 |
||
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
365 |
if (log.isLoggable(PlatformLogger.Level.FINE)) { |
2 | 366 |
log.fine("Creating window for " + this + " with the following attributes: \n" + params); |
367 |
} |
|
368 |
window = XlibWrapper.XCreateWindow(XToolkit.getDisplay(), |
|
369 |
parentWindow.longValue(), |
|
370 |
bounds.x, bounds.y, // location |
|
371 |
bounds.width, bounds.height, // size |
|
372 |
0, // border |
|
373 |
depth.intValue(), // depth |
|
374 |
visual_class.intValue(), // class |
|
375 |
visual.longValue(), // visual |
|
376 |
value_mask, // value mask |
|
377 |
xattr.pData); // attributes |
|
378 |
||
379 |
if (window == 0) { |
|
380 |
throw new IllegalStateException("Couldn't create window because of wrong parameters. Run with NOISY_AWT to see details"); |
|
381 |
} |
|
382 |
XToolkit.addToWinMap(window, this); |
|
383 |
} finally { |
|
384 |
xattr.dispose(); |
|
385 |
} |
|
386 |
} finally { |
|
387 |
XToolkit.awtUnlock(); |
|
388 |
} |
|
389 |
} |
|
390 |
||
391 |
public XCreateWindowParams getDelayedParams() { |
|
392 |
return delayedParams; |
|
393 |
} |
|
394 |
||
395 |
protected String getWMName() { |
|
396 |
return XToolkit.getCorrectXIDString(getClass().getName()); |
|
397 |
} |
|
398 |
||
399 |
protected void initClientLeader() { |
|
400 |
XToolkit.awtLock(); |
|
401 |
try { |
|
402 |
if (wm_client_leader == null) { |
|
403 |
wm_client_leader = XAtom.get("WM_CLIENT_LEADER"); |
|
404 |
} |
|
405 |
wm_client_leader.setWindowProperty(this, getXAWTRootWindow()); |
|
406 |
} finally { |
|
407 |
XToolkit.awtUnlock(); |
|
408 |
} |
|
409 |
} |
|
410 |
||
411 |
static XRootWindow getXAWTRootWindow() { |
|
412 |
return XRootWindow.getInstance(); |
|
413 |
} |
|
414 |
||
415 |
void destroy() { |
|
416 |
XToolkit.awtLock(); |
|
417 |
try { |
|
418 |
if (hints != null) { |
|
419 |
XlibWrapper.XFree(hints.pData); |
|
420 |
hints = null; |
|
421 |
} |
|
422 |
XToolkit.removeFromWinMap(getWindow(), this); |
|
423 |
XlibWrapper.XDestroyWindow(XToolkit.getDisplay(), getWindow()); |
|
424 |
if (XPropertyCache.isCachingSupported()) { |
|
425 |
XPropertyCache.clearCache(window); |
|
426 |
} |
|
427 |
window = -1; |
|
428 |
if( !isDisposed() ) { |
|
429 |
setDisposed( true ); |
|
430 |
} |
|
431 |
||
432 |
XAwtState.getGrabWindow(); // Magic - getGrabWindow clear state if grabbing window is disposed of. |
|
433 |
} finally { |
|
434 |
XToolkit.awtUnlock(); |
|
435 |
} |
|
436 |
} |
|
437 |
||
438 |
void flush() { |
|
439 |
XToolkit.awtLock(); |
|
440 |
try { |
|
441 |
XlibWrapper.XFlush(XToolkit.getDisplay()); |
|
442 |
} finally { |
|
443 |
XToolkit.awtUnlock(); |
|
444 |
} |
|
445 |
} |
|
446 |
||
447 |
/** |
|
448 |
* Helper function to set W |
|
449 |
*/ |
|
450 |
public final void setWMHints(XWMHints hints) { |
|
451 |
XToolkit.awtLock(); |
|
452 |
try { |
|
453 |
XlibWrapper.XSetWMHints(XToolkit.getDisplay(), getWindow(), hints.pData); |
|
454 |
} finally { |
|
455 |
XToolkit.awtUnlock(); |
|
456 |
} |
|
457 |
} |
|
458 |
||
459 |
public XWMHints getWMHints() { |
|
460 |
if (wmHints == null) { |
|
461 |
wmHints = new XWMHints(XlibWrapper.XAllocWMHints()); |
|
462 |
// XlibWrapper.XGetWMHints(XToolkit.getDisplay(), |
|
463 |
// getWindow(), |
|
464 |
// wmHints.pData); |
|
465 |
} |
|
466 |
return wmHints; |
|
467 |
} |
|
468 |
||
469 |
||
470 |
/* |
|
471 |
* Call this method under AWTLock. |
|
472 |
* The lock should be acquired untill all operations with XSizeHints are completed. |
|
473 |
*/ |
|
474 |
public XSizeHints getHints() { |
|
475 |
if (hints == null) { |
|
476 |
long p_hints = XlibWrapper.XAllocSizeHints(); |
|
477 |
hints = new XSizeHints(p_hints); |
|
478 |
// XlibWrapper.XGetWMNormalHints(XToolkit.getDisplay(), getWindow(), p_hints, XlibWrapper.larg1); |
|
479 |
// TODO: Shouldn't we listen for WM updates on this property? |
|
480 |
} |
|
481 |
return hints; |
|
482 |
} |
|
483 |
||
484 |
public void setSizeHints(long flags, int x, int y, int width, int height) { |
|
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
485 |
if (insLog.isLoggable(PlatformLogger.Level.FINER)) { |
16839
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
486 |
insLog.finer("Setting hints, flags " + XlibWrapper.hintsToString(flags)); |
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
487 |
} |
2 | 488 |
XToolkit.awtLock(); |
489 |
try { |
|
490 |
XSizeHints hints = getHints(); |
|
491 |
// Note: if PPosition is not set in flags this means that |
|
492 |
// we want to reset PPosition in hints. This is necessary |
|
493 |
// for locationByPlatform functionality |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
494 |
if ((flags & XUtilConstants.PPosition) != 0) { |
2 | 495 |
hints.set_x(x); |
496 |
hints.set_y(y); |
|
497 |
} |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
498 |
if ((flags & XUtilConstants.PSize) != 0) { |
2 | 499 |
hints.set_width(width); |
500 |
hints.set_height(height); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
501 |
} else if ((hints.get_flags() & XUtilConstants.PSize) != 0) { |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
502 |
flags |= XUtilConstants.PSize; |
2 | 503 |
} |
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
504 |
if ((flags & XUtilConstants.PMinSize) != 0) { |
2 | 505 |
hints.set_min_width(width); |
506 |
hints.set_min_height(height); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
507 |
} else if ((hints.get_flags() & XUtilConstants.PMinSize) != 0) { |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
508 |
flags |= XUtilConstants.PMinSize; |
2 | 509 |
//Fix for 4320050: Minimum size for java.awt.Frame is not being enforced. |
510 |
//We don't need to reset minimum size if it's already set |
|
511 |
} |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
512 |
if ((flags & XUtilConstants.PMaxSize) != 0) { |
2 | 513 |
if (maxBounds != null) { |
514 |
if (maxBounds.width != Integer.MAX_VALUE) { |
|
515 |
hints.set_max_width(maxBounds.width); |
|
516 |
} else { |
|
517 |
hints.set_max_width(XToolkit.getDefaultScreenWidth()); |
|
518 |
} |
|
519 |
if (maxBounds.height != Integer.MAX_VALUE) { |
|
520 |
hints.set_max_height(maxBounds.height); |
|
521 |
} else { |
|
522 |
hints.set_max_height(XToolkit.getDefaultScreenHeight()); |
|
523 |
} |
|
524 |
} else { |
|
525 |
hints.set_max_width(width); |
|
526 |
hints.set_max_height(height); |
|
527 |
} |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
528 |
} else if ((hints.get_flags() & XUtilConstants.PMaxSize) != 0) { |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
529 |
flags |= XUtilConstants.PMaxSize; |
2 | 530 |
if (maxBounds != null) { |
531 |
if (maxBounds.width != Integer.MAX_VALUE) { |
|
532 |
hints.set_max_width(maxBounds.width); |
|
533 |
} else { |
|
534 |
hints.set_max_width(XToolkit.getDefaultScreenWidth()); |
|
535 |
} |
|
536 |
if (maxBounds.height != Integer.MAX_VALUE) { |
|
537 |
hints.set_max_height(maxBounds.height); |
|
538 |
} else { |
|
539 |
hints.set_max_height(XToolkit.getDefaultScreenHeight()); |
|
540 |
} |
|
541 |
} else { |
|
542 |
// Leave intact |
|
543 |
} |
|
544 |
} |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
545 |
flags |= XUtilConstants.PWinGravity; |
2 | 546 |
hints.set_flags(flags); |
22584
eed64ee05369
8032733: Fix cast lint warnings in client libraries
darcy
parents:
18178
diff
changeset
|
547 |
hints.set_win_gravity(XConstants.NorthWestGravity); |
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
548 |
if (insLog.isLoggable(PlatformLogger.Level.FINER)) { |
16839
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
549 |
insLog.finer("Setting hints, resulted flags " + XlibWrapper.hintsToString(flags) + |
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
550 |
", values " + hints); |
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
551 |
} |
2 | 552 |
XlibWrapper.XSetWMNormalHints(XToolkit.getDisplay(), getWindow(), hints.pData); |
553 |
} finally { |
|
554 |
XToolkit.awtUnlock(); |
|
555 |
} |
|
556 |
} |
|
557 |
||
558 |
public boolean isMinSizeSet() { |
|
559 |
XSizeHints hints = getHints(); |
|
560 |
long flags = hints.get_flags(); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
561 |
return ((flags & XUtilConstants.PMinSize) == XUtilConstants.PMinSize); |
2 | 562 |
} |
563 |
||
564 |
/** |
|
565 |
* This lock object can be used to protect instance data from concurrent access |
|
566 |
* by two threads. If both state lock and AWT lock are taken, AWT Lock should be taken first. |
|
567 |
*/ |
|
568 |
Object getStateLock() { |
|
569 |
return state_lock; |
|
570 |
} |
|
571 |
||
572 |
public long getWindow() { |
|
573 |
return window; |
|
574 |
} |
|
575 |
public long getContentWindow() { |
|
576 |
return window; |
|
577 |
} |
|
578 |
||
579 |
public XBaseWindow getContentXWindow() { |
|
580 |
return XToolkit.windowToXWindow(getContentWindow()); |
|
581 |
} |
|
582 |
||
583 |
public Rectangle getBounds() { |
|
584 |
return new Rectangle(x, y, width, height); |
|
585 |
} |
|
586 |
public Dimension getSize() { |
|
587 |
return new Dimension(width, height); |
|
588 |
} |
|
589 |
||
590 |
||
591 |
public void toFront() { |
|
592 |
XToolkit.awtLock(); |
|
593 |
try { |
|
594 |
XlibWrapper.XRaiseWindow(XToolkit.getDisplay(), getWindow()); |
|
595 |
} finally { |
|
596 |
XToolkit.awtUnlock(); |
|
597 |
} |
|
598 |
} |
|
599 |
public void xRequestFocus(long time) { |
|
600 |
XToolkit.awtLock(); |
|
601 |
try { |
|
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
602 |
if (focusLog.isLoggable(PlatformLogger.Level.FINER)) { |
16839
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
603 |
focusLog.finer("XSetInputFocus on " + Long.toHexString(getWindow()) + " with time " + time); |
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
604 |
} |
2 | 605 |
XlibWrapper.XSetInputFocus2(XToolkit.getDisplay(), getWindow(), time); |
606 |
} finally { |
|
607 |
XToolkit.awtUnlock(); |
|
608 |
} |
|
609 |
} |
|
610 |
public void xRequestFocus() { |
|
611 |
XToolkit.awtLock(); |
|
612 |
try { |
|
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
613 |
if (focusLog.isLoggable(PlatformLogger.Level.FINER)) { |
16839
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
614 |
focusLog.finer("XSetInputFocus on " + Long.toHexString(getWindow())); |
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
615 |
} |
2 | 616 |
XlibWrapper.XSetInputFocus(XToolkit.getDisplay(), getWindow()); |
617 |
} finally { |
|
618 |
XToolkit.awtUnlock(); |
|
619 |
} |
|
620 |
} |
|
621 |
||
622 |
public static long xGetInputFocus() { |
|
623 |
XToolkit.awtLock(); |
|
624 |
try { |
|
625 |
return XlibWrapper.XGetInputFocus(XToolkit.getDisplay()); |
|
626 |
} finally { |
|
627 |
XToolkit.awtUnlock(); |
|
628 |
} |
|
629 |
} |
|
630 |
||
631 |
public void xSetVisible(boolean visible) { |
|
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
632 |
if (log.isLoggable(PlatformLogger.Level.FINE)) { |
16839
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
633 |
log.fine("Setting visible on " + this + " to " + visible); |
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
634 |
} |
2 | 635 |
XToolkit.awtLock(); |
636 |
try { |
|
637 |
this.visible = visible; |
|
638 |
if (visible) { |
|
639 |
XlibWrapper.XMapWindow(XToolkit.getDisplay(), getWindow()); |
|
640 |
} |
|
641 |
else { |
|
642 |
XlibWrapper.XUnmapWindow(XToolkit.getDisplay(), getWindow()); |
|
643 |
} |
|
644 |
XlibWrapper.XFlush(XToolkit.getDisplay()); |
|
645 |
} finally { |
|
646 |
XToolkit.awtUnlock(); |
|
647 |
} |
|
648 |
} |
|
649 |
||
650 |
boolean isMapped() { |
|
651 |
return mapped; |
|
652 |
} |
|
653 |
||
654 |
void updateWMName() { |
|
655 |
String name = getWMName(); |
|
656 |
XToolkit.awtLock(); |
|
657 |
try { |
|
658 |
if (name == null) { |
|
659 |
name = " "; |
|
660 |
} |
|
661 |
XAtom nameAtom = XAtom.get(XAtom.XA_WM_NAME); |
|
662 |
nameAtom.setProperty(getWindow(), name); |
|
663 |
XAtom netNameAtom = XAtom.get("_NET_WM_NAME"); |
|
664 |
netNameAtom.setPropertyUTF8(getWindow(), name); |
|
665 |
} finally { |
|
666 |
XToolkit.awtUnlock(); |
|
667 |
} |
|
668 |
} |
|
669 |
void setWMClass(String[] cl) { |
|
670 |
if (cl.length != 2) { |
|
671 |
throw new IllegalArgumentException("WM_CLASS_NAME consists of exactly two strings"); |
|
672 |
} |
|
673 |
XToolkit.awtLock(); |
|
674 |
try { |
|
675 |
XAtom xa = XAtom.get(XAtom.XA_WM_CLASS); |
|
676 |
xa.setProperty8(getWindow(), cl[0] + '\0' + cl[1]); |
|
677 |
} finally { |
|
678 |
XToolkit.awtUnlock(); |
|
679 |
} |
|
680 |
} |
|
681 |
||
682 |
boolean isVisible() { |
|
683 |
return visible; |
|
684 |
} |
|
685 |
||
686 |
static long getScreenOfWindow(long window) { |
|
687 |
XToolkit.awtLock(); |
|
688 |
try { |
|
689 |
return XlibWrapper.getScreenOfWindow(XToolkit.getDisplay(), window); |
|
690 |
} finally { |
|
691 |
XToolkit.awtUnlock(); |
|
692 |
} |
|
693 |
} |
|
694 |
long getScreenNumber() { |
|
695 |
XToolkit.awtLock(); |
|
696 |
try { |
|
697 |
return XlibWrapper.XScreenNumberOfScreen(getScreen()); |
|
698 |
} finally { |
|
699 |
XToolkit.awtUnlock(); |
|
700 |
} |
|
701 |
} |
|
702 |
||
703 |
long getScreen() { |
|
704 |
if (screen == -1) { // Not initialized |
|
705 |
screen = getScreenOfWindow(window); |
|
706 |
} |
|
707 |
return screen; |
|
708 |
} |
|
709 |
||
710 |
public void xSetBounds(Rectangle bounds) { |
|
711 |
xSetBounds(bounds.x, bounds.y, bounds.width, bounds.height); |
|
712 |
} |
|
713 |
||
714 |
public void xSetBounds(int x, int y, int width, int height) { |
|
715 |
if (getWindow() == 0) { |
|
716 |
insLog.warning("Attempt to resize uncreated window"); |
|
717 |
throw new IllegalStateException("Attempt to resize uncreated window"); |
|
718 |
} |
|
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
719 |
if (insLog.isLoggable(PlatformLogger.Level.FINE)) { |
16839
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
720 |
insLog.fine("Setting bounds on " + this + " to (" + x + ", " + y + "), " + width + "x" + height); |
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
721 |
} |
6637
64ecd501905b
6987945: XDecoratedPeer shouldn't allow to resize a frame to zero size
omajid
parents:
5506
diff
changeset
|
722 |
width = Math.max(MIN_SIZE, width); |
64ecd501905b
6987945: XDecoratedPeer shouldn't allow to resize a frame to zero size
omajid
parents:
5506
diff
changeset
|
723 |
height = Math.max(MIN_SIZE, height); |
2 | 724 |
XToolkit.awtLock(); |
725 |
try { |
|
726 |
XlibWrapper.XMoveResizeWindow(XToolkit.getDisplay(), getWindow(), x,y,width,height); |
|
727 |
} finally { |
|
728 |
XToolkit.awtUnlock(); |
|
729 |
} |
|
730 |
} |
|
731 |
||
732 |
/** |
|
733 |
* Translate coordinates from one window into another. Optimized |
|
734 |
* for XAWT - uses cached data when possible. Preferable over |
|
735 |
* pure XTranslateCoordinates. |
|
736 |
* @return coordinates relative to dst, or null if error happened |
|
737 |
*/ |
|
738 |
static Point toOtherWindow(long src, long dst, int x, int y) { |
|
739 |
Point rpt = new Point(0, 0); |
|
740 |
||
741 |
// Check if both windows belong to XAWT - then no X calls are necessary |
|
742 |
||
743 |
XBaseWindow srcPeer = XToolkit.windowToXWindow(src); |
|
744 |
XBaseWindow dstPeer = XToolkit.windowToXWindow(dst); |
|
745 |
||
746 |
if (srcPeer != null && dstPeer != null) { |
|
747 |
// (x, y) is relative to src |
|
748 |
rpt.x = x + srcPeer.getAbsoluteX() - dstPeer.getAbsoluteX(); |
|
749 |
rpt.y = y + srcPeer.getAbsoluteY() - dstPeer.getAbsoluteY(); |
|
750 |
} else if (dstPeer != null && XlibUtil.isRoot(src, dstPeer.getScreenNumber())) { |
|
751 |
// from root into peer |
|
752 |
rpt.x = x - dstPeer.getAbsoluteX(); |
|
753 |
rpt.y = y - dstPeer.getAbsoluteY(); |
|
754 |
} else if (srcPeer != null && XlibUtil.isRoot(dst, srcPeer.getScreenNumber())) { |
|
755 |
// from peer into root |
|
756 |
rpt.x = x + srcPeer.getAbsoluteX(); |
|
757 |
rpt.y = y + srcPeer.getAbsoluteY(); |
|
758 |
} else { |
|
759 |
rpt = XlibUtil.translateCoordinates(src, dst, new Point(x, y)); |
|
760 |
} |
|
761 |
return rpt; |
|
762 |
} |
|
763 |
||
764 |
/* |
|
765 |
* Convert to global coordinates. |
|
766 |
*/ |
|
767 |
Rectangle toGlobal(Rectangle rec) { |
|
768 |
Point p = toGlobal(rec.getLocation()); |
|
769 |
Rectangle newRec = new Rectangle(rec); |
|
770 |
if (p != null) { |
|
771 |
newRec.setLocation(p); |
|
772 |
} |
|
773 |
return newRec; |
|
774 |
} |
|
775 |
||
776 |
Point toGlobal(Point pt) { |
|
777 |
Point p = toGlobal(pt.x, pt.y); |
|
778 |
if (p != null) { |
|
779 |
return p; |
|
780 |
} else { |
|
781 |
return new Point(pt); |
|
782 |
} |
|
783 |
} |
|
784 |
||
785 |
Point toGlobal(int x, int y) { |
|
786 |
long root; |
|
787 |
XToolkit.awtLock(); |
|
788 |
try { |
|
789 |
root = XlibWrapper.RootWindow(XToolkit.getDisplay(), |
|
790 |
getScreenNumber()); |
|
791 |
} finally { |
|
792 |
XToolkit.awtUnlock(); |
|
793 |
} |
|
794 |
Point p = toOtherWindow(getContentWindow(), root, x, y); |
|
795 |
if (p != null) { |
|
796 |
return p; |
|
797 |
} else { |
|
798 |
return new Point(x, y); |
|
799 |
} |
|
800 |
} |
|
801 |
||
802 |
/* |
|
803 |
* Convert to local coordinates. |
|
804 |
*/ |
|
805 |
Point toLocal(Point pt) { |
|
806 |
Point p = toLocal(pt.x, pt.y); |
|
807 |
if (p != null) { |
|
808 |
return p; |
|
809 |
} else { |
|
810 |
return new Point(pt); |
|
811 |
} |
|
812 |
} |
|
813 |
||
814 |
Point toLocal(int x, int y) { |
|
815 |
long root; |
|
816 |
XToolkit.awtLock(); |
|
817 |
try { |
|
818 |
root = XlibWrapper.RootWindow(XToolkit.getDisplay(), |
|
819 |
getScreenNumber()); |
|
820 |
} finally { |
|
821 |
XToolkit.awtUnlock(); |
|
822 |
} |
|
823 |
Point p = toOtherWindow(root, getContentWindow(), x, y); |
|
824 |
if (p != null) { |
|
825 |
return p; |
|
826 |
} else { |
|
827 |
return new Point(x, y); |
|
828 |
} |
|
829 |
} |
|
830 |
||
831 |
/** |
|
832 |
* We should always grab both keyboard and pointer to control event flow |
|
833 |
* on popups. This also simplifies synthetic grab implementation. |
|
834 |
* The active grab overrides activated automatic grab. |
|
835 |
*/ |
|
836 |
public boolean grabInput() { |
|
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
837 |
if (grabLog.isLoggable(PlatformLogger.Level.FINE)) { |
16839
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
838 |
grabLog.fine("Grab input on {0}", this); |
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
839 |
} |
2 | 840 |
|
841 |
XToolkit.awtLock(); |
|
842 |
try { |
|
843 |
if (XAwtState.getGrabWindow() == this && |
|
844 |
XAwtState.isManualGrab()) |
|
845 |
{ |
|
846 |
grabLog.fine(" Already Grabbed"); |
|
847 |
return true; |
|
848 |
} |
|
849 |
//6273031: PIT. Choice drop down does not close once it is right clicked to show a popup menu |
|
850 |
//remember previous window having grab and if it's not null ungrab it. |
|
851 |
XBaseWindow prevGrabWindow = XAwtState.getGrabWindow(); |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
852 |
final int eventMask = (int) (XConstants.ButtonPressMask | XConstants.ButtonReleaseMask |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
853 |
| XConstants.EnterWindowMask | XConstants.LeaveWindowMask | XConstants.PointerMotionMask |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
854 |
| XConstants.ButtonMotionMask); |
2 | 855 |
final int ownerEvents = 1; |
856 |
||
857 |
||
2471
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
858 |
//6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
859 |
//process on Linux |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
860 |
//The user must pass the sun.awt.disablegrab property to disable |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
861 |
//taking grabs. This prevents hanging of the GUI when a breakpoint |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
862 |
//is hit while a popup window taking the grab is open. |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
863 |
if (!XToolkit.getSunAwtDisableGrab()) { |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
864 |
int ptrGrab = XlibWrapper.XGrabPointer(XToolkit.getDisplay(), |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
865 |
getContentWindow(), ownerEvents, eventMask, XConstants.GrabModeAsync, |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
866 |
XConstants.GrabModeAsync, XConstants.None, (XWM.isMotif() ? XToolkit.arrowCursor : XConstants.None), |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
867 |
XConstants.CurrentTime); |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
868 |
// Check grab results to be consistent with X server grab |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
869 |
if (ptrGrab != XConstants.GrabSuccess) { |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
870 |
XlibWrapper.XUngrabPointer(XToolkit.getDisplay(), XConstants.CurrentTime); |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
871 |
XAwtState.setGrabWindow(null); |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
872 |
grabLog.fine(" Grab Failure - mouse"); |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
873 |
return false; |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
874 |
} |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
875 |
|
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
876 |
int keyGrab = XlibWrapper.XGrabKeyboard(XToolkit.getDisplay(), |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
877 |
getContentWindow(), ownerEvents, XConstants.GrabModeAsync, XConstants.GrabModeAsync, |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
878 |
XConstants.CurrentTime); |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
879 |
if (keyGrab != XConstants.GrabSuccess) { |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
880 |
XlibWrapper.XUngrabPointer(XToolkit.getDisplay(), XConstants.CurrentTime); |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
881 |
XlibWrapper.XUngrabKeyboard(XToolkit.getDisplay(), XConstants.CurrentTime); |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
882 |
XAwtState.setGrabWindow(null); |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
883 |
grabLog.fine(" Grab Failure - keyboard"); |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
884 |
return false; |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
885 |
} |
2 | 886 |
} |
887 |
if (prevGrabWindow != null) { |
|
888 |
prevGrabWindow.ungrabInputImpl(); |
|
889 |
} |
|
890 |
XAwtState.setGrabWindow(this); |
|
891 |
grabLog.fine(" Grab - success"); |
|
892 |
return true; |
|
893 |
} finally { |
|
894 |
XToolkit.awtUnlock(); |
|
895 |
} |
|
896 |
} |
|
897 |
||
898 |
static void ungrabInput() { |
|
899 |
XToolkit.awtLock(); |
|
900 |
try { |
|
901 |
XBaseWindow grabWindow = XAwtState.getGrabWindow(); |
|
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
902 |
if (grabLog.isLoggable(PlatformLogger.Level.FINE)) { |
16839
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
903 |
grabLog.fine("UnGrab input on {0}", grabWindow); |
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
904 |
} |
2 | 905 |
if (grabWindow != null) { |
906 |
grabWindow.ungrabInputImpl(); |
|
2471
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
907 |
if (!XToolkit.getSunAwtDisableGrab()) { |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
908 |
XlibWrapper.XUngrabPointer(XToolkit.getDisplay(), XConstants.CurrentTime); |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
909 |
XlibWrapper.XUngrabKeyboard(XToolkit.getDisplay(), XConstants.CurrentTime); |
71401ceec494
6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs process on Linux
anthony
parents:
1962
diff
changeset
|
910 |
} |
2 | 911 |
XAwtState.setGrabWindow(null); |
912 |
// we need to call XFlush() here to force ungrab |
|
913 |
// see 6384219 for details |
|
914 |
XlibWrapper.XFlush(XToolkit.getDisplay()); |
|
915 |
} |
|
916 |
} finally { |
|
917 |
XToolkit.awtUnlock(); |
|
918 |
} |
|
919 |
} |
|
920 |
||
921 |
// called from ungrabInput, used in popup windows to hide theirselfs in ungrabbing |
|
922 |
void ungrabInputImpl() { |
|
923 |
} |
|
924 |
||
925 |
static void checkSecurity() { |
|
926 |
if (XToolkit.isSecurityWarningEnabled() && XToolkit.isToolkitThread()) { |
|
927 |
StackTraceElement stack[] = (new Throwable()).getStackTrace(); |
|
928 |
log.warning(stack[1] + ": Security violation: calling user code on toolkit thread"); |
|
929 |
} |
|
930 |
} |
|
931 |
||
932 |
public Set<Long> getChildren() { |
|
933 |
synchronized (getStateLock()) { |
|
934 |
return new HashSet<Long>(children); |
|
935 |
} |
|
936 |
} |
|
937 |
||
938 |
// -------------- Event handling ---------------- |
|
939 |
public void handleMapNotifyEvent(XEvent xev) { |
|
940 |
mapped = true; |
|
941 |
} |
|
942 |
public void handleUnmapNotifyEvent(XEvent xev) { |
|
943 |
mapped = false; |
|
944 |
} |
|
945 |
public void handleReparentNotifyEvent(XEvent xev) { |
|
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
946 |
if (eventLog.isLoggable(PlatformLogger.Level.FINER)) { |
2 | 947 |
XReparentEvent msg = xev.get_xreparent(); |
948 |
eventLog.finer(msg.toString()); |
|
949 |
} |
|
950 |
} |
|
951 |
public void handlePropertyNotify(XEvent xev) { |
|
952 |
XPropertyEvent msg = xev.get_xproperty(); |
|
953 |
if (XPropertyCache.isCachingSupported()) { |
|
954 |
XPropertyCache.clearCache(window, XAtom.get(msg.get_atom())); |
|
955 |
} |
|
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
956 |
if (eventLog.isLoggable(PlatformLogger.Level.FINER)) { |
3938
ef327bd847c0
6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents:
3288
diff
changeset
|
957 |
eventLog.finer("{0}", msg); |
2 | 958 |
} |
959 |
} |
|
960 |
||
961 |
public void handleDestroyNotify(XEvent xev) { |
|
962 |
XAnyEvent xany = xev.get_xany(); |
|
963 |
if (xany.get_window() == getWindow()) { |
|
964 |
XToolkit.removeFromWinMap(getWindow(), this); |
|
965 |
if (XPropertyCache.isCachingSupported()) { |
|
966 |
XPropertyCache.clearCache(getWindow()); |
|
967 |
} |
|
968 |
} |
|
969 |
if (xany.get_window() != getWindow()) { |
|
970 |
synchronized (getStateLock()) { |
|
971 |
children.remove(xany.get_window()); |
|
972 |
} |
|
973 |
} |
|
974 |
} |
|
975 |
||
976 |
public void handleCreateNotify(XEvent xev) { |
|
977 |
XAnyEvent xany = xev.get_xany(); |
|
978 |
if (xany.get_window() != getWindow()) { |
|
979 |
synchronized (getStateLock()) { |
|
980 |
children.add(xany.get_window()); |
|
981 |
} |
|
982 |
} |
|
983 |
} |
|
984 |
||
985 |
public void handleClientMessage(XEvent xev) { |
|
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
986 |
if (eventLog.isLoggable(PlatformLogger.Level.FINER)) { |
2 | 987 |
XClientMessageEvent msg = xev.get_xclient(); |
988 |
eventLog.finer(msg.toString()); |
|
989 |
} |
|
990 |
} |
|
991 |
||
992 |
public void handleVisibilityEvent(XEvent xev) { |
|
993 |
} |
|
994 |
public void handleKeyPress(XEvent xev) { |
|
995 |
} |
|
996 |
public void handleKeyRelease(XEvent xev) { |
|
997 |
} |
|
998 |
public void handleExposeEvent(XEvent xev) { |
|
999 |
} |
|
1000 |
/** |
|
1001 |
* Activate automatic grab on first ButtonPress, |
|
1002 |
* deactivate on full mouse release |
|
1003 |
*/ |
|
1004 |
public void handleButtonPressRelease(XEvent xev) { |
|
1005 |
XButtonEvent xbe = xev.get_xbutton(); |
|
2810
fa49c6a06baf
6799099: All automatic regression tests that create Robot fail on X11
dav
parents:
2471
diff
changeset
|
1006 |
/* |
fa49c6a06baf
6799099: All automatic regression tests that create Robot fail on X11
dav
parents:
2471
diff
changeset
|
1007 |
* Ignore the buttons above 20 due to the bit limit for |
fa49c6a06baf
6799099: All automatic regression tests that create Robot fail on X11
dav
parents:
2471
diff
changeset
|
1008 |
* InputEvent.BUTTON_DOWN_MASK. |
fa49c6a06baf
6799099: All automatic regression tests that create Robot fail on X11
dav
parents:
2471
diff
changeset
|
1009 |
* One more bit is reserved for FIRST_HIGH_BIT. |
fa49c6a06baf
6799099: All automatic regression tests that create Robot fail on X11
dav
parents:
2471
diff
changeset
|
1010 |
*/ |
fa49c6a06baf
6799099: All automatic regression tests that create Robot fail on X11
dav
parents:
2471
diff
changeset
|
1011 |
if (xbe.get_button() > SunToolkit.MAX_BUTTONS_SUPPORTED) { |
fa49c6a06baf
6799099: All automatic regression tests that create Robot fail on X11
dav
parents:
2471
diff
changeset
|
1012 |
return; |
fa49c6a06baf
6799099: All automatic regression tests that create Robot fail on X11
dav
parents:
2471
diff
changeset
|
1013 |
} |
1962
6c293d33645b
6315717: Support for mouse with multiple scroll wheels and 4 or more buttons
dav
parents:
439
diff
changeset
|
1014 |
int buttonState = 0; |
14888
7ad1550e7050
8005018: X11: focus problems with openjdk 1.7.0 under gnome3 when selected keyboard is not the first in keyboard list
neugens
parents:
13652
diff
changeset
|
1015 |
buttonState = xbe.get_state() & XConstants.ALL_BUTTONS_MASK; |
2 | 1016 |
switch (xev.get_type()) { |
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1017 |
case XConstants.ButtonPress: |
2 | 1018 |
if (buttonState == 0) { |
13652
42544e68dc39
6981400: Tabbing between textfield do not work properly when ALT+TAB
ant
parents:
7668
diff
changeset
|
1019 |
XWindowPeer parent = getToplevelXWindow(); |
42544e68dc39
6981400: Tabbing between textfield do not work properly when ALT+TAB
ant
parents:
7668
diff
changeset
|
1020 |
// See 6385277, 6981400. |
42544e68dc39
6981400: Tabbing between textfield do not work properly when ALT+TAB
ant
parents:
7668
diff
changeset
|
1021 |
if (parent != null && parent.isFocusableWindow()) { |
42544e68dc39
6981400: Tabbing between textfield do not work properly when ALT+TAB
ant
parents:
7668
diff
changeset
|
1022 |
// A click in a client area drops the actual focused window retaining. |
42544e68dc39
6981400: Tabbing between textfield do not work properly when ALT+TAB
ant
parents:
7668
diff
changeset
|
1023 |
parent.setActualFocusedWindow(null); |
42544e68dc39
6981400: Tabbing between textfield do not work properly when ALT+TAB
ant
parents:
7668
diff
changeset
|
1024 |
parent.requestWindowFocus(xbe.get_time(), true); |
42544e68dc39
6981400: Tabbing between textfield do not work properly when ALT+TAB
ant
parents:
7668
diff
changeset
|
1025 |
} |
2 | 1026 |
XAwtState.setAutoGrabWindow(this); |
1027 |
} |
|
1028 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1029 |
case XConstants.ButtonRelease: |
2 | 1030 |
if (isFullRelease(buttonState, xbe.get_button())) { |
1031 |
XAwtState.setAutoGrabWindow(null); |
|
1032 |
} |
|
1033 |
break; |
|
1034 |
} |
|
1035 |
} |
|
1036 |
public void handleMotionNotify(XEvent xev) { |
|
1037 |
} |
|
1038 |
public void handleXCrossingEvent(XEvent xev) { |
|
1039 |
} |
|
1040 |
public void handleConfigureNotifyEvent(XEvent xev) { |
|
1041 |
XConfigureEvent xe = xev.get_xconfigure(); |
|
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
1042 |
if (insLog.isLoggable(PlatformLogger.Level.FINER)) { |
16839
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
1043 |
insLog.finer("Configure, {0}", xe); |
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
1044 |
} |
2 | 1045 |
x = xe.get_x(); |
1046 |
y = xe.get_y(); |
|
1047 |
width = xe.get_width(); |
|
1048 |
height = xe.get_height(); |
|
1049 |
} |
|
1050 |
/** |
|
1051 |
* Checks ButtonRelease released all Mouse buttons |
|
1052 |
*/ |
|
1053 |
static boolean isFullRelease(int buttonState, int button) { |
|
14888
7ad1550e7050
8005018: X11: focus problems with openjdk 1.7.0 under gnome3 when selected keyboard is not the first in keyboard list
neugens
parents:
13652
diff
changeset
|
1054 |
final int buttonsNumber = XToolkit.getNumberOfButtonsForMask(); |
2810
fa49c6a06baf
6799099: All automatic regression tests that create Robot fail on X11
dav
parents:
2471
diff
changeset
|
1055 |
|
fa49c6a06baf
6799099: All automatic regression tests that create Robot fail on X11
dav
parents:
2471
diff
changeset
|
1056 |
if (button < 0 || button > buttonsNumber) { |
1962
6c293d33645b
6315717: Support for mouse with multiple scroll wheels and 4 or more buttons
dav
parents:
439
diff
changeset
|
1057 |
return buttonState == 0; |
6c293d33645b
6315717: Support for mouse with multiple scroll wheels and 4 or more buttons
dav
parents:
439
diff
changeset
|
1058 |
} else { |
14888
7ad1550e7050
8005018: X11: focus problems with openjdk 1.7.0 under gnome3 when selected keyboard is not the first in keyboard list
neugens
parents:
13652
diff
changeset
|
1059 |
return buttonState == XlibUtil.getButtonMask(button); |
2 | 1060 |
} |
1061 |
} |
|
1062 |
||
1063 |
static boolean isGrabbedEvent(XEvent ev, XBaseWindow target) { |
|
1064 |
switch (ev.get_type()) { |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1065 |
case XConstants.ButtonPress: |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1066 |
case XConstants.ButtonRelease: |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1067 |
case XConstants.MotionNotify: |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1068 |
case XConstants.KeyPress: |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1069 |
case XConstants.KeyRelease: |
2 | 1070 |
return true; |
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1071 |
case XConstants.LeaveNotify: |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1072 |
case XConstants.EnterNotify: |
2 | 1073 |
// We shouldn't dispatch this events to the grabbed components (see 6317481) |
1074 |
// But this logic is important if the grabbed component is top-level (see realSync) |
|
1075 |
return (target instanceof XWindowPeer); |
|
1076 |
default: |
|
1077 |
return false; |
|
1078 |
} |
|
1079 |
} |
|
1080 |
/** |
|
1081 |
* Dispatches event to the grab Window or event source window depending |
|
1082 |
* on whether the grab is active and on the event type |
|
1083 |
*/ |
|
1084 |
static void dispatchToWindow(XEvent ev) { |
|
1085 |
XBaseWindow target = XAwtState.getGrabWindow(); |
|
1086 |
if (target == null || !isGrabbedEvent(ev, target)) { |
|
1087 |
target = XToolkit.windowToXWindow(ev.get_xany().get_window()); |
|
1088 |
} |
|
1089 |
if (target != null && target.checkInitialised()) { |
|
1090 |
target.dispatchEvent(ev); |
|
1091 |
} |
|
1092 |
} |
|
1093 |
||
1094 |
public void dispatchEvent(XEvent xev) { |
|
18178
ee71c923891d
8016747: Replace deprecated PlatformLogger isLoggable(int) with isLoggable(Level)
chegar
parents:
16839
diff
changeset
|
1095 |
if (eventLog.isLoggable(PlatformLogger.Level.FINEST)) { |
16839
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
1096 |
eventLog.finest(xev.toString()); |
d0f2e97b7359
8010297: Missing isLoggable() checks in logging code
anthony
parents:
14888
diff
changeset
|
1097 |
} |
2 | 1098 |
int type = xev.get_type(); |
1099 |
||
1100 |
if (isDisposed()) { |
|
1101 |
return; |
|
1102 |
} |
|
1103 |
||
1104 |
switch (type) |
|
1105 |
{ |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1106 |
case XConstants.VisibilityNotify: |
2 | 1107 |
handleVisibilityEvent(xev); |
1108 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1109 |
case XConstants.ClientMessage: |
2 | 1110 |
handleClientMessage(xev); |
1111 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1112 |
case XConstants.Expose : |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1113 |
case XConstants.GraphicsExpose : |
2 | 1114 |
handleExposeEvent(xev); |
1115 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1116 |
case XConstants.ButtonPress: |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1117 |
case XConstants.ButtonRelease: |
2 | 1118 |
handleButtonPressRelease(xev); |
1119 |
break; |
|
1120 |
||
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1121 |
case XConstants.MotionNotify: |
2 | 1122 |
handleMotionNotify(xev); |
1123 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1124 |
case XConstants.KeyPress: |
2 | 1125 |
handleKeyPress(xev); |
1126 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1127 |
case XConstants.KeyRelease: |
2 | 1128 |
handleKeyRelease(xev); |
1129 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1130 |
case XConstants.EnterNotify: |
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1131 |
case XConstants.LeaveNotify: |
2 | 1132 |
handleXCrossingEvent(xev); |
1133 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1134 |
case XConstants.ConfigureNotify: |
2 | 1135 |
handleConfigureNotifyEvent(xev); |
1136 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1137 |
case XConstants.MapNotify: |
2 | 1138 |
handleMapNotifyEvent(xev); |
1139 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1140 |
case XConstants.UnmapNotify: |
2 | 1141 |
handleUnmapNotifyEvent(xev); |
1142 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1143 |
case XConstants.ReparentNotify: |
2 | 1144 |
handleReparentNotifyEvent(xev); |
1145 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1146 |
case XConstants.PropertyNotify: |
2 | 1147 |
handlePropertyNotify(xev); |
1148 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1149 |
case XConstants.DestroyNotify: |
2 | 1150 |
handleDestroyNotify(xev); |
1151 |
break; |
|
439
3488710b02f8
6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents:
2
diff
changeset
|
1152 |
case XConstants.CreateNotify: |
2 | 1153 |
handleCreateNotify(xev); |
1154 |
break; |
|
1155 |
} |
|
1156 |
} |
|
1157 |
protected boolean isEventDisabled(XEvent e) { |
|
1158 |
return false; |
|
1159 |
} |
|
1160 |
||
1161 |
int getX() { |
|
1162 |
return x; |
|
1163 |
} |
|
1164 |
||
1165 |
int getY() { |
|
1166 |
return y; |
|
1167 |
} |
|
1168 |
||
1169 |
int getWidth() { |
|
1170 |
return width; |
|
1171 |
} |
|
1172 |
||
1173 |
int getHeight() { |
|
1174 |
return height; |
|
1175 |
} |
|
1176 |
||
1177 |
void setDisposed(boolean d) { |
|
1178 |
disposed = d; |
|
1179 |
} |
|
1180 |
||
1181 |
boolean isDisposed() { |
|
1182 |
return disposed; |
|
1183 |
} |
|
1184 |
||
1185 |
public int getAbsoluteX() { |
|
1186 |
XBaseWindow pw = getParentWindow(); |
|
1187 |
if (pw != null) { |
|
1188 |
return pw.getAbsoluteX() + getX(); |
|
1189 |
} else { |
|
1190 |
// Overridden for top-levels as their (x,y) is Java (x, y), not native location |
|
1191 |
return getX(); |
|
1192 |
} |
|
1193 |
} |
|
1194 |
||
1195 |
public int getAbsoluteY() { |
|
1196 |
XBaseWindow pw = getParentWindow(); |
|
1197 |
if (pw != null) { |
|
1198 |
return pw.getAbsoluteY() + getY(); |
|
1199 |
} else { |
|
1200 |
return getY(); |
|
1201 |
} |
|
1202 |
} |
|
1203 |
||
1204 |
public XBaseWindow getParentWindow() { |
|
1205 |
return parentWindow; |
|
1206 |
} |
|
1207 |
||
1208 |
public XWindowPeer getToplevelXWindow() { |
|
1209 |
XBaseWindow bw = this; |
|
1210 |
while (bw != null && !(bw instanceof XWindowPeer)) { |
|
1211 |
bw = bw.getParentWindow(); |
|
1212 |
} |
|
1213 |
return (XWindowPeer)bw; |
|
1214 |
} |
|
1215 |
public String toString() { |
|
1216 |
return super.toString() + "(" + Long.toString(getWindow(), 16) + ")"; |
|
1217 |
} |
|
1218 |
||
1219 |
/** |
|
1220 |
* Returns whether the given point is inside of the window. Coordinates are local. |
|
1221 |
*/ |
|
1222 |
public boolean contains(int x, int y) { |
|
1223 |
return x >= 0 && y >= 0 && x < getWidth() && y < getHeight(); |
|
1224 |
} |
|
1225 |
||
1226 |
/** |
|
1227 |
* Returns whether the given point is inside of the window. Coordinates are global. |
|
1228 |
*/ |
|
1229 |
public boolean containsGlobal(int x, int y) { |
|
1230 |
return x >= getAbsoluteX() && y >= getAbsoluteY() && x < (getAbsoluteX()+getWidth()) && y < (getAbsoluteY()+getHeight()); |
|
1231 |
} |
|
1232 |
||
1233 |
} |