1 /*
   2  * Copyright (c) 2003, 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 sun.awt.*;
  30 import java.util.*;
  31 import sun.util.logging.PlatformLogger;
  32 
  33 public class XBaseWindow {
  34     private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XBaseWindow");
  35     private static final PlatformLogger insLog = PlatformLogger.getLogger("sun.awt.X11.insets.XBaseWindow");
  36     private static final PlatformLogger eventLog = PlatformLogger.getLogger("sun.awt.X11.event.XBaseWindow");
  37     private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.awt.X11.focus.XBaseWindow");
  38     private static final PlatformLogger grabLog = PlatformLogger.getLogger("sun.awt.X11.grab.XBaseWindow");
  39 
  40     public static final String
  41         PARENT_WINDOW = "parent window", // parent window, Long
  42         BOUNDS = "bounds", // bounds of the window, Rectangle
  43         OVERRIDE_REDIRECT = "overrideRedirect", // override_redirect setting, Boolean
  44         EVENT_MASK = "event mask", // event mask, Integer
  45         VALUE_MASK = "value mask", // value mask, Long
  46         BORDER_PIXEL = "border pixel", // border pixel value, Integer
  47         COLORMAP = "color map", // color map, Long
  48         DEPTH = "visual depth", // depth, Integer
  49         VISUAL_CLASS = "visual class", // visual class, Integer
  50         VISUAL = "visual", // visual, Long
  51         EMBEDDED = "embedded", // is embedded?, Boolean
  52         DELAYED = "delayed", // is creation delayed?, Boolean
  53         PARENT = "parent", // parent peer
  54         BACKGROUND_PIXMAP = "pixmap", // background pixmap
  55         VISIBLE = "visible", // whether it is visible by default
  56         SAVE_UNDER = "save under", // save content under this window
  57         BACKING_STORE = "backing store", // enables double buffering
  58         BIT_GRAVITY = "bit gravity"; // copy old content on geometry change
  59     private XCreateWindowParams delayedParams;
  60 
  61     Set<Long> children = new HashSet<Long>();
  62     long window;
  63     boolean visible;
  64     boolean mapped;
  65     boolean embedded;
  66     Rectangle maxBounds;
  67     volatile XBaseWindow parentWindow;
  68 
  69     private boolean disposed;
  70 
  71     private long screen;
  72     private XSizeHints hints;
  73     private XWMHints wmHints;
  74 
  75     static final int MIN_SIZE = 1;
  76     static final int DEF_LOCATION = 1;
  77 
  78     private static XAtom wm_client_leader;
  79 
  80     static enum InitialiseState {
  81         INITIALISING,
  82         NOT_INITIALISED,
  83         INITIALISED,
  84         FAILED_INITIALISATION
  85     };
  86 
  87     private InitialiseState initialising;
  88 
  89     int x;
  90     int y;
  91     int width;
  92     int height;
  93 
  94     void awtLock() {
  95         XToolkit.awtLock();
  96     }
  97 
  98     void awtUnlock() {
  99         XToolkit.awtUnlock();
 100     }
 101 
 102     void awtLockNotifyAll() {
 103         XToolkit.awtLockNotifyAll();
 104     }
 105 
 106     void awtLockWait() throws InterruptedException {
 107         XToolkit.awtLockWait();
 108     }
 109 
 110     // To prevent errors from overriding obsolete methods
 111     protected final void init(long parentWindow, Rectangle bounds) {}
 112     protected final void preInit() {}
 113     protected final void postInit() {}
 114 
 115     // internal lock for synchronizing state changes and paint calls, initialized in preInit.
 116     // the order with other locks: AWTLock -> stateLock
 117     static class StateLock extends Object { }
 118     protected StateLock state_lock;
 119 
 120     /**
 121      * Called for delayed inits during construction
 122      */
 123     void instantPreInit(XCreateWindowParams params) {
 124         state_lock = new StateLock();
 125         initialising = InitialiseState.NOT_INITIALISED;
 126     }
 127 
 128     /**
 129      * Called before window creation, descendants should override to initialize the data,
 130      * initialize params.
 131      */
 132     void preInit(XCreateWindowParams params) {
 133         state_lock = new StateLock();
 134         initialising = InitialiseState.NOT_INITIALISED;
 135         embedded = Boolean.TRUE.equals(params.get(EMBEDDED));
 136         visible = Boolean.TRUE.equals(params.get(VISIBLE));
 137 
 138         Object parent = params.get(PARENT);
 139         if (parent instanceof XBaseWindow) {
 140             parentWindow = (XBaseWindow)parent;
 141         } else {
 142             Long parentWindowID = (Long)params.get(PARENT_WINDOW);
 143             if (parentWindowID != null) {
 144                 parentWindow = XToolkit.windowToXWindow(parentWindowID);
 145             }
 146         }
 147 
 148         Long eventMask = (Long)params.get(EVENT_MASK);
 149         if (eventMask != null) {
 150             long mask = eventMask.longValue();
 151             mask |= XConstants.SubstructureNotifyMask;
 152             params.put(EVENT_MASK, mask);
 153         }
 154 
 155         screen = -1;
 156     }
 157 
 158     /**
 159      * Called after window creation, descendants should override to initialize Window
 160      * with class-specific values and perform post-initialization actions.
 161      */
 162     void postInit(XCreateWindowParams params) {
 163         if (log.isLoggable(PlatformLogger.Level.FINE)) {
 164             log.fine("WM name is " + getWMName());
 165         }
 166         updateWMName();
 167 
 168         // Set WM_CLIENT_LEADER property
 169         initClientLeader();
 170     }
 171 
 172     /**
 173      * Creates window using parameters <code>params</code>
 174      * If params contain flag DELAYED doesn't do anything.
 175      * Note: Descendants can call this method to create the window
 176      * at the time different to instance construction.
 177      */
 178     protected final void init(XCreateWindowParams params) {
 179         awtLock();
 180         initialising = InitialiseState.INITIALISING;
 181         awtUnlock();
 182 
 183         try {
 184             if (!Boolean.TRUE.equals(params.get(DELAYED))) {
 185                 preInit(params);
 186                 create(params);
 187                 postInit(params);
 188             } else {
 189                 instantPreInit(params);
 190                 delayedParams = params;
 191             }
 192             awtLock();
 193             initialising = InitialiseState.INITIALISED;
 194             awtLockNotifyAll();
 195             awtUnlock();
 196         } catch (RuntimeException re) {
 197             awtLock();
 198             initialising = InitialiseState.FAILED_INITIALISATION;
 199             awtLockNotifyAll();
 200             awtUnlock();
 201             throw re;
 202         } catch (Throwable t) {
 203             log.warning("Exception during peer initialization", t);
 204             awtLock();
 205             initialising = InitialiseState.FAILED_INITIALISATION;
 206             awtLockNotifyAll();
 207             awtUnlock();
 208         }
 209     }
 210 
 211     public boolean checkInitialised() {
 212         awtLock();
 213         try {
 214             switch (initialising) {
 215               case INITIALISED:
 216                   return true;
 217               case INITIALISING:
 218                   try {
 219                       while (initialising != InitialiseState.INITIALISED) {
 220                           awtLockWait();
 221                       }
 222                   } catch (InterruptedException ie) {
 223                       return false;
 224                   }
 225                   return true;
 226               case NOT_INITIALISED:
 227               case FAILED_INITIALISATION:
 228                   return false;
 229               default:
 230                   return false;
 231             }
 232         } finally {
 233             awtUnlock();
 234         }
 235     }
 236 
 237     /*
 238      * Creates an invisible InputOnly window without an associated Component.
 239      */
 240     XBaseWindow() {
 241         this(new XCreateWindowParams());
 242     }
 243 
 244     /**
 245      * Creates normal child window
 246      */
 247     XBaseWindow(long parentWindow, Rectangle bounds) {
 248         this(new XCreateWindowParams(new Object[] {
 249             BOUNDS, bounds,
 250             PARENT_WINDOW, Long.valueOf(parentWindow)}));
 251     }
 252 
 253     /**
 254      * Creates top-level window
 255      */
 256     XBaseWindow(Rectangle bounds) {
 257         this(new XCreateWindowParams(new Object[] {
 258             BOUNDS, bounds
 259         }));
 260     }
 261 
 262     public XBaseWindow (XCreateWindowParams params) {
 263         init(params);
 264     }
 265 
 266     /* This create is used by the XEmbeddedFramePeer since it has to create the window
 267        as a child of the netscape window. This netscape window is passed in as wid */
 268     XBaseWindow(long parentWindow) {
 269         this(new XCreateWindowParams(new Object[] {
 270             PARENT_WINDOW, Long.valueOf(parentWindow),
 271             EMBEDDED, Boolean.TRUE
 272         }));
 273     }
 274 
 275     /**
 276      * Verifies that all required parameters are set. If not, sets them to default values.
 277      * Verifies values of critical parameters, adjust their values when needed.
 278      * @throws IllegalArgumentException if params is null
 279      */
 280     protected void checkParams(XCreateWindowParams params) {
 281         if (params == null) {
 282             throw new IllegalArgumentException("Window creation parameters are null");
 283         }
 284         params.putIfNull(PARENT_WINDOW, Long.valueOf(XToolkit.getDefaultRootWindow()));
 285         params.putIfNull(BOUNDS, new Rectangle(DEF_LOCATION, DEF_LOCATION, MIN_SIZE, MIN_SIZE));
 286         params.putIfNull(DEPTH, Integer.valueOf((int)XConstants.CopyFromParent));
 287         params.putIfNull(VISUAL, Long.valueOf(XConstants.CopyFromParent));
 288         params.putIfNull(VISUAL_CLASS, Integer.valueOf(XConstants.InputOnly));
 289         params.putIfNull(VALUE_MASK, Long.valueOf(XConstants.CWEventMask));
 290         Rectangle bounds = (Rectangle)params.get(BOUNDS);
 291         bounds.width = Math.max(MIN_SIZE, bounds.width);
 292         bounds.height = Math.max(MIN_SIZE, bounds.height);
 293 
 294         Long eventMaskObj = (Long)params.get(EVENT_MASK);
 295         long eventMask = eventMaskObj != null ? eventMaskObj.longValue() : 0;
 296         // We use our own synthetic grab see XAwtState.getGrabWindow()
 297         // (see X vol. 1, 8.3.3.2)
 298         eventMask |= XConstants.PropertyChangeMask | XConstants.OwnerGrabButtonMask;
 299         params.put(EVENT_MASK, Long.valueOf(eventMask));
 300     }
 301 
 302     /**
 303      * Returns scale factor of the window. It is used to convert native
 304      * coordinates to local and vice verse.
 305      */
 306     protected int getScale() {
 307         return 1;
 308     }
 309 
 310     protected int scaleUp(int x) {
 311         return x;
 312     }
 313 
 314     protected int scaleDown(int x) {
 315         return x;
 316     }
 317 
 318     /**
 319      * Creates window with parameters specified by <code>params</code>
 320      * @see #init
 321      */
 322     private final void create(XCreateWindowParams params) {
 323         XToolkit.awtLock();
 324         try {
 325             XSetWindowAttributes xattr = new XSetWindowAttributes();
 326             try {
 327                 checkParams(params);
 328 
 329                 long value_mask = ((Long)params.get(VALUE_MASK)).longValue();
 330 
 331                 Long eventMask = (Long)params.get(EVENT_MASK);
 332                 xattr.set_event_mask(eventMask.longValue());
 333                 value_mask |= XConstants.CWEventMask;
 334 
 335                 Long border_pixel = (Long)params.get(BORDER_PIXEL);
 336                 if (border_pixel != null) {
 337                     xattr.set_border_pixel(border_pixel.longValue());
 338                     value_mask |= XConstants.CWBorderPixel;
 339                 }
 340 
 341                 Long colormap = (Long)params.get(COLORMAP);
 342                 if (colormap != null) {
 343                     xattr.set_colormap(colormap.longValue());
 344                     value_mask |= XConstants.CWColormap;
 345                 }
 346                 Long background_pixmap = (Long)params.get(BACKGROUND_PIXMAP);
 347                 if (background_pixmap != null) {
 348                     xattr.set_background_pixmap(background_pixmap.longValue());
 349                     value_mask |= XConstants.CWBackPixmap;
 350                 }
 351 
 352                 Long parentWindow = (Long)params.get(PARENT_WINDOW);
 353                 Rectangle bounds = (Rectangle)params.get(BOUNDS);
 354                 Integer depth = (Integer)params.get(DEPTH);
 355                 Integer visual_class = (Integer)params.get(VISUAL_CLASS);
 356                 Long visual = (Long)params.get(VISUAL);
 357                 Boolean overrideRedirect = (Boolean)params.get(OVERRIDE_REDIRECT);
 358                 if (overrideRedirect != null) {
 359                     xattr.set_override_redirect(overrideRedirect.booleanValue());
 360                     value_mask |= XConstants.CWOverrideRedirect;
 361                 }
 362 
 363                 Boolean saveUnder = (Boolean)params.get(SAVE_UNDER);
 364                 if (saveUnder != null) {
 365                     xattr.set_save_under(saveUnder.booleanValue());
 366                     value_mask |= XConstants.CWSaveUnder;
 367                 }
 368 
 369                 Integer backingStore = (Integer)params.get(BACKING_STORE);
 370                 if (backingStore != null) {
 371                     xattr.set_backing_store(backingStore.intValue());
 372                     value_mask |= XConstants.CWBackingStore;
 373                 }
 374 
 375                 Integer bitGravity = (Integer)params.get(BIT_GRAVITY);
 376                 if (bitGravity != null) {
 377                     xattr.set_bit_gravity(bitGravity.intValue());
 378                     value_mask |= XConstants.CWBitGravity;
 379                 }
 380 
 381                 if (log.isLoggable(PlatformLogger.Level.FINE)) {
 382                     log.fine("Creating window for " + this + " with the following attributes: \n" + params);
 383                 }
 384                 window = XlibWrapper.XCreateWindow(XToolkit.getDisplay(),
 385                                                    parentWindow.longValue(),
 386                                                    scaleUp(bounds.x),
 387                                                    scaleUp(bounds.y),
 388                                                    scaleUp(bounds.width),
 389                                                    scaleUp(bounds.height),
 390                                                    0, // border
 391                                                    depth.intValue(), // depth
 392                                                    visual_class.intValue(), // class
 393                                                    visual.longValue(), // visual
 394                                                    value_mask,  // value mask
 395                                                    xattr.pData); // attributes
 396 
 397                 if (window == 0) {
 398                     throw new IllegalStateException("Couldn't create window because of wrong parameters. Run with NOISY_AWT to see details");
 399                 }
 400                 XToolkit.addToWinMap(window, this);
 401             } finally {
 402                 xattr.dispose();
 403             }
 404         } finally {
 405             XToolkit.awtUnlock();
 406         }
 407     }
 408 
 409     public XCreateWindowParams getDelayedParams() {
 410         return delayedParams;
 411     }
 412 
 413     protected String getWMName() {
 414         return XToolkit.getCorrectXIDString(getClass().getName());
 415     }
 416 
 417     protected void initClientLeader() {
 418         XToolkit.awtLock();
 419         try {
 420             if (wm_client_leader == null) {
 421                 wm_client_leader = XAtom.get("WM_CLIENT_LEADER");
 422             }
 423             wm_client_leader.setWindowProperty(this, getXAWTRootWindow());
 424         } finally {
 425             XToolkit.awtUnlock();
 426         }
 427     }
 428 
 429     static XRootWindow getXAWTRootWindow() {
 430         return XRootWindow.getInstance();
 431     }
 432 
 433     void destroy() {
 434         XToolkit.awtLock();
 435         try {
 436             if (hints != null) {
 437                 XlibWrapper.XFree(hints.pData);
 438                 hints = null;
 439             }
 440             XToolkit.removeFromWinMap(getWindow(), this);
 441             XlibWrapper.XDestroyWindow(XToolkit.getDisplay(), getWindow());
 442             if (XPropertyCache.isCachingSupported()) {
 443                 XPropertyCache.clearCache(window);
 444             }
 445             window = -1;
 446             if( !isDisposed() ) {
 447                 setDisposed( true );
 448             }
 449 
 450             XAwtState.getGrabWindow(); // Magic - getGrabWindow clear state if grabbing window is disposed of.
 451         } finally {
 452             XToolkit.awtUnlock();
 453         }
 454     }
 455 
 456     void flush() {
 457         XToolkit.awtLock();
 458         try {
 459             XlibWrapper.XFlush(XToolkit.getDisplay());
 460         } finally {
 461             XToolkit.awtUnlock();
 462         }
 463     }
 464 
 465     /**
 466      * Helper function to set W
 467      */
 468     public final void setWMHints(XWMHints hints) {
 469         XToolkit.awtLock();
 470         try {
 471             XlibWrapper.XSetWMHints(XToolkit.getDisplay(), getWindow(), hints.pData);
 472         } finally {
 473             XToolkit.awtUnlock();
 474         }
 475     }
 476 
 477     public XWMHints getWMHints() {
 478         if (wmHints == null) {
 479             wmHints = new XWMHints(XlibWrapper.XAllocWMHints());
 480 //              XlibWrapper.XGetWMHints(XToolkit.getDisplay(),
 481 //                                      getWindow(),
 482 //                                      wmHints.pData);
 483         }
 484         return wmHints;
 485     }
 486 
 487 
 488     /*
 489      * Call this method under AWTLock.
 490      * The lock should be acquired untill all operations with XSizeHints are completed.
 491      */
 492     public XSizeHints getHints() {
 493         if (hints == null) {
 494             long p_hints = XlibWrapper.XAllocSizeHints();
 495             hints = new XSizeHints(p_hints);
 496 //              XlibWrapper.XGetWMNormalHints(XToolkit.getDisplay(), getWindow(), p_hints, XlibWrapper.larg1);
 497             // TODO: Shouldn't we listen for WM updates on this property?
 498         }
 499         return hints;
 500     }
 501 
 502     public void setSizeHints(long flags, int x, int y, int width, int height) {
 503         if (insLog.isLoggable(PlatformLogger.Level.FINER)) {
 504             insLog.finer("Setting hints, flags " + XlibWrapper.hintsToString(flags));
 505         }
 506         XToolkit.awtLock();
 507         try {
 508             XSizeHints hints = getHints();
 509             // Note: if PPosition is not set in flags this means that
 510             // we want to reset PPosition in hints.  This is necessary
 511             // for locationByPlatform functionality
 512             if ((flags & XUtilConstants.PPosition) != 0) {
 513                 hints.set_x(scaleUp(x));
 514                 hints.set_y(scaleUp(y));
 515             }
 516             if ((flags & XUtilConstants.PSize) != 0) {
 517                 hints.set_width(scaleUp(width));
 518                 hints.set_height(scaleUp(height));
 519             } else if ((hints.get_flags() & XUtilConstants.PSize) != 0) {
 520                 flags |= XUtilConstants.PSize;
 521             }
 522             if ((flags & XUtilConstants.PMinSize) != 0) {
 523                 hints.set_min_width(scaleUp(width));
 524                 hints.set_min_height(scaleUp(height));
 525             } else if ((hints.get_flags() & XUtilConstants.PMinSize) != 0) {
 526                 flags |= XUtilConstants.PMinSize;
 527                 //Fix for 4320050: Minimum size for java.awt.Frame is not being enforced.
 528                 //We don't need to reset minimum size if it's already set
 529             }
 530             if ((flags & XUtilConstants.PMaxSize) != 0) {
 531                 if (maxBounds != null) {
 532                     if (maxBounds.width != Integer.MAX_VALUE) {
 533                         hints.set_max_width(scaleUp(maxBounds.width));
 534                     } else {
 535                         hints.set_max_width(XToolkit.getDefaultScreenWidth());
 536                     }
 537                     if (maxBounds.height != Integer.MAX_VALUE) {
 538                         hints.set_max_height(scaleUp(maxBounds.height));
 539                     } else {
 540                         hints.set_max_height(XToolkit.getDefaultScreenHeight());
 541                     }
 542                 } else {
 543                     hints.set_max_width(scaleUp(width));
 544                     hints.set_max_height(scaleUp(height));
 545                 }
 546             } else if ((hints.get_flags() & XUtilConstants.PMaxSize) != 0) {
 547                 flags |= XUtilConstants.PMaxSize;
 548                 if (maxBounds != null) {
 549                     if (maxBounds.width != Integer.MAX_VALUE) {
 550                         hints.set_max_width(scaleUp(maxBounds.width));
 551                     } else {
 552                         hints.set_max_width(scaleUp(XToolkit.getDefaultScreenWidth()));
 553                     }
 554                     if (maxBounds.height != Integer.MAX_VALUE) {
 555                         hints.set_max_height(scaleUp(maxBounds.height));
 556                     } else {
 557                         hints.set_max_height(scaleUp(XToolkit.getDefaultScreenHeight()));
 558                     }
 559                 } else {
 560                     // Leave intact
 561                 }
 562             }
 563             flags |= XUtilConstants.PWinGravity;
 564             hints.set_flags(flags);
 565             hints.set_win_gravity(XConstants.NorthWestGravity);
 566             if (insLog.isLoggable(PlatformLogger.Level.FINER)) {
 567                 insLog.finer("Setting hints, resulted flags " + XlibWrapper.hintsToString(flags) +
 568                              ", values " + hints);
 569             }
 570             XlibWrapper.XSetWMNormalHints(XToolkit.getDisplay(), getWindow(), hints.pData);
 571         } finally {
 572             XToolkit.awtUnlock();
 573         }
 574     }
 575 
 576     public boolean isMinSizeSet() {
 577         XSizeHints hints = getHints();
 578         long flags = hints.get_flags();
 579         return ((flags & XUtilConstants.PMinSize) == XUtilConstants.PMinSize);
 580     }
 581 
 582     /**
 583      * This lock object can be used to protect instance data from concurrent access
 584      * by two threads. If both state lock and AWT lock are taken, AWT Lock should be taken first.
 585      */
 586     Object getStateLock() {
 587         return state_lock;
 588     }
 589 
 590     public long getWindow() {
 591         return window;
 592     }
 593     public long getContentWindow() {
 594         return window;
 595     }
 596 
 597     public XBaseWindow getContentXWindow() {
 598         return XToolkit.windowToXWindow(getContentWindow());
 599     }
 600 
 601     public Rectangle getBounds() {
 602         return new Rectangle(x, y, width, height);
 603     }
 604     public Dimension getSize() {
 605         return new Dimension(width, height);
 606     }
 607 
 608 
 609     public void toFront() {
 610         XToolkit.awtLock();
 611         try {
 612             XlibWrapper.XRaiseWindow(XToolkit.getDisplay(), getWindow());
 613         } finally {
 614             XToolkit.awtUnlock();
 615         }
 616     }
 617     public void xRequestFocus(long time) {
 618         XToolkit.awtLock();
 619         try {
 620             if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
 621                 focusLog.finer("XSetInputFocus on " + Long.toHexString(getWindow()) + " with time " + time);
 622             }
 623             XlibWrapper.XSetInputFocus2(XToolkit.getDisplay(), getWindow(), time);
 624         } finally {
 625             XToolkit.awtUnlock();
 626         }
 627     }
 628     public void xRequestFocus() {
 629         XToolkit.awtLock();
 630         try {
 631             if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
 632                 focusLog.finer("XSetInputFocus on " + Long.toHexString(getWindow()));
 633             }
 634              XlibWrapper.XSetInputFocus(XToolkit.getDisplay(), getWindow());
 635         } finally {
 636             XToolkit.awtUnlock();
 637         }
 638     }
 639 
 640     public static long xGetInputFocus() {
 641         XToolkit.awtLock();
 642         try {
 643             return XlibWrapper.XGetInputFocus(XToolkit.getDisplay());
 644         } finally {
 645             XToolkit.awtUnlock();
 646         }
 647     }
 648 
 649     public void xSetVisible(boolean visible) {
 650         if (log.isLoggable(PlatformLogger.Level.FINE)) {
 651             log.fine("Setting visible on " + this + " to " + visible);
 652         }
 653         XToolkit.awtLock();
 654         try {
 655             this.visible = visible;
 656             if (visible) {
 657                 XlibWrapper.XMapWindow(XToolkit.getDisplay(), getWindow());
 658             }
 659             else {
 660                 XlibWrapper.XUnmapWindow(XToolkit.getDisplay(), getWindow());
 661             }
 662             XlibWrapper.XFlush(XToolkit.getDisplay());
 663         } finally {
 664             XToolkit.awtUnlock();
 665         }
 666     }
 667 
 668     boolean isMapped() {
 669         return mapped;
 670     }
 671 
 672     void updateWMName() {
 673         String name = getWMName();
 674         XToolkit.awtLock();
 675         try {
 676             if (name == null) {
 677                 name = " ";
 678             }
 679             XAtom nameAtom = XAtom.get(XAtom.XA_WM_NAME);
 680             nameAtom.setProperty(getWindow(), name);
 681             XAtom netNameAtom = XAtom.get("_NET_WM_NAME");
 682             netNameAtom.setPropertyUTF8(getWindow(), name);
 683         } finally {
 684             XToolkit.awtUnlock();
 685         }
 686     }
 687     void setWMClass(String[] cl) {
 688         if (cl.length != 2) {
 689             throw new IllegalArgumentException("WM_CLASS_NAME consists of exactly two strings");
 690         }
 691         XToolkit.awtLock();
 692         try {
 693             XAtom xa = XAtom.get(XAtom.XA_WM_CLASS);
 694             xa.setProperty8(getWindow(), cl[0] + '\0' + cl[1]);
 695         } finally {
 696             XToolkit.awtUnlock();
 697         }
 698     }
 699 
 700     boolean isVisible() {
 701         return visible;
 702     }
 703 
 704     static long getScreenOfWindow(long window) {
 705         XToolkit.awtLock();
 706         try {
 707             return XlibWrapper.getScreenOfWindow(XToolkit.getDisplay(), window);
 708         } finally {
 709             XToolkit.awtUnlock();
 710         }
 711     }
 712     long getScreenNumber() {
 713         XToolkit.awtLock();
 714         try {
 715             return XlibWrapper.XScreenNumberOfScreen(getScreen());
 716         } finally {
 717             XToolkit.awtUnlock();
 718         }
 719     }
 720 
 721     long getScreen() {
 722         if (screen == -1) { // Not initialized
 723             screen = getScreenOfWindow(window);
 724         }
 725         return screen;
 726     }
 727 
 728     public void xSetBounds(Rectangle bounds) {
 729         xSetBounds(bounds.x, bounds.y, bounds.width, bounds.height);
 730     }
 731 
 732     public void xSetBounds(int x, int y, int width, int height) {
 733         if (getWindow() == 0) {
 734             insLog.warning("Attempt to resize uncreated window");
 735             throw new IllegalStateException("Attempt to resize uncreated window");
 736         }
 737         if (insLog.isLoggable(PlatformLogger.Level.FINE)) {
 738             insLog.fine("Setting bounds on " + this + " to (" + x + ", " + y + "), " + width + "x" + height);
 739         }
 740         width = Math.max(MIN_SIZE, width);
 741         height = Math.max(MIN_SIZE, height);
 742         XToolkit.awtLock();
 743         try {
 744             XlibWrapper.XMoveResizeWindow(XToolkit.getDisplay(), getWindow(),
 745                                           scaleUp(x), scaleUp(y),
 746                                           scaleUp(width), scaleUp(height));
 747         } finally {
 748             XToolkit.awtUnlock();
 749         }
 750     }
 751 
 752     /**
 753      * Translate coordinates from one window into another.  Optimized
 754      * for XAWT - uses cached data when possible.  Preferable over
 755      * pure XTranslateCoordinates.
 756      * @return coordinates relative to dst, or null if error happened
 757      */
 758     static Point toOtherWindow(long src, long dst, int x, int y) {
 759         Point rpt = new Point(0, 0);
 760 
 761         // Check if both windows belong to XAWT - then no X calls are necessary
 762 
 763         XBaseWindow srcPeer = XToolkit.windowToXWindow(src);
 764         XBaseWindow dstPeer = XToolkit.windowToXWindow(dst);
 765 
 766         if (srcPeer != null && dstPeer != null) {
 767             // (x, y) is relative to src
 768             rpt.x = x + srcPeer.getAbsoluteX() - dstPeer.getAbsoluteX();
 769             rpt.y = y + srcPeer.getAbsoluteY() - dstPeer.getAbsoluteY();
 770         } else if (dstPeer != null && XlibUtil.isRoot(src, dstPeer.getScreenNumber())) {
 771             // from root into peer
 772             rpt.x = x - dstPeer.getAbsoluteX();
 773             rpt.y = y - dstPeer.getAbsoluteY();
 774         } else if (srcPeer != null && XlibUtil.isRoot(dst, srcPeer.getScreenNumber())) {
 775             // from peer into root
 776             rpt.x = x + srcPeer.getAbsoluteX();
 777             rpt.y = y + srcPeer.getAbsoluteY();
 778         } else {
 779             int scale = srcPeer == null ? 1 : srcPeer.getScale();
 780             rpt = XlibUtil.translateCoordinates(src, dst, new Point(x, y), scale);
 781         }
 782         return rpt;
 783     }
 784 
 785     /*
 786      * Convert to global coordinates.
 787      */
 788     Rectangle toGlobal(Rectangle rec) {
 789         Point p = toGlobal(rec.getLocation());
 790         Rectangle newRec = new Rectangle(rec);
 791         if (p != null) {
 792             newRec.setLocation(p);
 793         }
 794         return newRec;
 795     }
 796 
 797     Point toGlobal(Point pt) {
 798         Point p = toGlobal(pt.x, pt.y);
 799         if (p != null) {
 800             return p;
 801         } else {
 802             return new Point(pt);
 803         }
 804     }
 805 
 806     Point toGlobal(int x, int y) {
 807         long root;
 808         XToolkit.awtLock();
 809         try {
 810             root = XlibWrapper.RootWindow(XToolkit.getDisplay(),
 811                     getScreenNumber());
 812         } finally {
 813             XToolkit.awtUnlock();
 814         }
 815         Point p = toOtherWindow(getContentWindow(), root, x, y);
 816         if (p != null) {
 817             return p;
 818         } else {
 819             return new Point(x, y);
 820         }
 821     }
 822 
 823     /*
 824      * Convert to local coordinates.
 825      */
 826     Point toLocal(Point pt) {
 827         Point p = toLocal(pt.x, pt.y);
 828         if (p != null) {
 829             return p;
 830         } else {
 831             return new Point(pt);
 832         }
 833     }
 834 
 835     Point toLocal(int x, int y) {
 836         long root;
 837         XToolkit.awtLock();
 838         try {
 839             root = XlibWrapper.RootWindow(XToolkit.getDisplay(),
 840                     getScreenNumber());
 841         } finally {
 842             XToolkit.awtUnlock();
 843         }
 844         Point p = toOtherWindow(root, getContentWindow(), x, y);
 845         if (p != null) {
 846             return p;
 847         } else {
 848             return new Point(x, y);
 849         }
 850     }
 851 
 852     /**
 853      * We should always grab both keyboard and pointer to control event flow
 854      * on popups. This also simplifies synthetic grab implementation.
 855      * The active grab overrides activated automatic grab.
 856      */
 857     public boolean grabInput() {
 858         if (grabLog.isLoggable(PlatformLogger.Level.FINE)) {
 859             grabLog.fine("Grab input on {0}", this);
 860         }
 861 
 862         XToolkit.awtLock();
 863         try {
 864             if (XAwtState.getGrabWindow() == this &&
 865                 XAwtState.isManualGrab())
 866             {
 867                 grabLog.fine("    Already Grabbed");
 868                 return true;
 869             }
 870             //6273031: PIT. Choice drop down does not close once it is right clicked to show a popup menu
 871             //remember previous window having grab and if it's not null ungrab it.
 872             XBaseWindow prevGrabWindow = XAwtState.getGrabWindow();
 873             final int eventMask = (int) (XConstants.ButtonPressMask | XConstants.ButtonReleaseMask
 874                 | XConstants.EnterWindowMask | XConstants.LeaveWindowMask | XConstants.PointerMotionMask
 875                 | XConstants.ButtonMotionMask);
 876             final int ownerEvents = 1;
 877 
 878 
 879             //6714678: IDE (Netbeans, Eclipse, JDeveloper) Debugger hangs
 880             //process on Linux
 881             //The user must pass the sun.awt.disablegrab property to disable
 882             //taking grabs. This prevents hanging of the GUI when a breakpoint
 883             //is hit while a popup window taking the grab is open.
 884             if (!XToolkit.getSunAwtDisableGrab()) {
 885                 int ptrGrab = XlibWrapper.XGrabPointer(XToolkit.getDisplay(),
 886                         getContentWindow(), ownerEvents, eventMask, XConstants.GrabModeAsync,
 887                         XConstants.GrabModeAsync, XConstants.None, (XWM.isMotif() ? XToolkit.arrowCursor : XConstants.None),
 888                         XConstants.CurrentTime);
 889                 // Check grab results to be consistent with X server grab
 890                 if (ptrGrab != XConstants.GrabSuccess) {
 891                     XlibWrapper.XUngrabPointer(XToolkit.getDisplay(), XConstants.CurrentTime);
 892                     XAwtState.setGrabWindow(null);
 893                     grabLog.fine("    Grab Failure - mouse");
 894                     return false;
 895                 }
 896 
 897                 int keyGrab = XlibWrapper.XGrabKeyboard(XToolkit.getDisplay(),
 898                         getContentWindow(), ownerEvents, XConstants.GrabModeAsync, XConstants.GrabModeAsync,
 899                         XConstants.CurrentTime);
 900                 if (keyGrab != XConstants.GrabSuccess) {
 901                     XlibWrapper.XUngrabPointer(XToolkit.getDisplay(), XConstants.CurrentTime);
 902                     XlibWrapper.XUngrabKeyboard(XToolkit.getDisplay(), XConstants.CurrentTime);
 903                     XAwtState.setGrabWindow(null);
 904                     grabLog.fine("    Grab Failure - keyboard");
 905                     return false;
 906                 }
 907             }
 908             if (prevGrabWindow != null) {
 909                 prevGrabWindow.ungrabInputImpl();
 910             }
 911             XAwtState.setGrabWindow(this);
 912             grabLog.fine("    Grab - success");
 913             return true;
 914         } finally {
 915             XToolkit.awtUnlock();
 916         }
 917     }
 918 
 919     static void ungrabInput() {
 920         XToolkit.awtLock();
 921         try {
 922             XBaseWindow grabWindow = XAwtState.getGrabWindow();
 923             if (grabLog.isLoggable(PlatformLogger.Level.FINE)) {
 924                 grabLog.fine("UnGrab input on {0}", grabWindow);
 925             }
 926             if (grabWindow != null) {
 927                 grabWindow.ungrabInputImpl();
 928                 if (!XToolkit.getSunAwtDisableGrab()) {
 929                     XlibWrapper.XUngrabPointer(XToolkit.getDisplay(), XConstants.CurrentTime);
 930                     XlibWrapper.XUngrabKeyboard(XToolkit.getDisplay(), XConstants.CurrentTime);
 931                 }
 932                 XAwtState.setGrabWindow(null);
 933                 // we need to call XFlush() here to force ungrab
 934                 // see 6384219 for details
 935                 XlibWrapper.XFlush(XToolkit.getDisplay());
 936             }
 937         } finally {
 938             XToolkit.awtUnlock();
 939         }
 940     }
 941 
 942     // called from ungrabInput, used in popup windows to hide theirselfs in ungrabbing
 943     void ungrabInputImpl() {
 944     }
 945 
 946     static void checkSecurity() {
 947         if (XToolkit.isSecurityWarningEnabled() && XToolkit.isToolkitThread()) {
 948             StackTraceElement stack[] = (new Throwable()).getStackTrace();
 949             log.warning(stack[1] + ": Security violation: calling user code on toolkit thread");
 950         }
 951     }
 952 
 953     public Set<Long> getChildren() {
 954         synchronized (getStateLock()) {
 955             return new HashSet<Long>(children);
 956         }
 957     }
 958 
 959     // -------------- Event handling ----------------
 960     public void handleMapNotifyEvent(XEvent xev) {
 961         mapped = true;
 962     }
 963     public void handleUnmapNotifyEvent(XEvent xev) {
 964         mapped = false;
 965     }
 966     public void handleReparentNotifyEvent(XEvent xev) {
 967         if (eventLog.isLoggable(PlatformLogger.Level.FINER)) {
 968             XReparentEvent msg = xev.get_xreparent();
 969             eventLog.finer(msg.toString());
 970         }
 971     }
 972     public void handlePropertyNotify(XEvent xev) {
 973         XPropertyEvent msg = xev.get_xproperty();
 974         if (XPropertyCache.isCachingSupported()) {
 975             XPropertyCache.clearCache(window, XAtom.get(msg.get_atom()));
 976         }
 977         if (eventLog.isLoggable(PlatformLogger.Level.FINER)) {
 978             eventLog.finer("{0}", msg);
 979         }
 980     }
 981 
 982     public void handleDestroyNotify(XEvent xev) {
 983         XAnyEvent xany = xev.get_xany();
 984         if (xany.get_window() == getWindow()) {
 985             XToolkit.removeFromWinMap(getWindow(), this);
 986             if (XPropertyCache.isCachingSupported()) {
 987                 XPropertyCache.clearCache(getWindow());
 988             }
 989         }
 990         if (xany.get_window() != getWindow()) {
 991             synchronized (getStateLock()) {
 992                 children.remove(xany.get_window());
 993             }
 994         }
 995     }
 996 
 997     public void handleCreateNotify(XEvent xev) {
 998         XAnyEvent xany = xev.get_xany();
 999         if (xany.get_window() != getWindow()) {
1000             synchronized (getStateLock()) {
1001                 children.add(xany.get_window());
1002             }
1003         }
1004     }
1005 
1006     public void handleClientMessage(XEvent xev) {
1007         if (eventLog.isLoggable(PlatformLogger.Level.FINER)) {
1008             XClientMessageEvent msg = xev.get_xclient();
1009             eventLog.finer(msg.toString());
1010         }
1011     }
1012 
1013     public void handleVisibilityEvent(XEvent xev) {
1014     }
1015     public void handleKeyPress(XEvent xev) {
1016     }
1017     public void handleKeyRelease(XEvent xev) {
1018     }
1019     public void handleExposeEvent(XEvent xev) {
1020     }
1021     /**
1022      * Activate automatic grab on first ButtonPress,
1023      * deactivate on full mouse release
1024      */
1025     public void handleButtonPressRelease(XEvent xev) {
1026         XButtonEvent xbe = xev.get_xbutton();
1027         /*
1028          * Ignore the buttons above 20 due to the bit limit for
1029          * InputEvent.BUTTON_DOWN_MASK.
1030          * One more bit is reserved for FIRST_HIGH_BIT.
1031          */
1032         if (xbe.get_button() > SunToolkit.MAX_BUTTONS_SUPPORTED) {
1033             return;
1034         }
1035         int buttonState = 0;
1036         buttonState = xbe.get_state() & XConstants.ALL_BUTTONS_MASK;
1037         switch (xev.get_type()) {
1038         case XConstants.ButtonPress:
1039             if (buttonState == 0) {
1040                 XWindowPeer parent = getToplevelXWindow();
1041                 // See 6385277, 6981400.
1042                 if (parent != null && parent.isFocusableWindow()) {
1043                     // A click in a client area drops the actual focused window retaining.
1044                     parent.setActualFocusedWindow(null);
1045                     parent.requestWindowFocus(xbe.get_time(), true);
1046                 }
1047                 XAwtState.setAutoGrabWindow(this);
1048             }
1049             break;
1050         case XConstants.ButtonRelease:
1051             if (isFullRelease(buttonState, xbe.get_button())) {
1052                 XAwtState.setAutoGrabWindow(null);
1053             }
1054             break;
1055         }
1056     }
1057     public void handleMotionNotify(XEvent xev) {
1058     }
1059     public void handleXCrossingEvent(XEvent xev) {
1060     }
1061     public void handleConfigureNotifyEvent(XEvent xev) {
1062         XConfigureEvent xe = xev.get_xconfigure();
1063         if (insLog.isLoggable(PlatformLogger.Level.FINER)) {
1064             insLog.finer("Configure, {0}", xe);
1065         }
1066 
1067         x = scaleDown(xe.get_x());
1068         y = scaleDown(xe.get_y());
1069         width = scaleDown(xe.get_width());
1070         height = scaleDown(xe.get_height());
1071     }
1072     /**
1073      * Checks ButtonRelease released all Mouse buttons
1074      */
1075     static boolean isFullRelease(int buttonState, int button) {
1076         final int buttonsNumber = XToolkit.getNumberOfButtonsForMask();
1077 
1078         if (button < 0 || button > buttonsNumber) {
1079             return buttonState == 0;
1080         } else {
1081             return buttonState == XlibUtil.getButtonMask(button);
1082         }
1083     }
1084 
1085     static boolean isGrabbedEvent(XEvent ev, XBaseWindow target) {
1086         switch (ev.get_type()) {
1087           case XConstants.ButtonPress:
1088           case XConstants.ButtonRelease:
1089           case XConstants.MotionNotify:
1090           case XConstants.KeyPress:
1091           case XConstants.KeyRelease:
1092               return true;
1093           case XConstants.LeaveNotify:
1094           case XConstants.EnterNotify:
1095               // We shouldn't dispatch this events to the grabbed components (see 6317481)
1096               // But this logic is important if the grabbed component is top-level (see realSync)
1097               return (target instanceof XWindowPeer);
1098           default:
1099               return false;
1100         }
1101     }
1102     /**
1103      * Dispatches event to the grab Window or event source window depending
1104      * on whether the grab is active and on the event type
1105      */
1106     static void dispatchToWindow(XEvent ev) {
1107         XBaseWindow target = XAwtState.getGrabWindow();
1108         if (target == null || !isGrabbedEvent(ev, target)) {
1109             target = XToolkit.windowToXWindow(ev.get_xany().get_window());
1110         }
1111         if (target != null && target.checkInitialised()) {
1112             target.dispatchEvent(ev);
1113         }
1114     }
1115 
1116     public void dispatchEvent(XEvent xev) {
1117         if (eventLog.isLoggable(PlatformLogger.Level.FINEST)) {
1118             eventLog.finest(xev.toString());
1119         }
1120         int type = xev.get_type();
1121 
1122         if (isDisposed()) {
1123             return;
1124         }
1125 
1126         switch (type)
1127         {
1128           case XConstants.VisibilityNotify:
1129               handleVisibilityEvent(xev);
1130               break;
1131           case XConstants.ClientMessage:
1132               handleClientMessage(xev);
1133               break;
1134           case XConstants.Expose :
1135           case XConstants.GraphicsExpose :
1136               handleExposeEvent(xev);
1137               break;
1138           case XConstants.ButtonPress:
1139           case XConstants.ButtonRelease:
1140               handleButtonPressRelease(xev);
1141               break;
1142 
1143           case XConstants.MotionNotify:
1144               handleMotionNotify(xev);
1145               break;
1146           case XConstants.KeyPress:
1147               handleKeyPress(xev);
1148               break;
1149           case XConstants.KeyRelease:
1150               handleKeyRelease(xev);
1151               break;
1152           case XConstants.EnterNotify:
1153           case XConstants.LeaveNotify:
1154               handleXCrossingEvent(xev);
1155               break;
1156           case XConstants.ConfigureNotify:
1157               handleConfigureNotifyEvent(xev);
1158               break;
1159           case XConstants.MapNotify:
1160               handleMapNotifyEvent(xev);
1161               break;
1162           case XConstants.UnmapNotify:
1163               handleUnmapNotifyEvent(xev);
1164               break;
1165           case XConstants.ReparentNotify:
1166               handleReparentNotifyEvent(xev);
1167               break;
1168           case XConstants.PropertyNotify:
1169               handlePropertyNotify(xev);
1170               break;
1171           case XConstants.DestroyNotify:
1172               handleDestroyNotify(xev);
1173               break;
1174           case XConstants.CreateNotify:
1175               handleCreateNotify(xev);
1176               break;
1177         }
1178     }
1179     protected boolean isEventDisabled(XEvent e) {
1180         return false;
1181     }
1182 
1183     int getX() {
1184         return x;
1185     }
1186 
1187     int getY() {
1188         return y;
1189     }
1190 
1191     int getWidth() {
1192         return width;
1193     }
1194 
1195     int getHeight() {
1196         return height;
1197     }
1198 
1199     void setDisposed(boolean d) {
1200         disposed = d;
1201     }
1202 
1203     boolean isDisposed() {
1204         return disposed;
1205     }
1206 
1207     public int getAbsoluteX() {
1208         XBaseWindow pw = getParentWindow();
1209         if (pw != null) {
1210             return pw.getAbsoluteX() + getX();
1211         } else {
1212             // Overridden for top-levels as their (x,y) is Java (x, y), not native location
1213             return getX();
1214         }
1215     }
1216 
1217     public int getAbsoluteY() {
1218         XBaseWindow pw = getParentWindow();
1219         if (pw != null) {
1220             return pw.getAbsoluteY() + getY();
1221         } else {
1222             return getY();
1223         }
1224     }
1225 
1226     public XBaseWindow getParentWindow() {
1227         return parentWindow;
1228     }
1229 
1230     public XWindowPeer getToplevelXWindow() {
1231         XBaseWindow bw = this;
1232         while (bw != null && !(bw instanceof XWindowPeer)) {
1233             bw = bw.getParentWindow();
1234         }
1235         return (XWindowPeer)bw;
1236     }
1237     public String toString() {
1238         return super.toString() + "(" + Long.toString(getWindow(), 16) + ")";
1239     }
1240 
1241     /**
1242      * Returns whether the given point is inside of the window.  Coordinates are local.
1243      */
1244     public boolean contains(int x, int y) {
1245         return x >= 0 && y >= 0 && x < getWidth() && y < getHeight();
1246     }
1247 
1248     /**
1249      * Returns whether the given point is inside of the window.  Coordinates are global.
1250      */
1251     public boolean containsGlobal(int x, int y) {
1252         return x >= getAbsoluteX() && y >= getAbsoluteY() && x < (getAbsoluteX()+getWidth()) && y < (getAbsoluteY()+getHeight());
1253     }
1254 
1255 }
--- EOF ---