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