< prev index next >

openjfx9/modules/javafx.graphics/src/main/java/com/sun/marlin/MarlinProperties.java

Print this page

        

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2007, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this

@@ -21,37 +21,37 @@
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 
-package sun.java2d.marlin;
+package com.sun.marlin;
 
 import java.security.AccessController;
-import static sun.java2d.marlin.MarlinUtils.logInfo;
-import sun.security.action.GetPropertyAction;
+import static com.sun.marlin.MarlinUtils.logInfo;
+import java.security.PrivilegedAction;
 
 public final class MarlinProperties {
 
     private MarlinProperties() {
         // no-op
     }
 
     // marlin system properties
 
     public static boolean isUseThreadLocal() {
-        return getBoolean("sun.java2d.renderer.useThreadLocal", "true");
+        return getBoolean("prism.marlin.useThreadLocal", "true");
     }
 
     /**
      * Return the initial edge capacity used to define initial arrays
      * (edges, polystack, crossings)
      *
      * @return 256 < initial edges < 65536 (4096 by default)
      */
     public static int getInitialEdges() {
         return align(
-            getInteger("sun.java2d.renderer.edges", 4096, 64, 64 * 1024),
+            getInteger("prism.marlin.edges", 4096, 64, 64 * 1024),
             64);
     }
 
     /**
      * Return the initial pixel size used to define initial arrays

@@ -59,126 +59,133 @@
      *
      * @return 64 < initial pixel size < 32768 (2048 by default)
      */
     public static int getInitialImageSize() {
         return align(
-            getInteger("sun.java2d.renderer.pixelsize", 2048, 64, 32 * 1024),
+            getInteger("prism.marlin.pixelsize", 2048, 64, 32 * 1024),
             64);
     }
 
     /**
      * Return the log(2) corresponding to subpixel on x-axis (
      *
-     * @return 1 (2 subpixels) < initial pixel size < 4 (256 subpixels)
+     * @return 0 (1 subpixels) < initial pixel size < 4 (256 subpixels)
      * (3 by default ie 8 subpixels)
      */
     public static int getSubPixel_Log2_X() {
-        return getInteger("sun.java2d.renderer.subPixel_log2_X", 3, 1, 8);
+        return getInteger("prism.marlin.subPixel_log2_X", 3, 0, 8);
     }
 
     /**
      * Return the log(2) corresponding to subpixel on y-axis (
      *
-     * @return 1 (2 subpixels) < initial pixel size < 8 (256 subpixels)
+     * @return 0 (1 subpixels) < initial pixel size < 8 (256 subpixels)
      * (3 by default ie 8 subpixels)
      */
     public static int getSubPixel_Log2_Y() {
-        return getInteger("sun.java2d.renderer.subPixel_log2_Y", 3, 1, 8);
+        return getInteger("prism.marlin.subPixel_log2_Y", 3, 0, 8);
     }
 
     /**
      * Return the log(2) corresponding to the square tile size in pixels
      *
      * @return 3 (8x8 pixels) < tile size < 8 (256x256 pixels)
      * (5 by default ie 32x32 pixels)
      */
     public static int getTileSize_Log2() {
-        return getInteger("sun.java2d.renderer.tileSize_log2", 5, 3, 8);
+        return getInteger("prism.marlin.tileSize_log2", 5, 3, 8);
+    }
+
+    public static int getTileWidth_Log2() {
+        return getInteger("prism.marlin.tileWidth_log2", 5, 3, 10);
     }
 
     /**
      * Return the log(2) corresponding to the block size in pixels
      *
      * @return 3 (8 pixels) < block size < 8 (256 pixels)
      * (5 by default ie 32 pixels)
      */
     public static int getBlockSize_Log2() {
-        return getInteger("sun.java2d.renderer.blockSize_log2", 5, 3, 8);
+        return getInteger("prism.marlin.blockSize_log2", 5, 3, 8);
     }
 
     // RLE / blockFlags settings
 
     public static boolean isForceRLE() {
-        return getBoolean("sun.java2d.renderer.forceRLE", "false");
+        return getBoolean("prism.marlin.forceRLE", "false");
     }
 
     public static boolean isForceNoRLE() {
-        return getBoolean("sun.java2d.renderer.forceNoRLE", "false");
+        return getBoolean("prism.marlin.forceNoRLE", "false");
     }
 
     public static boolean isUseTileFlags() {
-        return getBoolean("sun.java2d.renderer.useTileFlags", "true");
+        return getBoolean("prism.marlin.useTileFlags", "true");
     }
 
     public static boolean isUseTileFlagsWithHeuristics() {
         return isUseTileFlags()
-        && getBoolean("sun.java2d.renderer.useTileFlags.useHeuristics", "true");
+        && getBoolean("prism.marlin.useTileFlags.useHeuristics", "true");
     }
 
     public static int getRLEMinWidth() {
-        return getInteger("sun.java2d.renderer.rleMinWidth", 64, 0, Integer.MAX_VALUE);
+        return getInteger("prism.marlin.rleMinWidth", 64, 0, Integer.MAX_VALUE);
     }
 
     // optimisation parameters
 
     public static boolean isUseSimplifier() {
-        return getBoolean("sun.java2d.renderer.useSimplifier", "false");
+        return getBoolean("prism.marlin.useSimplifier", "false");
     }
 
     // debugging parameters
 
     public static boolean isDoStats() {
-        return getBoolean("sun.java2d.renderer.doStats", "false");
+        return getBoolean("prism.marlin.doStats", "false");
     }
 
     public static boolean isDoMonitors() {
-        return getBoolean("sun.java2d.renderer.doMonitors", "false");
+        return getBoolean("prism.marlin.doMonitors", "false");
     }
 
     public static boolean isDoChecks() {
-        return getBoolean("sun.java2d.renderer.doChecks", "false");
+        return getBoolean("prism.marlin.doChecks", "false");
     }
 
     // logging parameters
 
     public static boolean isLoggingEnabled() {
-        return getBoolean("sun.java2d.renderer.log", "false");
+        return getBoolean("prism.marlin.log", "false");
     }
 
     public static boolean isUseLogger() {
-        return getBoolean("sun.java2d.renderer.useLogger", "false");
+        return getBoolean("prism.marlin.useLogger", "false");
     }
 
     public static boolean isLogCreateContext() {
-        return getBoolean("sun.java2d.renderer.logCreateContext", "false");
+        return getBoolean("prism.marlin.logCreateContext", "false");
     }
 
     public static boolean isLogUnsafeMalloc() {
-        return getBoolean("sun.java2d.renderer.logUnsafeMalloc", "false");
+        return getBoolean("prism.marlin.logUnsafeMalloc", "false");
     }
 
     // system property utilities
     static boolean getBoolean(final String key, final String def) {
         return Boolean.valueOf(AccessController.doPrivileged(
-                  new GetPropertyAction(key, def)));
+            (PrivilegedAction<String>) () -> {
+                String value = System.getProperty(key);
+                return (value == null) ? def : value;
+            }));
     }
 
     static int getInteger(final String key, final int def,
                                  final int min, final int max)
     {
         final String property = AccessController.doPrivileged(
-                                    new GetPropertyAction(key));
+                    (PrivilegedAction<String>) () -> System.getProperty(key));
 
         int value = def;
         if (property != null) {
             try {
                 value = Integer.decode(property);
< prev index next >