1 /*
   2  * Copyright (c) 2006, 2013, 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.Dimension;
  29 import java.awt.GraphicsEnvironment;
  30 import java.awt.Point;
  31 import java.awt.Rectangle;
  32 
  33 import java.util.Collections;
  34 import java.util.HashSet;
  35 import java.util.Set;
  36 
  37 import sun.awt.X11GraphicsConfig;
  38 import sun.awt.X11GraphicsDevice;
  39 import sun.awt.X11GraphicsEnvironment;
  40 
  41 import sun.java2d.pipe.Region;
  42 
  43 /*
  44  * This class is a collection of utility methods that operate
  45  * with native windows.
  46  */
  47 public class XlibUtil
  48 {
  49     /**
  50      * The constructor is made private to eliminate any
  51      * instances of this class
  52     */
  53     private XlibUtil()
  54     {
  55     }
  56 
  57     /**
  58      * Xinerama-aware version of XlibWrapper.RootWindow method.
  59      */
  60     public static long getRootWindow(int screenNumber)
  61     {
  62         XToolkit.awtLock();
  63         try
  64         {
  65             X11GraphicsEnvironment x11ge = (X11GraphicsEnvironment)
  66                 GraphicsEnvironment.getLocalGraphicsEnvironment();
  67             if (x11ge.runningXinerama())
  68             {
  69                 // all the Xinerama windows share the same root window
  70                 return XlibWrapper.RootWindow(XToolkit.getDisplay(), 0);
  71             }
  72             else
  73             {
  74                 return XlibWrapper.RootWindow(XToolkit.getDisplay(), screenNumber);
  75             }
  76         }
  77         finally
  78         {
  79             XToolkit.awtUnlock();
  80         }
  81     }
  82 
  83     /**
  84      * Checks if the given window is a root window for the given screen
  85      */
  86     static boolean isRoot(long rootCandidate, long screenNumber)
  87     {
  88         long root;
  89 
  90         XToolkit.awtLock();
  91         try
  92         {
  93             root = XlibWrapper.RootWindow(XToolkit.getDisplay(),
  94                                           screenNumber);
  95         }
  96         finally
  97         {
  98             XToolkit.awtUnlock();
  99         }
 100 
 101         return root == rootCandidate;
 102     }
 103 
 104     /**
 105      * Returns the bounds of the given window, in absolute coordinates
 106      */
 107     static Rectangle getWindowGeometry(long window, int scale)
 108     {
 109         XToolkit.awtLock();
 110         try
 111         {
 112             int res = XlibWrapper.XGetGeometry(XToolkit.getDisplay(),
 113                                                window,
 114                                                XlibWrapper.larg1, // root_return
 115                                                XlibWrapper.larg2, // x_return
 116                                                XlibWrapper.larg3, // y_return
 117                                                XlibWrapper.larg4, // width_return
 118                                                XlibWrapper.larg5, // height_return
 119                                                XlibWrapper.larg6, // border_width_return
 120                                                XlibWrapper.larg7); // depth_return
 121             if (res == 0)
 122             {
 123                 return null;
 124             }
 125 
 126             int x = Native.getInt(XlibWrapper.larg2);
 127             int y = Native.getInt(XlibWrapper.larg3);
 128             long width = Native.getUInt(XlibWrapper.larg4);
 129             long height = Native.getUInt(XlibWrapper.larg5);
 130 
 131             return new Rectangle(scaleDown(x, scale), scaleDown(y, scale),
 132                                  scaleDown((int) width, scale),
 133                                  scaleDown((int) height, scale));
 134         }
 135         finally
 136         {
 137             XToolkit.awtUnlock();
 138         }
 139     }
 140 
 141     /**
 142      * Translates the given point from one window to another. Returns
 143      * null if the translation is failed
 144      */
 145     static Point translateCoordinates(long src, long dst, Point p, int scale)
 146     {
 147         Point translated = null;
 148 
 149         XToolkit.awtLock();
 150         try
 151         {
 152             XTranslateCoordinates xtc =
 153                 new XTranslateCoordinates(src, dst, p.x * scale, p.y * scale);
 154             try
 155             {
 156                 int status = xtc.execute(XErrorHandler.IgnoreBadWindowHandler.getInstance());
 157                 if ((status != 0) &&
 158                     ((XErrorHandlerUtil.saved_error == null) ||
 159                     (XErrorHandlerUtil.saved_error.get_error_code() == XConstants.Success)))
 160                 {
 161                     translated = new Point(scaleDown(xtc.get_dest_x(), scale),
 162                                            scaleDown(xtc.get_dest_y(), scale));
 163                 }
 164             }
 165             finally
 166             {
 167                 xtc.dispose();
 168             }
 169         }
 170         finally
 171         {
 172             XToolkit.awtUnlock();
 173         }
 174 
 175         return translated;
 176     }
 177 
 178     /**
 179      * Translates the given rectangle from one window to another.
 180      * Returns null if the translation is failed
 181      */
 182     static Rectangle translateCoordinates(long src, long dst, Rectangle r,
 183                                           int scale)
 184     {
 185         Point translatedLoc = translateCoordinates(src, dst, r.getLocation(),
 186                                                    scale);
 187 
 188         if (translatedLoc == null)
 189         {
 190             return null;
 191         }
 192         else
 193         {
 194             return new Rectangle(translatedLoc, r.getSize());
 195         }
 196     }
 197 
 198     /**
 199      * Returns the parent for the given window
 200      */
 201     static long getParentWindow(long window)
 202     {
 203         XToolkit.awtLock();
 204         try
 205         {
 206             XBaseWindow bw = XToolkit.windowToXWindow(window);
 207             if (bw != null)
 208             {
 209                 XBaseWindow pbw = bw.getParentWindow();
 210                 if (pbw != null)
 211                 {
 212                     return pbw.getWindow();
 213                 }
 214             }
 215 
 216             XQueryTree qt = new XQueryTree(window);
 217             try
 218             {
 219                 if (qt.execute() == 0)
 220                 {
 221                     return 0;
 222                 }
 223                 else
 224                 {
 225                     return qt.get_parent();
 226                 }
 227             }
 228             finally
 229             {
 230                 qt.dispose();
 231             }
 232         }
 233         finally
 234         {
 235             XToolkit.awtUnlock();
 236         }
 237     }
 238 
 239     /**
 240      * Returns all the children for the given window
 241      */
 242     static Set<Long> getChildWindows(long window)
 243     {
 244         XToolkit.awtLock();
 245         try
 246         {
 247             XBaseWindow bw = XToolkit.windowToXWindow(window);
 248             if (bw != null)
 249             {
 250                 return bw.getChildren();
 251             }
 252 
 253             XQueryTree xqt = new XQueryTree(window);
 254             try
 255             {
 256                 int status = xqt.execute();
 257                 if (status == 0)
 258                 {
 259                     return Collections.emptySet();
 260                 }
 261 
 262                 long children = xqt.get_children();
 263 
 264                 if (children == 0)
 265                 {
 266                     return Collections.emptySet();
 267                 }
 268 
 269                 int childrenCount = xqt.get_nchildren();
 270 
 271                 Set<Long> childrenSet = new HashSet<Long>(childrenCount);
 272                 for (int i = 0; i < childrenCount; i++)
 273                 {
 274                     childrenSet.add(Native.getWindow(children, i));
 275                 }
 276 
 277                 return childrenSet;
 278             }
 279             finally
 280             {
 281                 xqt.dispose();
 282             }
 283         }
 284         finally
 285         {
 286             XToolkit.awtUnlock();
 287         }
 288     }
 289 
 290     /**
 291      * Checks if the given window is a Java window and is an
 292      * instance of XWindowPeer
 293      */
 294     static boolean isXAWTToplevelWindow(long window)
 295     {
 296         return XToolkit.windowToXWindow(window) instanceof XWindowPeer;
 297     }
 298 
 299     /**
 300      * NOTICE: Right now returns only decorated top-levels (not Window)
 301      */
 302     static boolean isToplevelWindow(long window)
 303     {
 304         if (XToolkit.windowToXWindow(window) instanceof XDecoratedPeer)
 305         {
 306             return true;
 307         }
 308 
 309         XToolkit.awtLock();
 310         try
 311         {
 312             WindowPropertyGetter wpg =
 313                 new WindowPropertyGetter(window, XWM.XA_WM_STATE, 0, 1, false,
 314                                          XWM.XA_WM_STATE);
 315             try
 316             {
 317                 wpg.execute(XErrorHandler.IgnoreBadWindowHandler.getInstance());
 318                 if (wpg.getActualType() == XWM.XA_WM_STATE.getAtom())
 319                 {
 320                     return true;
 321                 }
 322             }
 323             finally
 324             {
 325                 wpg.dispose();
 326             }
 327 
 328             return false;
 329         }
 330         finally
 331         {
 332             XToolkit.awtUnlock();
 333         }
 334     }
 335 
 336     /**
 337      * The same as isToplevelWindow(window), but doesn't treat
 338      * XEmbeddedFramePeer as toplevel.
 339      */
 340     static boolean isTrueToplevelWindow(long window)
 341     {
 342         if (XToolkit.windowToXWindow(window) instanceof XEmbeddedFramePeer)
 343         {
 344             return false;
 345         }
 346 
 347         return isToplevelWindow(window);
 348     }
 349 
 350     static int getWindowMapState(long window)
 351     {
 352         XToolkit.awtLock();
 353         XWindowAttributes wattr = new XWindowAttributes();
 354         try
 355         {
 356             XErrorHandlerUtil.WITH_XERROR_HANDLER(XErrorHandler.IgnoreBadWindowHandler.getInstance());
 357             int status = XlibWrapper.XGetWindowAttributes(XToolkit.getDisplay(),
 358                                                           window, wattr.pData);
 359             XErrorHandlerUtil.RESTORE_XERROR_HANDLER();
 360             if ((status != 0) &&
 361                 ((XErrorHandlerUtil.saved_error == null) ||
 362                 (XErrorHandlerUtil.saved_error.get_error_code() == XConstants.Success)))
 363             {
 364                 return wattr.get_map_state();
 365             }
 366         }
 367         finally
 368         {
 369             wattr.dispose();
 370             XToolkit.awtUnlock();
 371         }
 372 
 373         return XConstants.IsUnmapped;
 374     }
 375 
 376     /**
 377      * XSHAPE extension support.
 378      */
 379 
 380     // The variable is declared static as the XSHAPE extension cannot
 381     // be disabled at run-time, and thus is available all the time
 382     // once the check is passed.
 383     static Boolean isShapingSupported = null;
 384 
 385     /**
 386      *  Returns whether the XSHAPE extension available
 387      *  @since 1.7
 388      */
 389     static synchronized boolean isShapingSupported() {
 390 
 391         if (isShapingSupported == null) {
 392             XToolkit.awtLock();
 393             try {
 394                 isShapingSupported =
 395                     XlibWrapper.XShapeQueryExtension(
 396                             XToolkit.getDisplay(),
 397                             XlibWrapper.larg1,
 398                             XlibWrapper.larg2);
 399             } finally {
 400                 XToolkit.awtUnlock();
 401             }
 402         }
 403 
 404         return isShapingSupported.booleanValue();
 405     }
 406 
 407     static int getButtonMask(int button) {
 408         // Button indices start with 1. The first bit in the button mask is the 8th.
 409         // The state mask does not support button indicies > 5, so we need to
 410         // cut there.
 411         if (button <= 0 || button > XConstants.MAX_BUTTONS) {
 412             return 0;
 413         } else {
 414             return 1 << (7 + button);
 415         }
 416     }
 417 
 418     static int scaleDown(int x, int scale) {
 419         return Region.clipRound(x / (double)scale);
 420     }
 421 }