1 /*
   2  * Copyright (c) 1997, 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;
  27 
  28 import java.awt.AWTError;
  29 import java.awt.GraphicsDevice;
  30 import java.awt.Point;
  31 import java.awt.Rectangle;
  32 import java.io.BufferedReader;
  33 import java.io.File;
  34 import java.io.FileReader;
  35 import java.io.FileNotFoundException;
  36 import java.io.InputStream;
  37 import java.io.IOException;
  38 import java.io.StreamTokenizer;
  39 import java.net.InetAddress;
  40 import java.net.NetworkInterface;
  41 import java.net.SocketException;
  42 import java.net.UnknownHostException;
  43 
  44 import java.util.*;
  45 
  46 import sun.awt.motif.MFontConfiguration;
  47 import sun.font.FcFontConfiguration;
  48 import sun.font.Font2D;
  49 import sun.font.FontManager;
  50 import sun.font.NativeFont;
  51 import sun.java2d.SunGraphicsEnvironment;
  52 import sun.java2d.SurfaceManagerFactory;
  53 import sun.java2d.UnixSurfaceManagerFactory;
  54 import sun.util.logging.PlatformLogger;
  55 import sun.java2d.xr.XRSurfaceData;
  56 
  57 /**
  58  * This is an implementation of a GraphicsEnvironment object for the
  59  * default local GraphicsEnvironment used by the Java Runtime Environment
  60  * for X11 environments.
  61  *
  62  * @see GraphicsDevice
  63  * @see GraphicsConfiguration
  64  */
  65 public class X11GraphicsEnvironment
  66     extends SunGraphicsEnvironment
  67 {
  68     private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11GraphicsEnvironment");
  69     private static final PlatformLogger screenLog = PlatformLogger.getLogger("sun.awt.screen.X11GraphicsEnvironment");
  70 
  71     private static Boolean xinerState;
  72 
  73     static {
  74         java.security.AccessController.doPrivileged(
  75                           new java.security.PrivilegedAction<Object>() {
  76             public Object run() {
  77                 System.loadLibrary("awt");
  78 
  79                 /*
  80                  * Note: The MToolkit object depends on the static initializer
  81                  * of X11GraphicsEnvironment to initialize the connection to
  82                  * the X11 server.
  83                  */
  84                 if (!isHeadless()) {
  85                     // first check the OGL system property
  86                     boolean glxRequested = false;
  87                     String prop = System.getProperty("sun.java2d.opengl");
  88                     if (prop != null) {
  89                         if (prop.equals("true") || prop.equals("t")) {
  90                             glxRequested = true;
  91                         } else if (prop.equals("True") || prop.equals("T")) {
  92                             glxRequested = true;
  93                             glxVerbose = true;
  94                         }
  95                     }
  96 
  97                     // Now check for XRender system property
  98                     boolean xRenderRequested = true;
  99                     boolean xRenderIgnoreLinuxVersion = false;
 100                     String xProp = System.getProperty("sun.java2d.xrender");
 101                         if (xProp != null) {
 102                         if (xProp.equals("false") || xProp.equals("f")) {
 103                             xRenderRequested = false;
 104                         } else if (xProp.equals("True") || xProp.equals("T")) {
 105                             xRenderRequested = true;
 106                             xRenderVerbose = true;
 107                         }
 108 
 109                         if(xProp.equalsIgnoreCase("t") || xProp.equalsIgnoreCase("true")) {
 110                             xRenderIgnoreLinuxVersion = true;
 111                         }
 112                     }
 113 
 114                     // initialize the X11 display connection
 115                     initDisplay(glxRequested);
 116 
 117                     // only attempt to initialize GLX if it was requested
 118                     if (glxRequested) {
 119                         glxAvailable = initGLX();
 120                         if (glxVerbose && !glxAvailable) {
 121                             System.out.println(
 122                                 "Could not enable OpenGL " +
 123                                 "pipeline (GLX 1.3 not available)");
 124                         }
 125                     }
 126 
 127                     // only attempt to initialize Xrender if it was requested
 128                     if (xRenderRequested) {
 129                         xRenderAvailable = initXRender(xRenderVerbose, xRenderIgnoreLinuxVersion);
 130                         if (xRenderVerbose && !xRenderAvailable) {
 131                             System.out.println(
 132                                          "Could not enable XRender pipeline");
 133                         }
 134                     }
 135 
 136                     if (xRenderAvailable) {
 137                         XRSurfaceData.initXRSurfaceData();
 138                     }
 139                 }
 140 
 141                 return null;
 142             }
 143          });
 144 
 145         // Install the correct surface manager factory.
 146         SurfaceManagerFactory.setInstance(new UnixSurfaceManagerFactory());
 147 
 148     }
 149 
 150 
 151     private static boolean glxAvailable;
 152     private static boolean glxVerbose;
 153 
 154     private static native boolean initGLX();
 155 
 156     public static boolean isGLXAvailable() {
 157         return glxAvailable;
 158     }
 159 
 160     public static boolean isGLXVerbose() {
 161         return glxVerbose;
 162     }
 163 
 164     private static boolean xRenderVerbose;
 165     private static boolean xRenderAvailable;
 166 
 167     private static native boolean initXRender(boolean verbose, boolean ignoreLinuxVersion);
 168     public static boolean isXRenderAvailable() {
 169         return xRenderAvailable;
 170     }
 171 
 172     public static boolean isXRenderVerbose() {
 173         return xRenderVerbose;
 174     }
 175 
 176     /**
 177      * Checks if Shared Memory extension can be used.
 178      * Returns:
 179      *   -1 if server doesn't support MITShm
 180      *    1 if server supports it and it can be used
 181      *    0 otherwise
 182      */
 183     private static native int checkShmExt();
 184 
 185     private static  native String getDisplayString();
 186     private Boolean isDisplayLocal;
 187 
 188     /**
 189      * This should only be called from the static initializer, so no need for
 190      * the synchronized keyword.
 191      */
 192     private static native void initDisplay(boolean glxRequested);
 193 
 194     public X11GraphicsEnvironment() {
 195     }
 196 
 197     protected native int getNumScreens();
 198 
 199     protected GraphicsDevice makeScreenDevice(int screennum) {
 200         return new X11GraphicsDevice(screennum);
 201     }
 202 
 203     protected native int getDefaultScreenNum();
 204     /**
 205      * Returns the default screen graphics device.
 206      */
 207     public GraphicsDevice getDefaultScreenDevice() {
 208         GraphicsDevice[] screens = getScreenDevices();
 209         if (screens.length == 0) {
 210             throw new AWTError("no screen devices");
 211         }
 212         int index = getDefaultScreenNum();
 213         return screens[0 < index && index < screens.length ? index : 0];
 214     }
 215 
 216     public boolean isDisplayLocal() {
 217         if (isDisplayLocal == null) {
 218             SunToolkit.awtLock();
 219             try {
 220                 if (isDisplayLocal == null) {
 221                     isDisplayLocal = Boolean.valueOf(_isDisplayLocal());
 222                 }
 223             } finally {
 224                 SunToolkit.awtUnlock();
 225             }
 226         }
 227         return isDisplayLocal.booleanValue();
 228     }
 229 
 230     private static boolean _isDisplayLocal() {
 231         if (isHeadless()) {
 232             return true;
 233         }
 234 
 235         String isRemote = java.security.AccessController.doPrivileged(
 236             new sun.security.action.GetPropertyAction("sun.java2d.remote"));
 237         if (isRemote != null) {
 238             return isRemote.equals("false");
 239         }
 240 
 241         int shm = checkShmExt();
 242         if (shm != -1) {
 243             return (shm == 1);
 244         }
 245 
 246         // If XServer doesn't support ShMem extension,
 247         // try the other way
 248 
 249         String display = getDisplayString();
 250         int ind = display.indexOf(':');
 251         final String hostName = display.substring(0, ind);
 252         if (ind <= 0) {
 253             // ':0' case
 254             return true;
 255         }
 256 
 257         Boolean result = java.security.AccessController.doPrivileged(
 258             new java.security.PrivilegedAction<Boolean>() {
 259             public Boolean run() {
 260                 InetAddress remAddr[] = null;
 261                 Enumeration<InetAddress> locals = null;
 262                 Enumeration<NetworkInterface> interfaces = null;
 263                 try {
 264                     interfaces = NetworkInterface.getNetworkInterfaces();
 265                     remAddr = InetAddress.getAllByName(hostName);
 266                     if (remAddr == null) {
 267                         return Boolean.FALSE;
 268                     }
 269                 } catch (UnknownHostException e) {
 270                     System.err.println("Unknown host: " + hostName);
 271                     return Boolean.FALSE;
 272                 } catch (SocketException e1) {
 273                     System.err.println(e1.getMessage());
 274                     return Boolean.FALSE;
 275                 }
 276 
 277                 for (; interfaces.hasMoreElements();) {
 278                     locals = interfaces.nextElement().getInetAddresses();
 279                     for (; locals.hasMoreElements();) {
 280                         final InetAddress localAddr = locals.nextElement();
 281                         for (int i = 0; i < remAddr.length; i++) {
 282                             if (localAddr.equals(remAddr[i])) {
 283                                 return Boolean.TRUE;
 284                             }
 285                         }
 286                     }
 287                 }
 288                 return Boolean.FALSE;
 289             }});
 290         return result.booleanValue();
 291     }
 292 
 293 
 294 
 295     /**
 296      * Returns face name for default font, or null if
 297      * no face names are used for CompositeFontDescriptors
 298      * for this platform.
 299      */
 300     public String getDefaultFontFaceName() {
 301 
 302         return null;
 303     }
 304 
 305     private static native boolean pRunningXinerama();
 306     private static native Point getXineramaCenterPoint();
 307 
 308     /**
 309      * Override for Xinerama case: call new Solaris API for getting the correct
 310      * centering point from the windowing system.
 311      */
 312     public Point getCenterPoint() {
 313         if (runningXinerama()) {
 314             Point p = getXineramaCenterPoint();
 315             if (p != null) {
 316                 return p;
 317             }
 318         }
 319         return super.getCenterPoint();
 320     }
 321 
 322     /**
 323      * Override for Xinerama case
 324      */
 325     public Rectangle getMaximumWindowBounds() {
 326         if (runningXinerama()) {
 327             return getXineramaWindowBounds();
 328         } else {
 329             return super.getMaximumWindowBounds();
 330         }
 331     }
 332 
 333     public boolean runningXinerama() {
 334         if (xinerState == null) {
 335             // pRunningXinerama() simply returns a global boolean variable,
 336             // so there is no need to synchronize here
 337             xinerState = Boolean.valueOf(pRunningXinerama());
 338             if (screenLog.isLoggable(PlatformLogger.Level.FINER)) {
 339                 screenLog.finer("Running Xinerama: " + xinerState);
 340             }
 341         }
 342         return xinerState.booleanValue();
 343     }
 344 
 345     /**
 346      * Return the bounds for a centered Window on a system running in Xinerama
 347      * mode.
 348      *
 349      * Calculations are based on the assumption of a perfectly rectangular
 350      * display area (display edges line up with one another, and displays
 351      * have consistent width and/or height).
 352      *
 353      * The bounds to return depend on the arrangement of displays and on where
 354      * Windows are to be centered.  There are two common situations:
 355      *
 356      * 1) The center point lies at the center of the combined area of all the
 357      *    displays.  In this case, the combined area of all displays is
 358      *    returned.
 359      *
 360      * 2) The center point lies at the center of a single display.  In this case
 361      *    the user most likely wants centered Windows to be constrained to that
 362      *    single display.  The boundaries of the one display are returned.
 363      *
 364      * It is possible for the center point to be at both the center of the
 365      * entire display space AND at the center of a single monitor (a square of
 366      * 9 monitors, for instance).  In this case, the entire display area is
 367      * returned.
 368      *
 369      * Because the center point is arbitrarily settable by the user, it could
 370      * fit neither of the cases above.  The fallback case is to simply return
 371      * the combined area for all screens.
 372      */
 373     protected Rectangle getXineramaWindowBounds() {
 374         Point center = getCenterPoint();
 375         Rectangle unionRect, tempRect;
 376         GraphicsDevice[] gds = getScreenDevices();
 377         Rectangle centerMonitorRect = null;
 378         int i;
 379 
 380         // if center point is at the center of all monitors
 381         // return union of all bounds
 382         //
 383         //  MM*MM     MMM       M
 384         //            M*M       *
 385         //            MMM       M
 386 
 387         // if center point is at center of a single monitor (but not of all
 388         // monitors)
 389         // return bounds of single monitor
 390         //
 391         // MMM         MM
 392         // MM*         *M
 393 
 394         // else, center is in some strange spot (such as on the border between
 395         // monitors), and we should just return the union of all monitors
 396         //
 397         // MM          MMM
 398         // MM          MMM
 399 
 400         unionRect = getUsableBounds(gds[0]);
 401 
 402         for (i = 0; i < gds.length; i++) {
 403             tempRect = getUsableBounds(gds[i]);
 404             if (centerMonitorRect == null &&
 405                 // add a pixel or two for fudge-factor
 406                 (tempRect.width / 2) + tempRect.x > center.x - 1 &&
 407                 (tempRect.height / 2) + tempRect.y > center.y - 1 &&
 408                 (tempRect.width / 2) + tempRect.x < center.x + 1 &&
 409                 (tempRect.height / 2) + tempRect.y < center.y + 1) {
 410                 centerMonitorRect = tempRect;
 411             }
 412             unionRect = unionRect.union(tempRect);
 413         }
 414 
 415         // first: check for center of all monitors (video wall)
 416         // add a pixel or two for fudge-factor
 417         if ((unionRect.width / 2) + unionRect.x > center.x - 1 &&
 418             (unionRect.height / 2) + unionRect.y > center.y - 1 &&
 419             (unionRect.width / 2) + unionRect.x < center.x + 1 &&
 420             (unionRect.height / 2) + unionRect.y < center.y + 1) {
 421 
 422             if (screenLog.isLoggable(PlatformLogger.Level.FINER)) {
 423                 screenLog.finer("Video Wall: center point is at center of all displays.");
 424             }
 425             return unionRect;
 426         }
 427 
 428         // next, check if at center of one monitor
 429         if (centerMonitorRect != null) {
 430             if (screenLog.isLoggable(PlatformLogger.Level.FINER)) {
 431                 screenLog.finer("Center point at center of a particular " +
 432                                 "monitor, but not of the entire virtual display.");
 433             }
 434             return centerMonitorRect;
 435         }
 436 
 437         // otherwise, the center is at some weird spot: return unionRect
 438         if (screenLog.isLoggable(PlatformLogger.Level.FINER)) {
 439             screenLog.finer("Center point is somewhere strange - return union of all bounds.");
 440         }
 441         return unionRect;
 442     }
 443 
 444     /**
 445      * From the DisplayChangedListener interface; devices do not need
 446      * to react to this event.
 447      */
 448     @Override
 449     public void paletteChanged() {
 450     }
 451 }
--- EOF ---