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