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