1 /*
2 * Copyright (c) 2002, 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 sun.awt.X11;
27
28 import java.awt.*;
29 import java.awt.event.*;
30 import java.awt.peer.ComponentPeer;
31 import java.awt.image.ColorModel;
32
33 import java.lang.ref.WeakReference;
34
35 import sun.awt.AWTAccessor.ComponentAccessor;
36 import sun.util.logging.PlatformLogger;
37
38 import sun.awt.*;
39
40 import sun.awt.image.PixelConverter;
41
42 import sun.java2d.SunGraphics2D;
43 import sun.java2d.SurfaceData;
44
45 class XWindow extends XBaseWindow implements X11ComponentPeer {
46 private static PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XWindow");
47 private static PlatformLogger insLog = PlatformLogger.getLogger("sun.awt.X11.insets.XWindow");
48 private static PlatformLogger eventLog = PlatformLogger.getLogger("sun.awt.X11.event.XWindow");
49 private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.awt.X11.focus.XWindow");
50 private static PlatformLogger keyEventLog = PlatformLogger.getLogger("sun.awt.X11.kye.XWindow");
51 /* If a motion comes in while a multi-click is pending,
52 * allow a smudge factor so that moving the mouse by a small
53 * amount does not wipe out the multi-click state variables.
54 */
55 private static final int AWT_MULTICLICK_SMUDGE = 4;
56 // ButtonXXX events stuff
57 static int lastX = 0, lastY = 0;
58 static long lastTime = 0;
59 static long lastButton = 0;
60 static WeakReference<XWindow> lastWindowRef = null;
61 static int clickCount = 0;
62
63 // used to check if we need to re-create surfaceData.
64 int oldWidth = -1;
65 int oldHeight = -1;
66
67 protected PropMwmHints mwm_hints;
68 protected static XAtom wm_protocols;
69 protected static XAtom wm_delete_window;
70 protected static XAtom wm_take_focus;
71
72 private boolean stateChanged; // Indicates whether the value on savedState is valid
73 private int savedState; // Holds last known state of the top-level window
74
75 XWindowAttributesData winAttr;
76
77 protected X11GraphicsConfig graphicsConfig;
78 protected AwtGraphicsConfigData graphicsConfigData;
79
80 private boolean reparented;
81
82 XWindow parent;
83
84 Component target;
85
86 private static int JAWT_LOCK_ERROR=0x00000001;
87 private static int JAWT_LOCK_CLIP_CHANGED=0x00000002;
88 private static int JAWT_LOCK_BOUNDS_CHANGED=0x00000004;
89 private static int JAWT_LOCK_SURFACE_CHANGED=0x00000008;
90 private int drawState = JAWT_LOCK_CLIP_CHANGED |
91 JAWT_LOCK_BOUNDS_CHANGED |
92 JAWT_LOCK_SURFACE_CHANGED;
93
94 public static final String TARGET = "target",
95 REPARENTED = "reparented"; // whether it is reparented by default
96
97 SurfaceData surfaceData;
98
99 XRepaintArea paintArea;
100
101 // fallback default font object
102 private static Font defaultFont;
103
104 static synchronized Font getDefaultFont() {
105 if (null == defaultFont) {
106 defaultFont = new Font(Font.DIALOG, Font.PLAIN, 12);
107 }
108 return defaultFont;
109 }
110
111 /* A bitmask keeps the button's numbers as Button1Mask, Button2Mask, Button3Mask
112 * which are allowed to
113 * generate the CLICK event after the RELEASE has happened.
114 * There are conditions that must be true for that sending CLICK event:
115 * 1) button was initially PRESSED
116 * 2) no movement or drag has happened until RELEASE
117 */
118 private int mouseButtonClickAllowed = 0;
119
120 native int getNativeColor(Color clr, GraphicsConfiguration gc);
121 native void getWMInsets(long window, long left, long top, long right, long bottom, long border);
122 native long getTopWindow(long window, long rootWin);
123 native void getWindowBounds(long window, long x, long y, long width, long height);
124 private static native void initIDs();
125
126 static {
127 initIDs();
128 }
129
130 XWindow(XCreateWindowParams params) {
131 super(params);
132 }
133
134 XWindow() {
135 }
136
137 XWindow(long parentWindow, Rectangle bounds) {
138 super(new XCreateWindowParams(new Object[] {
139 BOUNDS, bounds,
140 PARENT_WINDOW, Long.valueOf(parentWindow)}));
141 }
142
143 XWindow(Component target, long parentWindow, Rectangle bounds) {
144 super(new XCreateWindowParams(new Object[] {
145 BOUNDS, bounds,
146 PARENT_WINDOW, Long.valueOf(parentWindow),
147 TARGET, target}));
148 }
149
150 XWindow(Component target, long parentWindow) {
151 this(target, parentWindow, new Rectangle(target.getBounds()));
152 }
153
154 XWindow(Component target) {
155 this(target, (target.getParent() == null) ? 0 : getParentWindowID(target), new Rectangle(target.getBounds()));
156 }
157
158 XWindow(Object target) {
159 this(null, 0, null);
160 }
161
162 /* This create is used by the XEmbeddedFramePeer since it has to create the window
163 as a child of the netscape window. This netscape window is passed in as wid */
164 XWindow(long parentWindow) {
165 super(new XCreateWindowParams(new Object[] {
166 PARENT_WINDOW, Long.valueOf(parentWindow),
167 REPARENTED, Boolean.TRUE,
168 EMBEDDED, Boolean.TRUE}));
169 }
170
171 protected void initGraphicsConfiguration() {
172 graphicsConfig = (X11GraphicsConfig) target.getGraphicsConfiguration();
173 graphicsConfigData = new AwtGraphicsConfigData(graphicsConfig.getAData());
174 }
175
176 void preInit(XCreateWindowParams params) {
177 super.preInit(params);
178 reparented = Boolean.TRUE.equals(params.get(REPARENTED));
179
180 target = (Component)params.get(TARGET);
181
182 initGraphicsConfiguration();
183
184 AwtGraphicsConfigData gData = getGraphicsConfigurationData();
185 X11GraphicsConfig config = (X11GraphicsConfig) getGraphicsConfiguration();
186 XVisualInfo visInfo = gData.get_awt_visInfo();
187 params.putIfNull(EVENT_MASK, XConstants.KeyPressMask | XConstants.KeyReleaseMask
188 | XConstants.FocusChangeMask | XConstants.ButtonPressMask | XConstants.ButtonReleaseMask
189 | XConstants.EnterWindowMask | XConstants.LeaveWindowMask | XConstants.PointerMotionMask
190 | XConstants.ButtonMotionMask | XConstants.ExposureMask | XConstants.StructureNotifyMask);
191
192 if (target != null) {
193 params.putIfNull(BOUNDS, new Rectangle(target.getBounds()));
194 } else {
195 params.putIfNull(BOUNDS, new Rectangle(0, 0, MIN_SIZE, MIN_SIZE));
196 }
197 params.putIfNull(BORDER_PIXEL, Long.valueOf(0));
198 getColorModel(); // fix 4948833: this call forces the color map to be initialized
199 params.putIfNull(COLORMAP, gData.get_awt_cmap());
200 params.putIfNull(DEPTH, gData.get_awt_depth());
201 params.putIfNull(VISUAL_CLASS, Integer.valueOf(XConstants.InputOutput));
202 params.putIfNull(VISUAL, visInfo.get_visual());
203 params.putIfNull(VALUE_MASK, XConstants.CWBorderPixel | XConstants.CWEventMask | XConstants.CWColormap);
204 Long parentWindow = (Long)params.get(PARENT_WINDOW);
205 if (parentWindow == null || parentWindow.longValue() == 0) {
206 XToolkit.awtLock();
207 try {
208 int screen = visInfo.get_screen();
209 if (screen != -1) {
210 params.add(PARENT_WINDOW, XlibWrapper.RootWindow(XToolkit.getDisplay(), screen));
211 } else {
212 params.add(PARENT_WINDOW, XToolkit.getDefaultRootWindow());
213 }
214 } finally {
215 XToolkit.awtUnlock();
216 }
217 }
218
219 paintArea = new XRepaintArea();
220 if (target != null) {
221 this.parent = getParentXWindowObject(target.getParent());
222 }
223
224 params.putIfNull(BACKING_STORE, XToolkit.getBackingStoreType());
225
226 XToolkit.awtLock();
227 try {
228 if (wm_protocols == null) {
229 wm_protocols = XAtom.get("WM_PROTOCOLS");
230 wm_delete_window = XAtom.get("WM_DELETE_WINDOW");
231 wm_take_focus = XAtom.get("WM_TAKE_FOCUS");
232 }
233 }
234 finally {
235 XToolkit.awtUnlock();
236 }
237 winAttr = new XWindowAttributesData();
238 savedState = XUtilConstants.WithdrawnState;
239 }
240
241 void postInit(XCreateWindowParams params) {
242 super.postInit(params);
243
244 setWMClass(getWMClass());
245
246 surfaceData = graphicsConfig.createSurfaceData(this);
247 Color c;
248 if (target != null && (c = target.getBackground()) != null) {
249 // We need a version of setBackground that does not call repaint !!
250 // and one that does not get overridden. The problem is that in postInit
251 // we call setBackground and we don't have all the stuff initialized to
252 // do a full paint for most peers. So we cannot call setBackground in postInit.
253 // instead we need to call xSetBackground.
254 xSetBackground(c);
255 }
256 }
257
258 public GraphicsConfiguration getGraphicsConfiguration() {
259 if (graphicsConfig == null) {
260 initGraphicsConfiguration();
261 }
262 return graphicsConfig;
263 }
264
265 public AwtGraphicsConfigData getGraphicsConfigurationData() {
266 if (graphicsConfigData == null) {
267 initGraphicsConfiguration();
268 }
269 return graphicsConfigData;
270 }
271
272 protected String[] getWMClass() {
273 return new String[] {XToolkit.getAWTAppClassName(),
274 XToolkit.getAWTAppClassName()};
275 }
276
277 void setReparented(boolean newValue) {
278 reparented = newValue;
279 }
280
281 boolean isReparented() {
282 return reparented;
283 }
284
285 static long getParentWindowID(Component target) {
286
287 Component temp = target.getParent();
288 final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
289 ComponentPeer peer = acc.getPeer(temp);
290 while (!(peer instanceof XWindow))
291 {
292 temp = temp.getParent();
293 peer = acc.getPeer(temp);
294 }
295
296 if (peer != null && peer instanceof XWindow)
297 return ((XWindow)peer).getContentWindow();
298 else return 0;
299 }
300
301
302 static XWindow getParentXWindowObject(Component target) {
303 if (target == null) return null;
304 Component temp = target.getParent();
305 if (temp == null) return null;
306 final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
307 ComponentPeer peer = acc.getPeer(temp);
308 if (peer == null) return null;
309 while ((peer != null) && !(peer instanceof XWindow))
310 {
311 temp = temp.getParent();
312 peer = acc.getPeer(temp);
313 }
314 if (peer != null && peer instanceof XWindow)
315 return (XWindow) peer;
316 else return null;
317 }
318
319
320 boolean isParentOf(XWindow win) {
321 if (!(target instanceof Container) || win == null || win.getTarget() == null) {
322 return false;
323 }
324 Container parent = AWTAccessor.getComponentAccessor().getParent(win.target);
325 while (parent != null && parent != target) {
326 parent = AWTAccessor.getComponentAccessor().getParent(parent);
327 }
328 return (parent == target);
329 }
330
331 public Object getTarget() {
332 return target;
333 }
334 public Component getEventSource() {
335 return target;
336 }
337
338 public ColorModel getColorModel(int transparency) {
339 return graphicsConfig.getColorModel (transparency);
340 }
341
342 public ColorModel getColorModel() {
343 if (graphicsConfig != null) {
344 return graphicsConfig.getColorModel ();
345 }
346 else {
347 return XToolkit.getStaticColorModel();
348 }
349 }
350
351 Graphics getGraphics(SurfaceData surfData, Color afore, Color aback, Font afont) {
352 if (surfData == null) return null;
353
354 Component target = this.target;
355
356 /* Fix for bug 4746122. Color and Font shouldn't be null */
357 Color bgColor = aback;
358 if (bgColor == null) {
359 bgColor = SystemColor.window;
360 }
361 Color fgColor = afore;
362 if (fgColor == null) {
363 fgColor = SystemColor.windowText;
364 }
365 Font font = afont;
366 if (font == null) {
367 font = XWindow.getDefaultFont();
368 }
369 return new SunGraphics2D(surfData, fgColor, bgColor, font);
370 }
371
372 public Graphics getGraphics() {
373 return getGraphics(surfaceData,
374 target.getForeground(),
375 target.getBackground(),
376 target.getFont());
377 }
378
379 @SuppressWarnings("deprecation")
380 public FontMetrics getFontMetrics(Font font) {
381 return Toolkit.getDefaultToolkit().getFontMetrics(font);
382 }
383
384 public Rectangle getTargetBounds() {
385 return target.getBounds();
386 }
387
388 /**
389 * Returns true if the event has been handled and should not be
390 * posted to Java.
391 */
392 boolean prePostEvent(AWTEvent e) {
393 return false;
394 }
395
396 static void sendEvent(final AWTEvent e) {
397 // The uses of this method imply that the incoming event is system-generated
398 SunToolkit.setSystemGenerated(e);
399 PeerEvent pe = new PeerEvent(Toolkit.getDefaultToolkit(), new Runnable() {
400 public void run() {
401 AWTAccessor.getAWTEventAccessor().setPosted(e);
402 ((Component)e.getSource()).dispatchEvent(e);
403 }
404 }, PeerEvent.ULTIMATE_PRIORITY_EVENT);
405 if (focusLog.isLoggable(PlatformLogger.Level.FINER) && (e instanceof FocusEvent)) {
406 focusLog.finer("Sending " + e);
407 }
408 XToolkit.postEvent(XToolkit.targetToAppContext(e.getSource()), pe);
409 }
410
411
412 /*
413 * Post an event to the event queue.
414 */
415 // NOTE: This method may be called by privileged threads.
416 // DO NOT INVOKE CLIENT CODE ON THIS THREAD!
417 void postEvent(AWTEvent event) {
418 XToolkit.postEvent(XToolkit.targetToAppContext(event.getSource()), event);
419 }
420
421 static void postEventStatic(AWTEvent event) {
422 XToolkit.postEvent(XToolkit.targetToAppContext(event.getSource()), event);
423 }
424
425 public void postEventToEventQueue(final AWTEvent event) {
426 //fix for 6239938 : Choice drop-down does not disappear when it loses focus, on XToolkit
427 if (!prePostEvent(event)) {
428 //event hasn't been handled and must be posted to EventQueue
429 postEvent(event);
430 }
431 }
432
433 // overriden in XCanvasPeer
434 protected boolean doEraseBackground() {
435 return true;
436 }
437
438 // We need a version of setBackground that does not call repaint !!
439 // and one that does not get overridden. The problem is that in postInit
440 // we call setBackground and we don't have all the stuff initialized to
441 // do a full paint for most peers. So we cannot call setBackground in postInit.
442 public final void xSetBackground(Color c) {
443 XToolkit.awtLock();
444 try {
445 winBackground(c);
446 // fix for 6558510: handle sun.awt.noerasebackground flag,
447 // see doEraseBackground() and preInit() methods in XCanvasPeer
448 if (!doEraseBackground()) {
449 return;
450 }
451 // 6304250: XAWT: Items in choice show a blue border on OpenGL + Solaris10 when background color is set
452 // Note: When OGL is enabled, surfaceData.pixelFor() will not
453 // return a pixel value appropriate for passing to
454 // XSetWindowBackground(). Therefore, we will use the ColorModel
455 // for this component in order to calculate a pixel value from
456 // the given RGB value.
457 ColorModel cm = getColorModel();
458 int pixel = PixelConverter.instance.rgbToPixel(c.getRGB(), cm);
459 XlibWrapper.XSetWindowBackground(XToolkit.getDisplay(), getContentWindow(), pixel);
460 XlibWrapper.XClearWindow(XToolkit.getDisplay(), getContentWindow());
461 }
462 finally {
463 XToolkit.awtUnlock();
464 }
465 }
466
467 public void setBackground(Color c) {
468 xSetBackground(c);
469 }
470
471 Color backgroundColor;
472 void winBackground(Color c) {
473 backgroundColor = c;
474 }
475
476 public Color getWinBackground() {
477 Color c = null;
478
479 if (backgroundColor != null) {
480 c = backgroundColor;
481 } else if (parent != null) {
482 c = parent.getWinBackground();
483 }
484
485 if (c instanceof SystemColor) {
486 c = new Color(c.getRGB());
487 }
488
489 return c;
490 }
491
492 public boolean isEmbedded() {
493 return embedded;
494 }
495
496 public final void repaint(int x, int y, int width, int height) {
497 if (!isVisible() || getWidth() == 0 || getHeight() == 0) {
498 return;
499 }
500 Graphics g = getGraphics();
501 if (g != null) {
502 try {
503 g.setClip(x, y, width, height);
504 if (SunToolkit.isDispatchThreadForAppContext(getTarget())) {
505 paint(g); // The native and target will be painted in place.
506 } else {
507 paintPeer(g);
508 postPaintEvent(target, x, y, width, height);
509 }
510 } finally {
511 g.dispose();
512 }
513 }
514 }
515
516 void repaint() {
517 repaint(0, 0, getWidth(), getHeight());
518 }
519
520 public void paint(final Graphics g) {
521 // paint peer
522 paintPeer(g);
523 }
524
525 void paintPeer(final Graphics g) {
526 }
527 //used by Peers to avoid flickering withing paint()
528 protected void flush(){
529 XToolkit.awtLock();
530 try {
531 XlibWrapper.XFlush(XToolkit.getDisplay());
532 } finally {
533 XToolkit.awtUnlock();
534 }
535 }
536
537 public void popup(int x, int y, int width, int height) {
538 // TBD: grab the pointer
539 xSetBounds(x, y, width, height);
540 }
541
542 public void handleExposeEvent(XEvent xev) {
543 super.handleExposeEvent(xev);
544 XExposeEvent xe = xev.get_xexpose();
545 if (isEventDisabled(xev)) {
546 return;
547 }
548
549 int x = scaleDown(xe.get_x());
550 int y = scaleDown(xe.get_y());
551 int w = scaleDown(xe.get_width());
552 int h = scaleDown(xe.get_height());
553
554 Component target = getEventSource();
555 ComponentAccessor compAccessor = AWTAccessor.getComponentAccessor();
556
557 if (!compAccessor.getIgnoreRepaint(target)
558 && compAccessor.getWidth(target) != 0
559 && compAccessor.getHeight(target) != 0)
560 {
561 postPaintEvent(target, x, y, w, h);
562 }
563 }
564
565 public void postPaintEvent(Component target, int x, int y, int w, int h) {
566 PaintEvent event = PaintEventDispatcher.getPaintEventDispatcher().
567 createPaintEvent(target, x, y, w, h);
568 if (event != null) {
569 postEventToEventQueue(event);
570 }
571 }
572
573 static int getModifiers(int state, int button, int keyCode) {
574 return getModifiers(state, button, keyCode, false);
575 }
576
577 static int getWheelModifiers(int state, int button) {
578 return getModifiers(state, button, 0, true);
579 }
580
581 private static int getModifiers(int state, int button, int keyCode, boolean isWheelMouse) {
582 int modifiers = 0;
583
584 if (((state & XConstants.ShiftMask) != 0) ^ (keyCode == KeyEvent.VK_SHIFT)) {
585 modifiers |= InputEvent.SHIFT_DOWN_MASK;
586 }
587 if (((state & XConstants.ControlMask) != 0) ^ (keyCode == KeyEvent.VK_CONTROL)) {
588 modifiers |= InputEvent.CTRL_DOWN_MASK;
589 }
590 if (((state & XToolkit.metaMask) != 0) ^ (keyCode == KeyEvent.VK_META)) {
591 modifiers |= InputEvent.META_DOWN_MASK;
592 }
593 if (((state & XToolkit.altMask) != 0) ^ (keyCode == KeyEvent.VK_ALT)) {
594 modifiers |= InputEvent.ALT_DOWN_MASK;
595 }
596 if (((state & XToolkit.modeSwitchMask) != 0) ^ (keyCode == KeyEvent.VK_ALT_GRAPH)) {
597 modifiers |= InputEvent.ALT_GRAPH_DOWN_MASK;
598 }
599 //InputEvent.BUTTON_DOWN_MASK array is starting from BUTTON1_DOWN_MASK on index == 0.
600 // button currently reflects a real button number and starts from 1. (except NOBUTTON which is zero )
601
602 /* this is an attempt to refactor button IDs in : MouseEvent, InputEvent, XlibWrapper and XWindow.*/
603
604 //reflects a button number similar to MouseEvent.BUTTON1, 2, 3 etc.
605 for (int i = 0; i < XConstants.buttons.length; i ++){
606 //modifier should be added if :
607 // 1) current button is now still in PRESSED state (means that user just pressed mouse but not released yet) or
608 // 2) if Xsystem reports that "state" represents that button was just released. This only happens on RELEASE with 1,2,3 buttons.
609 // ONLY one of these conditions should be TRUE to add that modifier.
610 if (((state & XlibUtil.getButtonMask(i + 1)) != 0) != (button == XConstants.buttons[i])){
611 //exclude wheel buttons from adding their numbers as modifiers
612 if (!isWheelMouse || !isWheel(XConstants.buttons[i])) {
613 modifiers |= InputEvent.getMaskForButton(i+1);
614 }
615 }
616 }
617 return modifiers;
618 }
619
620 static boolean isWheel(int button) {
621 // 4 and 5 buttons are usually considered assigned to a first wheel
622 return button == XConstants.buttons[3] || button == XConstants.buttons[4];
623 }
624 @SuppressWarnings("deprecation")
625 static int getXModifiers(AWTKeyStroke stroke) {
626 int mods = stroke.getModifiers();
627 int res = 0;
628 if ((mods & (InputEvent.SHIFT_DOWN_MASK | InputEvent.SHIFT_MASK)) != 0) {
629 res |= XConstants.ShiftMask;
630 }
631 if ((mods & (InputEvent.CTRL_DOWN_MASK | InputEvent.CTRL_MASK)) != 0) {
632 res |= XConstants.ControlMask;
633 }
634 if ((mods & (InputEvent.ALT_DOWN_MASK | InputEvent.ALT_MASK)) != 0) {
635 res |= XToolkit.altMask;
636 }
637 if ((mods & (InputEvent.META_DOWN_MASK | InputEvent.META_MASK)) != 0) {
638 res |= XToolkit.metaMask;
639 }
640 if ((mods & (InputEvent.ALT_GRAPH_DOWN_MASK | InputEvent.ALT_GRAPH_MASK)) != 0) {
641 res |= XToolkit.modeSwitchMask;
642 }
643 return res;
644 }
645
646 static int getMouseMovementSmudge() {
647 //TODO: It's possible to read corresponding settings
648 return AWT_MULTICLICK_SMUDGE;
649 }
650
651 public void handleButtonPressRelease(XEvent xev) {
652 super.handleButtonPressRelease(xev);
653 XButtonEvent xbe = xev.get_xbutton();
654 if (isEventDisabled(xev)) {
655 return;
656 }
657 if (eventLog.isLoggable(PlatformLogger.Level.FINE)) {
658 eventLog.fine(xbe.toString());
659 }
660 long when;
661 int modifiers;
662 boolean popupTrigger = false;
663 int button=0;
664 int lbutton = xbe.get_button();
665 /*
666 * Ignore the buttons above 20 due to the bit limit for
667 * InputEvent.BUTTON_DOWN_MASK.
668 * One more bit is reserved for FIRST_HIGH_BIT.
669 */
670 if (lbutton > SunToolkit.MAX_BUTTONS_SUPPORTED) {
671 return;
672 }
673 int type = xev.get_type();
674 when = xbe.get_time();
675 long jWhen = XToolkit.nowMillisUTC_offset(when);
676
677 int x = scaleDown(xbe.get_x());
678 int y = scaleDown(xbe.get_y());
679 if (xev.get_xany().get_window() != window) {
680 Point localXY = toLocal(scaleDown(xbe.get_x_root()),
681 scaleDown(xbe.get_y_root()));
682 x = localXY.x;
683 y = localXY.y;
684 }
685
686 if (type == XConstants.ButtonPress) {
687 //Allow this mouse button to generate CLICK event on next ButtonRelease
688 mouseButtonClickAllowed |= XlibUtil.getButtonMask(lbutton);
689 XWindow lastWindow = (lastWindowRef != null) ? (lastWindowRef.get()):(null);
690 /*
691 multiclick checking
692 */
693 if (eventLog.isLoggable(PlatformLogger.Level.FINEST)) {
694 eventLog.finest("lastWindow = " + lastWindow + ", lastButton "
695 + lastButton + ", lastTime " + lastTime + ", multiClickTime "
696 + XToolkit.getMultiClickTime());
697 }
698 if (lastWindow == this && lastButton == lbutton && (when - lastTime) < XToolkit.getMultiClickTime()) {
699 clickCount++;
700 } else {
701 clickCount = 1;
702 lastWindowRef = new WeakReference<>(this);
703 lastButton = lbutton;
704 lastX = x;
705 lastY = y;
706 }
707 lastTime = when;
708
709
710 /*
711 Check for popup trigger !!
712 */
713 popupTrigger = (lbutton == 3);
714 }
715
716 button = XConstants.buttons[lbutton - 1];
717
718 // mapping extra buttons to numbers starting from 4.
719 if ((button > XConstants.buttons[4]) && (!Toolkit.getDefaultToolkit().areExtraMouseButtonsEnabled())){
720 return;
721 }
722
723 if (button > XConstants.buttons[4]){
724 button -= 2;
725 }
726
727 if (!isWheel(lbutton)) {
728 modifiers = getModifiers(xbe.get_state(), button, 0);
729 MouseEvent me = new MouseEvent(getEventSource(),
730 type == XConstants.ButtonPress ? MouseEvent.MOUSE_PRESSED : MouseEvent.MOUSE_RELEASED,
731 jWhen,modifiers, x, y,
732 scaleDown(xbe.get_x_root()),
733 scaleDown(xbe.get_y_root()),
734 clickCount,popupTrigger,button);
735
736 postEventToEventQueue(me);
737
738 if ((type == XConstants.ButtonRelease) &&
739 ((mouseButtonClickAllowed & XlibUtil.getButtonMask(lbutton)) != 0) ) // No up-button in the drag-state
740 {
741 postEventToEventQueue(me = new MouseEvent(getEventSource(),
742 MouseEvent.MOUSE_CLICKED,
743 jWhen,
744 modifiers,
745 x, y,
746 scaleDown(xbe.get_x_root()),
747 scaleDown(xbe.get_y_root()),
748 clickCount,
749 false, button));
750 }
751
752 }
753 else {
754 modifiers = getWheelModifiers(xbe.get_state(), button);
755 if (xev.get_type() == XConstants.ButtonPress) {
756 MouseWheelEvent mwe = new MouseWheelEvent(getEventSource(),MouseEvent.MOUSE_WHEEL, jWhen,
757 modifiers,
758 x, y,
759 scaleDown(xbe.get_x_root()),
760 scaleDown(xbe.get_y_root()),
761 1,false,MouseWheelEvent.WHEEL_UNIT_SCROLL,
762 3,button==4 ? -1 : 1);
763 postEventToEventQueue(mwe);
764 }
765 }
766
767 /* Update the state variable AFTER the CLICKED event post. */
768 if (type == XConstants.ButtonRelease) {
769 /* Exclude this mouse button from allowed list.*/
770 mouseButtonClickAllowed &= ~ XlibUtil.getButtonMask(lbutton);
771 }
772 }
773
774 public void handleMotionNotify(XEvent xev) {
775 super.handleMotionNotify(xev);
776 XMotionEvent xme = xev.get_xmotion();
777 if (isEventDisabled(xev)) {
778 return;
779 }
780
781 int mouseKeyState = 0; //(xme.get_state() & (XConstants.buttonsMask[0] | XConstants.buttonsMask[1] | XConstants.buttonsMask[2]));
782
783 //this doesn't work for extra buttons because Xsystem is sending state==0 for every extra button event.
784 // we can't correct it in MouseEvent class as we done it with modifiers, because exact type (DRAG|MOVE)
785 // should be passed from XWindow.
786 final int buttonsNumber = XToolkit.getNumberOfButtonsForMask();
787
788 for (int i = 0; i < buttonsNumber; i++){
789 // TODO : here is the bug in WM: extra buttons doesn't have state!=0 as they should.
790 if ((i != 4) && (i != 5)) {
791 mouseKeyState = mouseKeyState | (xme.get_state() & XlibUtil.getButtonMask(i + 1));
792 }
793 }
794
795 boolean isDragging = (mouseKeyState != 0);
796 int mouseEventType = 0;
797
798 if (isDragging) {
799 mouseEventType = MouseEvent.MOUSE_DRAGGED;
800 } else {
801 mouseEventType = MouseEvent.MOUSE_MOVED;
802 }
803
804 /*
805 Fix for 6176814 . Add multiclick checking.
806 */
807 int x = scaleDown(xme.get_x());
808 int y = scaleDown(xme.get_y());
809 XWindow lastWindow = (lastWindowRef != null) ? (lastWindowRef.get()):(null);
810
811 if (!(lastWindow == this &&
812 (xme.get_time() - lastTime) < XToolkit.getMultiClickTime() &&
813 (Math.abs(lastX - x) < AWT_MULTICLICK_SMUDGE &&
814 Math.abs(lastY - y) < AWT_MULTICLICK_SMUDGE))) {
815 clickCount = 0;
816 lastWindowRef = null;
817 mouseButtonClickAllowed = 0;
818 lastTime = 0;
819 lastX = 0;
820 lastY = 0;
821 }
822
823 long jWhen = XToolkit.nowMillisUTC_offset(xme.get_time());
824 int modifiers = getModifiers(xme.get_state(), 0, 0);
825 boolean popupTrigger = false;
826
827 Component source = getEventSource();
828
829 if (xme.get_window() != window) {
830 Point localXY = toLocal(scaleDown(xme.get_x_root()),
831 scaleDown(xme.get_y_root()));
832 x = localXY.x;
833 y = localXY.y;
834 }
835 /* Fix for 5039416.
836 * According to canvas.c we shouldn't post any MouseEvent if mouse is dragging and clickCount!=0.
837 */
838 if ((isDragging && clickCount == 0) || !isDragging) {
839 MouseEvent mme = new MouseEvent(source, mouseEventType, jWhen,
840 modifiers, x, y,
841 scaleDown(xme.get_x_root()),
842 scaleDown(xme.get_y_root()),
843 clickCount, popupTrigger, MouseEvent.NOBUTTON);
844 postEventToEventQueue(mme);
845 }
846 }
847
848
849 // REMIND: need to implement looking for disabled events
850 private native boolean x11inputMethodLookupString(long event,
851 long[] keysymArray);
852
853 private native boolean haveCurrentX11InputMethodInstance();
854
855 private boolean mouseAboveMe;
856
857 public boolean isMouseAbove() {
858 synchronized (getStateLock()) {
859 return mouseAboveMe;
860 }
861 }
862 protected void setMouseAbove(boolean above) {
863 synchronized (getStateLock()) {
864 mouseAboveMe = above;
865 }
866 }
867
868 protected void enterNotify(long window) {
869 if (window == getWindow()) {
870 setMouseAbove(true);
871 }
872 }
873 protected void leaveNotify(long window) {
874 if (window == getWindow()) {
875 setMouseAbove(false);
876 }
877 }
878
879 public void handleXCrossingEvent(XEvent xev) {
880 super.handleXCrossingEvent(xev);
881 XCrossingEvent xce = xev.get_xcrossing();
882
883 if (eventLog.isLoggable(PlatformLogger.Level.FINEST)) {
884 eventLog.finest(xce.toString());
885 }
886
887 if (xce.get_type() == XConstants.EnterNotify) {
888 enterNotify(xce.get_window());
889 } else { // LeaveNotify:
890 leaveNotify(xce.get_window());
891 }
892
893 // Skip event If it was caused by a grab
894 // This is needed because on displays with focus-follows-mouse on MousePress X system generates
895 // two XCrossing events with mode != NormalNotify. First of them notifies that the mouse has left
896 // current component. Second one notifies that it has entered into the same component.
897 // This looks like the window under the mouse has actually changed and Java handle these events
898 // accordingly. This leads to impossibility to make a double click on Component (6404708)
899 XWindowPeer toplevel = getToplevelXWindow();
900 if (toplevel != null && !toplevel.isModalBlocked()){
901 if (xce.get_mode() != XConstants.NotifyNormal) {
902 // 6404708 : need update cursor in accordance with skipping Leave/EnterNotify event
903 // whereas it doesn't need to handled further.
904 if (xce.get_type() == XConstants.EnterNotify) {
905 XAwtState.setComponentMouseEntered(getEventSource());
906 XGlobalCursorManager.nativeUpdateCursor(getEventSource());
907 } else { // LeaveNotify:
908 XAwtState.setComponentMouseEntered(null);
909 }
910 return;
911 }
912 }
913 // X sends XCrossing to all hierarchy so if the edge of child equals to
914 // ancestor and mouse enters child, the ancestor will get an event too.
915 // From java point the event is bogus as ancestor is obscured, so if
916 // the child can get java event itself, we skip it on ancestor.
917 long childWnd = xce.get_subwindow();
918 if (childWnd != XConstants.None) {
919 XBaseWindow child = XToolkit.windowToXWindow(childWnd);
920 if (child != null && child instanceof XWindow &&
921 !child.isEventDisabled(xev))
922 {
923 return;
924 }
925 }
926
927 // Remember old component with mouse to have the opportunity to send it MOUSE_EXITED.
928 final Component compWithMouse = XAwtState.getComponentMouseEntered();
929 if (toplevel != null) {
930 if(!toplevel.isModalBlocked()){
931 if (xce.get_type() == XConstants.EnterNotify) {
932 // Change XAwtState's component mouse entered to the up-to-date one before requesting
933 // to update the cursor since XAwtState.getComponentMouseEntered() is used when the
934 // cursor is updated (in XGlobalCursorManager.findHeavyweightUnderCursor()).
935 XAwtState.setComponentMouseEntered(getEventSource());
936 XGlobalCursorManager.nativeUpdateCursor(getEventSource());
937 } else { // LeaveNotify:
938 XAwtState.setComponentMouseEntered(null);
939 }
940 } else {
941 ((XComponentPeer) AWTAccessor.getComponentAccessor().getPeer(target))
942 .pSetCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
943 }
944 }
945
946 if (isEventDisabled(xev)) {
947 return;
948 }
949
950 long jWhen = XToolkit.nowMillisUTC_offset(xce.get_time());
951 int modifiers = getModifiers(xce.get_state(),0,0);
952 int clickCount = 0;
953 boolean popupTrigger = false;
954 int x = scaleDown(xce.get_x());
955 int y = scaleDown(xce.get_y());
956 if (xce.get_window() != window) {
957 Point localXY = toLocal(scaleDown(xce.get_x_root()),
958 scaleDown(xce.get_y_root()));
959 x = localXY.x;
960 y = localXY.y;
961 }
962
963 // This code tracks boundary crossing and ensures MOUSE_ENTER/EXIT
964 // are posted in alternate pairs
965 if (compWithMouse != null) {
966 MouseEvent me = new MouseEvent(compWithMouse, MouseEvent.MOUSE_EXITED,
967 jWhen, modifiers,
968 scaleDown(xce.get_x()),
969 scaleDown(xce.get_y()),
970 scaleDown(xce.get_x_root()),
971 scaleDown(xce.get_y_root()),
972 clickCount, popupTrigger,
973 MouseEvent.NOBUTTON);
974 postEventToEventQueue(me);
975 eventLog.finest("Clearing last window ref");
976 lastWindowRef = null;
977 }
978 if (xce.get_type() == XConstants.EnterNotify) {
979 MouseEvent me = new MouseEvent(getEventSource(), MouseEvent.MOUSE_ENTERED,
980 jWhen, modifiers,
981 scaleDown(xce.get_x()),
982 scaleDown(xce.get_y()),
983 scaleDown(xce.get_x_root()),
984 scaleDown(xce.get_y_root()),
985 clickCount, popupTrigger,
986 MouseEvent.NOBUTTON);
987 postEventToEventQueue(me);
988 }
989 }
990
991 public void doLayout(int x, int y, int width, int height) {}
992
993 public void handleConfigureNotifyEvent(XEvent xev) {
994 Rectangle oldBounds = getBounds();
995
996 super.handleConfigureNotifyEvent(xev);
997 if (insLog.isLoggable(PlatformLogger.Level.FINER)) {
998 insLog.finer("Configure, {0}, event disabled: {1}",
999 xev.get_xconfigure(), isEventDisabled(xev));
1000 }
1001 if (isEventDisabled(xev)) {
1002 return;
1003 }
1004
1005 // if ( Check if it's a resize, a move, or a stacking order change )
1006 // {
1007 Rectangle bounds = getBounds();
1008 if (!bounds.getSize().equals(oldBounds.getSize())) {
1009 postEventToEventQueue(new ComponentEvent(getEventSource(), ComponentEvent.COMPONENT_RESIZED));
1010 }
1011 if (!bounds.getLocation().equals(oldBounds.getLocation())) {
1012 postEventToEventQueue(new ComponentEvent(getEventSource(), ComponentEvent.COMPONENT_MOVED));
1013 }
1014 // }
1015 }
1016
1017 public void handleMapNotifyEvent(XEvent xev) {
1018 super.handleMapNotifyEvent(xev);
1019 if (log.isLoggable(PlatformLogger.Level.FINE)) {
1020 log.fine("Mapped {0}", this);
1021 }
1022 if (isEventDisabled(xev)) {
1023 return;
1024 }
1025 ComponentEvent ce;
1026
1027 ce = new ComponentEvent(getEventSource(), ComponentEvent.COMPONENT_SHOWN);
1028 postEventToEventQueue(ce);
1029 }
1030
1031 public void handleUnmapNotifyEvent(XEvent xev) {
1032 super.handleUnmapNotifyEvent(xev);
1033 if (isEventDisabled(xev)) {
1034 return;
1035 }
1036 ComponentEvent ce;
1037
1038 ce = new ComponentEvent(target, ComponentEvent.COMPONENT_HIDDEN);
1039 postEventToEventQueue(ce);
1040 }
1041
1042 private void dumpKeysymArray(XKeyEvent ev) {
1043 if (keyEventLog.isLoggable(PlatformLogger.Level.FINE)) {
1044 keyEventLog.fine(" "+Long.toHexString(XlibWrapper.XKeycodeToKeysym(XToolkit.getDisplay(), ev.get_keycode(), 0))+
1045 "\n "+Long.toHexString(XlibWrapper.XKeycodeToKeysym(XToolkit.getDisplay(), ev.get_keycode(), 1))+
1046 "\n "+Long.toHexString(XlibWrapper.XKeycodeToKeysym(XToolkit.getDisplay(), ev.get_keycode(), 2))+
1047 "\n "+Long.toHexString(XlibWrapper.XKeycodeToKeysym(XToolkit.getDisplay(), ev.get_keycode(), 3)));
1048 }
1049 }
1050 /**
1051 Return unicode character or 0 if no correspondent character found.
1052 Parameter is a keysym basically from keysymdef.h
1053 XXX: how about vendor keys? Is there some with Unicode value and not in the list?
1054 */
1055 int keysymToUnicode( long keysym, int state ) {
1056 return XKeysym.convertKeysym( keysym, state );
1057 }
1058 int keyEventType2Id( int xEventType ) {
1059 return xEventType == XConstants.KeyPress ? java.awt.event.KeyEvent.KEY_PRESSED :
1060 xEventType == XConstants.KeyRelease ? java.awt.event.KeyEvent.KEY_RELEASED : 0;
1061 }
1062 private static long xkeycodeToKeysym(XKeyEvent ev) {
1063 return XKeysym.getKeysym( ev );
1064 }
1065 private long xkeycodeToPrimaryKeysym(XKeyEvent ev) {
1066 return XKeysym.xkeycode2primary_keysym( ev );
1067 }
1068 private static int primaryUnicode2JavaKeycode(int uni) {
1069 return (uni > 0? sun.awt.ExtendedKeyCodes.getExtendedKeyCodeForChar(uni) : 0);
1070 //return (uni > 0? uni + 0x01000000 : 0);
1071 }
1072 void logIncomingKeyEvent(XKeyEvent ev) {
1073 if (keyEventLog.isLoggable(PlatformLogger.Level.FINE)) {
1074 keyEventLog.fine("--XWindow.java:handleKeyEvent:"+ev);
1075 }
1076 dumpKeysymArray(ev);
1077 if (keyEventLog.isLoggable(PlatformLogger.Level.FINE)) {
1078 keyEventLog.fine("XXXXXXXXXXXXXX javakeycode will be most probably:0x"+ Integer.toHexString(XKeysym.getJavaKeycodeOnly(ev)));
1079 }
1080 }
1081 public void handleKeyPress(XEvent xev) {
1082 super.handleKeyPress(xev);
1083 XKeyEvent ev = xev.get_xkey();
1084 if (eventLog.isLoggable(PlatformLogger.Level.FINE)) {
1085 eventLog.fine(ev.toString());
1086 }
1087 if (isEventDisabled(xev)) {
1088 return;
1089 }
1090 handleKeyPress(ev);
1091 }
1092 // called directly from this package, unlike handleKeyRelease.
1093 // un-final it if you need to override it in a subclass.
1094 final void handleKeyPress(XKeyEvent ev) {
1095 long keysym[] = new long[2];
1096 int unicodeKey = 0;
1097 keysym[0] = XConstants.NoSymbol;
1098
1099 if (keyEventLog.isLoggable(PlatformLogger.Level.FINE)) {
1100 logIncomingKeyEvent( ev );
1101 }
1102 if ( //TODO check if there's an active input method instance
1103 // without calling a native method. Is it necessary though?
1104 haveCurrentX11InputMethodInstance()) {
1105 if (x11inputMethodLookupString(ev.pData, keysym)) {
1106 if (keyEventLog.isLoggable(PlatformLogger.Level.FINE)) {
1107 keyEventLog.fine("--XWindow.java XIM did process event; return; dec keysym processed:"+(keysym[0])+
1108 "; hex keysym processed:"+Long.toHexString(keysym[0])
1109 );
1110 }
1111 return;
1112 }else {
1113 unicodeKey = keysymToUnicode( keysym[0], ev.get_state() );
1114 if (keyEventLog.isLoggable(PlatformLogger.Level.FINE)) {
1115 keyEventLog.fine("--XWindow.java XIM did NOT process event, hex keysym:"+Long.toHexString(keysym[0])+"\n"+
1116 " unicode key:"+Integer.toHexString(unicodeKey));
1117 }
1118 }
1119 }else {
1120 // No input method instance found. For example, there's a Java Input Method.
1121 // Produce do-it-yourself keysym and perhaps unicode character.
1122 keysym[0] = xkeycodeToKeysym(ev);
1123 unicodeKey = keysymToUnicode( keysym[0], ev.get_state() );
1124 if (keyEventLog.isLoggable(PlatformLogger.Level.FINE)) {
1125 keyEventLog.fine("--XWindow.java XIM is absent; hex keysym:"+Long.toHexString(keysym[0])+"\n"+
1126 " unicode key:"+Integer.toHexString(unicodeKey));
1127 }
1128 }
1129 // Keysym should be converted to Unicode, if possible and necessary,
1130 // and Java KeyEvent keycode should be calculated.
1131 // For press we should post pressed & typed Java events.
1132 //
1133 // Press event might be not processed to this time because
1134 // (1) either XIM could not handle it or
1135 // (2) it was Latin 1:1 mapping.
1136 //
1137 // Preserve modifiers to get Java key code for dead keys
1138 boolean isDeadKey = isDeadKey(keysym[0]);
1139 XKeysym.Keysym2JavaKeycode jkc = isDeadKey ? XKeysym.getJavaKeycode(keysym[0])
1140 : XKeysym.getJavaKeycode(ev);
1141 if( jkc == null ) {
1142 jkc = new XKeysym.Keysym2JavaKeycode(java.awt.event.KeyEvent.VK_UNDEFINED, java.awt.event.KeyEvent.KEY_LOCATION_UNKNOWN);
1143 }
1144
1145 // Take the first keysym from a keysym array associated with the XKeyevent
1146 // and convert it to Unicode. Then, even if a Java keycode for the keystroke
1147 // is undefined, we still have a guess of what has been engraved on a keytop.
1148 int unicodeFromPrimaryKeysym = keysymToUnicode( xkeycodeToPrimaryKeysym(ev) ,0);
1149
1150 if (keyEventLog.isLoggable(PlatformLogger.Level.FINE)) {
1151 keyEventLog.fine(">>>Fire Event:"+
1152 (ev.get_type() == XConstants.KeyPress ? "KEY_PRESSED; " : "KEY_RELEASED; ")+
1153 "jkeycode:decimal="+jkc.getJavaKeycode()+
1154 ", hex=0x"+Integer.toHexString(jkc.getJavaKeycode())+"; "+
1155 " legacy jkeycode: decimal="+XKeysym.getLegacyJavaKeycodeOnly(ev)+
1156 ", hex=0x"+Integer.toHexString(XKeysym.getLegacyJavaKeycodeOnly(ev))+"; "
1157 );
1158 }
1159
1160 int jkeyToReturn = XKeysym.getLegacyJavaKeycodeOnly(ev); // someway backward compatible
1161 int jkeyExtended = jkc.getJavaKeycode() == java.awt.event.KeyEvent.VK_UNDEFINED ?
1162 primaryUnicode2JavaKeycode( unicodeFromPrimaryKeysym ) :
1163 jkc.getJavaKeycode();
1164 postKeyEvent( java.awt.event.KeyEvent.KEY_PRESSED,
1165 ev.get_time(),
1166 isDeadKey ? jkeyExtended : jkeyToReturn,
1167 (unicodeKey == 0 ? java.awt.event.KeyEvent.CHAR_UNDEFINED : unicodeKey),
1168 jkc.getKeyLocation(),
1169 ev.get_state(),ev.getPData(), XKeyEvent.getSize(), (long)(ev.get_keycode()),
1170 unicodeFromPrimaryKeysym,
1171 jkeyExtended);
1172
1173
1174 if (unicodeKey > 0 && !isDeadKey) {
1175 if (keyEventLog.isLoggable(PlatformLogger.Level.FINE)) {
1176 keyEventLog.fine("fire _TYPED on "+unicodeKey);
1177 }
1178 postKeyEvent( java.awt.event.KeyEvent.KEY_TYPED,
1179 ev.get_time(),
1180 java.awt.event.KeyEvent.VK_UNDEFINED,
1181 unicodeKey,
1182 java.awt.event.KeyEvent.KEY_LOCATION_UNKNOWN,
1183 ev.get_state(),ev.getPData(), XKeyEvent.getSize(), (long)0,
1184 unicodeFromPrimaryKeysym,
1185 java.awt.event.KeyEvent.VK_UNDEFINED);
1186
1187 }
1188
1189
1190 }
1191
1192 public void handleKeyRelease(XEvent xev) {
1193 super.handleKeyRelease(xev);
1194 XKeyEvent ev = xev.get_xkey();
1195 if (eventLog.isLoggable(PlatformLogger.Level.FINE)) {
1196 eventLog.fine(ev.toString());
1197 }
1198 if (isEventDisabled(xev)) {
1199 return;
1200 }
1201 handleKeyRelease(ev);
1202 }
1203 // un-private it if you need to call it from elsewhere
1204 private void handleKeyRelease(XKeyEvent ev) {
1205 int unicodeKey = 0;
1206
1207 if (keyEventLog.isLoggable(PlatformLogger.Level.FINE)) {
1208 logIncomingKeyEvent( ev );
1209 }
1210 // Keysym should be converted to Unicode, if possible and necessary,
1211 // and Java KeyEvent keycode should be calculated.
1212 // For release we should post released event.
1213 //
1214 // Preserve modifiers to get Java key code for dead keys
1215 long keysym = xkeycodeToKeysym(ev);
1216 boolean isDeadKey = isDeadKey(keysym);
1217 XKeysym.Keysym2JavaKeycode jkc = isDeadKey ? XKeysym.getJavaKeycode(keysym)
1218 : XKeysym.getJavaKeycode(ev);
1219 if( jkc == null ) {
1220 jkc = new XKeysym.Keysym2JavaKeycode(java.awt.event.KeyEvent.VK_UNDEFINED, java.awt.event.KeyEvent.KEY_LOCATION_UNKNOWN);
1221 }
1222 if (keyEventLog.isLoggable(PlatformLogger.Level.FINE)) {
1223 keyEventLog.fine(">>>Fire Event:"+
1224 (ev.get_type() == XConstants.KeyPress ? "KEY_PRESSED; " : "KEY_RELEASED; ")+
1225 "jkeycode:decimal="+jkc.getJavaKeycode()+
1226 ", hex=0x"+Integer.toHexString(jkc.getJavaKeycode())+"; "+
1227 " legacy jkeycode: decimal="+XKeysym.getLegacyJavaKeycodeOnly(ev)+
1228 ", hex=0x"+Integer.toHexString(XKeysym.getLegacyJavaKeycodeOnly(ev))+"; "
1229 );
1230 }
1231 // We obtain keysym from IM and derive unicodeKey from it for KeyPress only.
1232 // We used to cache that value and retrieve it on KeyRelease,
1233 // but in case for example of a dead key+vowel pair, a vowel after a deadkey
1234 // might never be cached before.
1235 // Also, switching between keyboard layouts, we might cache a wrong letter.
1236 // That's why we use the same procedure as if there was no IM instance: do-it-yourself unicode.
1237 unicodeKey = keysymToUnicode( xkeycodeToKeysym(ev), ev.get_state() );
1238
1239 // Take a first keysym from a keysym array associated with the XKeyevent
1240 // and convert it to Unicode. Then, even if Java keycode for the keystroke
1241 // is undefined, we still will have a guess of what was engraved on a keytop.
1242 int unicodeFromPrimaryKeysym = keysymToUnicode( xkeycodeToPrimaryKeysym(ev) ,0);
1243
1244 int jkeyToReturn = XKeysym.getLegacyJavaKeycodeOnly(ev); // someway backward compatible
1245 int jkeyExtended = jkc.getJavaKeycode() == java.awt.event.KeyEvent.VK_UNDEFINED ?
1246 primaryUnicode2JavaKeycode( unicodeFromPrimaryKeysym ) :
1247 jkc.getJavaKeycode();
1248 postKeyEvent( java.awt.event.KeyEvent.KEY_RELEASED,
1249 ev.get_time(),
1250 isDeadKey ? jkeyExtended : jkeyToReturn,
1251 (unicodeKey == 0 ? java.awt.event.KeyEvent.CHAR_UNDEFINED : unicodeKey),
1252 jkc.getKeyLocation(),
1253 ev.get_state(),ev.getPData(), XKeyEvent.getSize(), (long)(ev.get_keycode()),
1254 unicodeFromPrimaryKeysym,
1255 jkeyExtended);
1256
1257
1258 }
1259
1260
1261 private boolean isDeadKey(long keysym){
1262 return XKeySymConstants.XK_dead_grave <= keysym && keysym <= XKeySymConstants.XK_dead_semivoiced_sound;
1263 }
1264
1265 /*
1266 * XmNiconic and Map/UnmapNotify (that XmNiconic relies on) are
1267 * unreliable, since mapping changes can happen for a virtual desktop
1268 * switch or MacOS style shading that became quite popular under X as
1269 * well. Yes, it probably should not be this way, as it violates
1270 * ICCCM, but reality is that quite a lot of window managers abuse
1271 * mapping state.
1272 */
1273 int getWMState() {
1274 if (stateChanged) {
1275 stateChanged = false;
1276 WindowPropertyGetter getter =
1277 new WindowPropertyGetter(window, XWM.XA_WM_STATE, 0, 1, false,
1278 XWM.XA_WM_STATE);
1279 try {
1280 int status = getter.execute();
1281 if (status != XConstants.Success || getter.getData() == 0) {
1282 return savedState = XUtilConstants.WithdrawnState;
1283 }
1284
1285 if (getter.getActualType() != XWM.XA_WM_STATE.getAtom() && getter.getActualFormat() != 32) {
1286 return savedState = XUtilConstants.WithdrawnState;
1287 }
1288 savedState = (int)Native.getCard32(getter.getData());
1289 } finally {
1290 getter.dispose();
1291 }
1292 }
1293 return savedState;
1294 }
1295
1296 /**
1297 * Override this methods to get notifications when top-level window state changes. The state is
1298 * meant in terms of ICCCM: WithdrawnState, IconicState, NormalState
1299 */
1300 protected void stateChanged(long time, int oldState, int newState) {
1301 }
1302
1303 @Override
1304 public void handlePropertyNotify(XEvent xev) {
1305 super.handlePropertyNotify(xev);
1306 XPropertyEvent ev = xev.get_xproperty();
1307 if (ev.get_atom() == XWM.XA_WM_STATE.getAtom()) {
1308 // State has changed, invalidate saved value
1309 stateChanged = true;
1310 stateChanged(ev.get_time(), savedState, getWMState());
1311 }
1312 }
1313
1314 public void reshape(Rectangle bounds) {
1315 reshape(bounds.x, bounds.y, bounds.width, bounds.height);
1316 }
1317
1318 public void reshape(int x, int y, int width, int height) {
1319 if (width <= 0) {
1320 width = 1;
1321 }
1322 if (height <= 0) {
1323 height = 1;
1324 }
1325 this.x = x;
1326 this.y = y;
1327 this.width = width;
1328 this.height = height;
1329 xSetBounds(x, y, width, height);
1330 // Fixed 6322593, 6304251, 6315137:
1331 // XWindow's SurfaceData should be invalidated and recreated as part
1332 // of the process of resizing the window
1333 // see the evaluation of the bug 6304251 for more information
1334 validateSurface();
1335 layout();
1336 }
1337
1338 public void layout() {}
1339
1340 boolean isShowing() {
1341 return visible;
1342 }
1343
1344 boolean isResizable() {
1345 return true;
1346 }
1347
1348 boolean isLocationByPlatform() {
1349 return false;
1350 }
1351
1352 void updateSizeHints() {
1353 updateSizeHints(x, y, width, height);
1354 }
1355
1356 void updateSizeHints(int x, int y, int width, int height) {
1357 long flags = XUtilConstants.PSize | (isLocationByPlatform() ? 0 : (XUtilConstants.PPosition | XUtilConstants.USPosition));
1358 if (!isResizable()) {
1359 if (log.isLoggable(PlatformLogger.Level.FINER)) {
1360 log.finer("Window {0} is not resizable", this);
1361 }
1362 flags |= XUtilConstants.PMinSize | XUtilConstants.PMaxSize;
1363 } else {
1364 if (log.isLoggable(PlatformLogger.Level.FINER)) {
1365 log.finer("Window {0} is resizable", this);
1366 }
1367 }
1368 setSizeHints(flags, x, y, width, height);
1369 }
1370
1371 void updateSizeHints(int x, int y) {
1372 long flags = isLocationByPlatform() ? 0 : (XUtilConstants.PPosition | XUtilConstants.USPosition);
1373 if (!isResizable()) {
1374 if (log.isLoggable(PlatformLogger.Level.FINER)) {
1375 log.finer("Window {0} is not resizable", this);
1376 }
1377 flags |= XUtilConstants.PMinSize | XUtilConstants.PMaxSize | XUtilConstants.PSize;
1378 } else {
1379 if (log.isLoggable(PlatformLogger.Level.FINER)) {
1380 log.finer("Window {0} is resizable", this);
1381 }
1382 }
1383 setSizeHints(flags, x, y, width, height);
1384 }
1385
1386 void validateSurface() {
1387 if ((width != oldWidth) || (height != oldHeight)) {
1388 doValidateSurface();
1389
1390 oldWidth = width;
1391 oldHeight = height;
1392 }
1393 }
1394
1395 final void doValidateSurface() {
1396 SurfaceData oldData = surfaceData;
1397 if (oldData != null) {
1398 surfaceData = graphicsConfig.createSurfaceData(this);
1399 oldData.invalidate();
1400 }
1401 }
1402
1403 public SurfaceData getSurfaceData() {
1404 return surfaceData;
1405 }
1406
1407 public void dispose() {
1408 SurfaceData oldData = surfaceData;
1409 surfaceData = null;
1410 if (oldData != null) {
1411 oldData.invalidate();
1412 }
1413 XToolkit.targetDisposedPeer(target, this);
1414 destroy();
1415 }
1416
1417 public Point getLocationOnScreen() {
1418 synchronized (target.getTreeLock()) {
1419 Component comp = target;
1420
1421 while (comp != null && !(comp instanceof Window)) {
1422 comp = AWTAccessor.getComponentAccessor().getParent(comp);
1423 }
1424
1425 // applets, embedded, etc - translate directly
1426 // XXX: override in subclass?
1427 if (comp == null || comp instanceof sun.awt.EmbeddedFrame) {
1428 return toGlobal(0, 0);
1429 }
1430
1431 XToolkit.awtLock();
1432 try {
1433 Object wpeer = XToolkit.targetToPeer(comp);
1434 if (wpeer == null
1435 || !(wpeer instanceof XDecoratedPeer)
1436 || ((XDecoratedPeer)wpeer).configure_seen)
1437 {
1438 return toGlobal(0, 0);
1439 }
1440
1441 // wpeer is an XDecoratedPeer not yet fully adopted by WM
1442 Point pt = toOtherWindow(getContentWindow(),
1443 ((XDecoratedPeer)wpeer).getContentWindow(),
1444 0, 0);
1445
1446 if (pt == null) {
1447 pt = new Point(((XBaseWindow)wpeer).getAbsoluteX(), ((XBaseWindow)wpeer).getAbsoluteY());
1448 }
1449 pt.x += comp.getX();
1450 pt.y += comp.getY();
1451 return pt;
1452 } finally {
1453 XToolkit.awtUnlock();
1454 }
1455 }
1456 }
1457
1458
1459 static void setBData(KeyEvent e, byte[] data) {
1460 AWTAccessor.getAWTEventAccessor().setBData(e, data);
1461 }
1462
1463 public void postKeyEvent(int id, long when, int keyCode, int keyChar,
1464 int keyLocation, int state, long event, int eventSize, long rawCode,
1465 int unicodeFromPrimaryKeysym, int extendedKeyCode)
1466
1467 {
1468 long jWhen = XToolkit.nowMillisUTC_offset(when);
1469 int modifiers = getModifiers(state, 0, keyCode);
1470
1471 KeyEvent ke = new KeyEvent(getEventSource(), id, jWhen,
1472 modifiers, keyCode, (char)keyChar, keyLocation);
1473 if (event != 0) {
1474 byte[] data = Native.toBytes(event, eventSize);
1475 setBData(ke, data);
1476 }
1477
1478 AWTAccessor.KeyEventAccessor kea = AWTAccessor.getKeyEventAccessor();
1479 kea.setRawCode(ke, rawCode);
1480 kea.setPrimaryLevelUnicode(ke, (long)unicodeFromPrimaryKeysym);
1481 kea.setExtendedKeyCode(ke, (long)extendedKeyCode);
1482 postEventToEventQueue(ke);
1483 }
1484
1485 static native int getAWTKeyCodeForKeySym(int keysym);
1486 static native int getKeySymForAWTKeyCode(int keycode);
1487
1488 /* These two methods are actually applicable to toplevel windows only.
1489 * However, the functionality is required by both the XWindowPeer and
1490 * XWarningWindow, both of which have the XWindow as a common ancestor.
1491 * See XWM.setMotifDecor() for details.
1492 */
1493 public PropMwmHints getMWMHints() {
1494 if (mwm_hints == null) {
1495 mwm_hints = new PropMwmHints();
1496 if (!XWM.XA_MWM_HINTS.getAtomData(getWindow(), mwm_hints.pData, MWMConstants.PROP_MWM_HINTS_ELEMENTS)) {
1497 mwm_hints.zero();
1498 }
1499 }
1500 return mwm_hints;
1501 }
1502
1503 public void setMWMHints(PropMwmHints hints) {
1504 mwm_hints = hints;
1505 if (hints != null) {
1506 XWM.XA_MWM_HINTS.setAtomData(getWindow(), mwm_hints.pData, MWMConstants.PROP_MWM_HINTS_ELEMENTS);
1507 }
1508 }
1509
1510 protected final void initWMProtocols() {
1511 wm_protocols.setAtomListProperty(this, getWMProtocols());
1512 }
1513
1514 /**
1515 * Returns list of protocols which should be installed on this window.
1516 * Descendants can override this method to add class-specific protocols
1517 */
1518 protected XAtomList getWMProtocols() {
1519 // No protocols on simple window
1520 return new XAtomList();
1521 }
1522
1523 /**
1524 * Indicates if the window is currently in the FSEM.
1525 * Synchronization: state lock.
1526 */
1527 private boolean fullScreenExclusiveModeState = false;
1528
1529 // Implementation of the X11ComponentPeer
1530 @Override
1531 public void setFullScreenExclusiveModeState(boolean state) {
1532 synchronized (getStateLock()) {
1533 fullScreenExclusiveModeState = state;
1534 }
1535 }
1536
1537 public final boolean isFullScreenExclusiveMode() {
1538 synchronized (getStateLock()) {
1539 return fullScreenExclusiveModeState;
1540 }
1541 }
1542
1543 @Override
1544 protected int getScale() {
1545 return graphicsConfig.getScale();
1546 }
1547
1548 @Override
1549 protected int scaleUp(int x) {
1550 return graphicsConfig.scaleUp(x);
1551 }
1552
1553 @Override
1554 protected int scaleDown(int x) {
1555 return graphicsConfig.scaleDown(x);
1556 }
1557 }