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