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