rev 60064 : 8248802: Add log helper methods to FontUtilities.java

   1 /*
   2  * Copyright (c) 2008, 2020, 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.font;
  27 
  28 import java.awt.Font;




  29 import java.lang.ref.SoftReference;
  30 import java.util.concurrent.ConcurrentHashMap;
  31 import java.security.AccessController;
  32 
  33 import java.security.PrivilegedAction;
  34 import javax.swing.plaf.FontUIResource;
  35 
  36 import sun.util.logging.PlatformLogger;
  37 
  38 /**
  39  * A collection of utility methods.
  40  */
  41 public final class FontUtilities {
  42 
  43     public static boolean isLinux;
  44 
  45     public static boolean isMacOSX;
  46     public static boolean isMacOSX14;
  47 
  48     public static boolean useJDKScaler;
  49 
  50     public static boolean isWindows;
  51 
  52     private static boolean debugFonts = false;
  53     private static PlatformLogger logger = null;
  54     private static boolean logging;
  55 
  56     // This static initializer block figures out the OS constants.
  57     static {
  58 
  59         AccessController.doPrivileged(new PrivilegedAction<Object>() {
  60             @SuppressWarnings("deprecation") // PlatformLogger.setLevel is deprecated.
  61             @Override
  62             public Object run() {
  63                 String osName = System.getProperty("os.name", "unknownOS");
  64 
  65                 isLinux = osName.startsWith("Linux");
  66 
  67                 isMacOSX = osName.contains("OS X"); // TODO: MacOSX
  68                 if (isMacOSX) {
  69                     // os.version has values like 10.13.6, 10.14.6
  70                     // If it is not positively recognised as 10.13 or less,
  71                     // assume it means 10.14 or some later version.
  72                     isMacOSX14 = true;
  73                     String version = System.getProperty("os.version", "");
  74                     if (version.startsWith("10.")) {
  75                         version = version.substring(3);
  76                         int periodIndex = version.indexOf('.');
  77                         if (periodIndex != -1) {
  78                             version = version.substring(0, periodIndex);
  79                         }
  80                         try {
  81                             int v = Integer.parseInt(version);
  82                             isMacOSX14 = (v >= 14);
  83                         } catch (NumberFormatException e) {
  84                         }
  85                      }
  86                  }
  87                 /* If set to "jdk", use the JDK's scaler rather than
  88                  * the platform one. This may be a no-op on platforms where
  89                  * JDK has been configured so that it always relies on the
  90                  * platform scaler. The principal case where it has an
  91                  * effect is that on Windows, 2D will never use GDI.
  92                  */
  93                 String scalerStr = System.getProperty("sun.java2d.font.scaler");
  94                 if (scalerStr != null) {
  95                     useJDKScaler = "jdk".equals(scalerStr);
  96                 } else {
  97                     useJDKScaler = false;
  98                 }
  99                 isWindows = osName.startsWith("Windows");
 100                 String debugLevel =
 101                     System.getProperty("sun.java2d.debugfonts");
 102 
 103                 if (debugLevel != null && !debugLevel.equals("false")) {
 104                     debugFonts = true;
 105                     logger = PlatformLogger.getLogger("sun.java2d");
 106                     if (debugLevel.equals("warning")) {
 107                         logger.setLevel(PlatformLogger.Level.WARNING);
 108                     } else if (debugLevel.equals("severe")) {
 109                         logger.setLevel(PlatformLogger.Level.SEVERE);
 110                     }




 111                     logging = logger.isEnabled();
 112                 }
 113 
 114                 return null;
 115             }
 116         });
 117     }
 118 
 119     /**
 120      * Referenced by code in the JDK which wants to test for the
 121      * minimum char code for which layout may be required.
 122      * Note that even basic latin text can benefit from ligatures,
 123      * eg "ffi" but we presently apply those only if explicitly
 124      * requested with TextAttribute.LIGATURES_ON.
 125      * The value here indicates the lowest char code for which failing
 126      * to invoke layout would prevent acceptable rendering.
 127      */
 128     public static final int MIN_LAYOUT_CHARCODE = 0x0300;
 129 
 130     /**
 131      * Referenced by code in the JDK which wants to test for the
 132      * maximum char code for which layout may be required.
 133      * Note this does not account for supplementary characters
 134      * where the caller interprets 'layout' to mean any case where
 135      * one 'char' (ie the java type char) does not map to one glyph
 136      */
 137     public static final int MAX_LAYOUT_CHARCODE = 0x206F;
 138 
 139     /**
 140      * Calls the private getFont2D() method in java.awt.Font objects.
 141      *
 142      * @param font the font object to call
 143      *
 144      * @return the Font2D object returned by Font.getFont2D()
 145      */
 146     public static Font2D getFont2D(Font font) {
 147         return FontAccess.getFontAccess().getFont2D(font);
 148     }
 149 
 150     /**
 151      * Return true if there any characters which would trigger layout.
 152      * This method considers supplementary characters to be simple,
 153      * since we do not presently invoke layout on any code points in
 154      * outside the BMP.
 155      */
 156     public static boolean isComplexScript(char [] chs, int start, int limit) {
 157 
 158         for (int i = start; i < limit; i++) {
 159             if (chs[i] < MIN_LAYOUT_CHARCODE) {
 160                 continue;
 161             }
 162             else if (isComplexCharCode(chs[i])) {
 163                 return true;
 164             }
 165         }
 166         return false;
 167     }
 168 
 169     /**
 170      * If there is anything in the text which triggers a case
 171      * where char->glyph does not map 1:1 in straightforward
 172      * left->right ordering, then this method returns true.
 173      * Scripts which might require it but are not treated as such
 174      * due to JDK implementations will not return true.
 175      * ie a 'true' return is an indication of the treatment by
 176      * the implementation.
 177      * Whether supplementary characters should be considered is dependent
 178      * on the needs of the caller. Since this method accepts the 'char' type
 179      * then such chars are always represented by a pair. From a rendering
 180      * perspective these will all (in the cases I know of) still be one
 181      * unicode character -> one glyph. But if a caller is using this to
 182      * discover any case where it cannot make naive assumptions about
 183      * the number of chars, and how to index through them, then it may
 184      * need the option to have a 'true' return in such a case.
 185      */
 186     public static boolean isComplexText(char [] chs, int start, int limit) {
 187 
 188         for (int i = start; i < limit; i++) {
 189             if (chs[i] < MIN_LAYOUT_CHARCODE) {
 190                 continue;
 191             }
 192             else if (isNonSimpleChar(chs[i])) {
 193                 return true;
 194             }
 195         }
 196         return false;
 197     }
 198 
 199     /* This is almost the same as the method above, except it takes a
 200      * char which means it may include undecoded surrogate pairs.
 201      * The distinction is made so that code which needs to identify all
 202      * cases in which we do not have a simple mapping from
 203      * char->unicode character->glyph can be identified.
 204      * For example measurement cannot simply sum advances of 'chars',
 205      * the caret in editable text cannot advance one 'char' at a time, etc.
 206      * These callers really are asking for more than whether 'layout'
 207      * needs to be run, they need to know if they can assume 1->1
 208      * char->glyph mapping.
 209      */
 210     public static boolean isNonSimpleChar(char ch) {
 211         return
 212             isComplexCharCode(ch) ||
 213             (ch >= CharToGlyphMapper.HI_SURROGATE_START &&
 214              ch <= CharToGlyphMapper.LO_SURROGATE_END);
 215     }
 216 
 217     /* If the character code falls into any of a number of unicode ranges
 218      * where we know that simple left->right layout mapping chars to glyphs
 219      * 1:1 and accumulating advances is going to produce incorrect results,
 220      * we want to know this so the caller can use a more intelligent layout
 221      * approach. A caller who cares about optimum performance may want to
 222      * check the first case and skip the method call if its in that range.
 223      * Although there's a lot of tests in here, knowing you can skip
 224      * CTL saves a great deal more. The rest of the checks are ordered
 225      * so that rather than checking explicitly if (>= start & <= end)
 226      * which would mean all ranges would need to be checked so be sure
 227      * CTL is not needed, the method returns as soon as it recognises
 228      * the code point is outside of a CTL ranges.
 229      * NOTE: Since this method accepts an 'int' it is asssumed to properly
 230      * represent a CHARACTER. ie it assumes the caller has already
 231      * converted surrogate pairs into supplementary characters, and so
 232      * can handle this case and doesn't need to be told such a case is
 233      * 'complex'.
 234      */
 235     public static boolean isComplexCharCode(int code) {
 236 
 237         if (code < MIN_LAYOUT_CHARCODE || code > MAX_LAYOUT_CHARCODE) {
 238             return false;
 239         }
 240         else if (code <= 0x036f) {
 241             // Trigger layout for combining diacriticals 0x0300->0x036f
 242             return true;
 243         }
 244         else if (code < 0x0590) {
 245             // No automatic layout for Greek, Cyrillic, Armenian.
 246              return false;
 247         }
 248         else if (code <= 0x06ff) {
 249             // Hebrew 0590 - 05ff
 250             // Arabic 0600 - 06ff
 251             return true;
 252         }
 253         else if (code < 0x0900) {
 254             return false; // Syriac and Thaana
 255         }
 256         else if (code <= 0x0e7f) {
 257             // if Indic, assume shaping for conjuncts, reordering:
 258             // 0900 - 097F Devanagari
 259             // 0980 - 09FF Bengali
 260             // 0A00 - 0A7F Gurmukhi
 261             // 0A80 - 0AFF Gujarati
 262             // 0B00 - 0B7F Oriya
 263             // 0B80 - 0BFF Tamil
 264             // 0C00 - 0C7F Telugu
 265             // 0C80 - 0CFF Kannada
 266             // 0D00 - 0D7F Malayalam
 267             // 0D80 - 0DFF Sinhala
 268             // 0E00 - 0E7F if Thai, assume shaping for vowel, tone marks
 269             return true;
 270         }
 271         else if (code <  0x0f00) {
 272             return false;
 273         }
 274         else if (code <= 0x0fff) { // U+0F00 - U+0FFF Tibetan
 275             return true;
 276         }
 277         else if (code < 0x10A0) {  // U+1000 - U+109F Myanmar
 278             return true;
 279         }
 280         else if (code < 0x1100) {
 281             return false;
 282         }
 283         else if (code < 0x11ff) { // U+1100 - U+11FF Old Hangul
 284             return true;
 285         }
 286         else if (code < 0x1780) {
 287             return false;
 288         }
 289         else if (code <= 0x17ff) { // 1780 - 17FF Khmer
 290             return true;
 291         }
 292         else if (code < 0x200c) {
 293             return false;
 294         }
 295         else if (code <= 0x200d) { //  zwj or zwnj
 296             return true;
 297         }
 298         else if (code >= 0x202a && code <= 0x202e) { // directional control
 299             return true;
 300         }
 301         else if (code >= 0x206a && code <= 0x206f) { // directional control
 302             return true;
 303         }
 304         return false;
 305     }
 306 
 307     public static PlatformLogger getLogger() {
 308         return logger;
 309     }
 310 
 311     public static boolean isLogging() {
 312         return logging;
 313     }
 314 
 315     public static boolean debugFonts() {
 316         return debugFonts;
 317     }
 318 
 319     public static void logWarning(String s) {
 320         getLogger().warning(s);
 321     }
 322 
 323     public static void logInfo(String s) {
 324         getLogger().info(s);
 325     }
 326 
 327     public static void logSevere(String s) {
 328         getLogger().severe(s);
 329     }
 330 
 331     // The following methods are used by Swing.
 332 
 333     /* Revise the implementation to in fact mean "font is a composite font.
 334      * This ensures that Swing components will always benefit from the
 335      * fall back fonts
 336      */
 337     public static boolean fontSupportsDefaultEncoding(Font font) {
 338         return getFont2D(font) instanceof CompositeFont;
 339     }
 340 
 341     /**
 342      * This method is provided for internal and exclusive use by Swing.
 343      *
 344      * It may be used in conjunction with fontSupportsDefaultEncoding(Font)
 345      * In the event that a desktop properties font doesn't directly
 346      * support the default encoding, (ie because the host OS supports
 347      * adding support for the current locale automatically for native apps),
 348      * then Swing calls this method to get a font which  uses the specified
 349      * font for the code points it covers, but also supports this locale
 350      * just as the standard composite fonts do.
 351      * Note: this will over-ride any setting where an application
 352      * specifies it prefers locale specific composite fonts.
 353      * The logic for this, is that this method is used only where the user or
 354      * application has specified that the native L&F be used, and that
 355      * we should honour that request to use the same font as native apps use.
 356      *
 357      * The behaviour of this method is to construct a new composite
 358      * Font object that uses the specified physical font as its first
 359      * component, and adds all the components of "dialog" as fall back
 360      * components.
 361      * The method currently assumes that only the size and style attributes
 362      * are set on the specified font. It doesn't copy the font transform or
 363      * other attributes because they aren't set on a font created from
 364      * the desktop. This will need to be fixed if use is broadened.
 365      *
 366      * Operations such as Font.deriveFont will work properly on the
 367      * font returned by this method for deriving a different point size.
 368      * Additionally it tries to support a different style by calling
 369      * getNewComposite() below. That also supports replacing slot zero
 370      * with a different physical font but that is expected to be "rare".
 371      * Deriving with a different style is needed because its been shown
 372      * that some applications try to do this for Swing FontUIResources.
 373      * Also operations such as new Font(font.getFontName(..), Font.PLAIN, 14);
 374      * will NOT yield the same result, as the new underlying CompositeFont
 375      * cannot be "looked up" in the font registry.
 376      * This returns a FontUIResource as that is the Font sub-class needed
 377      * by Swing.
 378      * Suggested usage is something like :
 379      * FontUIResource fuir;
 380      * Font desktopFont = getDesktopFont(..);
 381      * if (FontManager.fontSupportsDefaultEncoding(desktopFont)) {
 382      *   fuir = new FontUIResource(desktopFont);
 383      * } else {
 384      *   fuir = FontManager.getCompositeFontUIResource(desktopFont);
 385      * }
 386      * return fuir;
 387      */
 388     private static volatile
 389         SoftReference<ConcurrentHashMap<PhysicalFont, CompositeFont>>
 390         compMapRef = new SoftReference<>(null);
 391 
 392     public static FontUIResource getCompositeFontUIResource(Font font) {
 393 
 394         FontUIResource fuir = new FontUIResource(font);
 395         Font2D font2D = FontUtilities.getFont2D(font);
 396 
 397         if (!(font2D instanceof PhysicalFont)) {
 398             /* Swing should only be calling this when a font is obtained
 399              * from desktop properties, so should generally be a physical font,
 400              * an exception might be for names like "MS Serif" which are
 401              * automatically mapped to "Serif", so there's no need to do
 402              * anything special in that case. But note that suggested usage
 403              * is first to call fontSupportsDefaultEncoding(Font) and this
 404              * method should not be called if that were to return true.
 405              */
 406              return fuir;
 407         }
 408 
 409         FontManager fm = FontManagerFactory.getInstance();
 410         Font2D dialog = fm.findFont2D("dialog", font.getStyle(), FontManager.NO_FALLBACK);
 411         // Should never be null, but MACOSX fonts are not CompositeFonts
 412         if (dialog == null || !(dialog instanceof CompositeFont)) {
 413             return fuir;
 414         }
 415         CompositeFont dialog2D = (CompositeFont)dialog;
 416         PhysicalFont physicalFont = (PhysicalFont)font2D;
 417         ConcurrentHashMap<PhysicalFont, CompositeFont> compMap = compMapRef.get();
 418         if (compMap == null) { // Its been collected.
 419             compMap = new ConcurrentHashMap<PhysicalFont, CompositeFont>();
 420             compMapRef = new SoftReference<>(compMap);
 421         }
 422         CompositeFont compFont = compMap.get(physicalFont);
 423         if (compFont == null) {
 424             compFont = new CompositeFont(physicalFont, dialog2D);
 425             compMap.put(physicalFont, compFont);
 426         }
 427         FontAccess.getFontAccess().setFont2D(fuir, compFont.handle);
 428         /* marking this as a created font is needed as only created fonts
 429          * copy their creator's handles.
 430          */
 431         FontAccess.getFontAccess().setCreatedFont(fuir);
 432         return fuir;
 433     }
 434 
 435    /* A small "map" from GTK/fontconfig names to the equivalent JDK
 436     * logical font name.
 437     */
 438     private static final String[][] nameMap = {
 439         {"sans",       "sansserif"},
 440         {"sans-serif", "sansserif"},
 441         {"serif",      "serif"},
 442         {"monospace",  "monospaced"}
 443     };
 444 
 445     public static String mapFcName(String name) {
 446         for (int i = 0; i < nameMap.length; i++) {
 447             if (name.equals(nameMap[i][0])) {
 448                 return nameMap[i][1];
 449             }
 450         }
 451         return null;
 452     }
 453 
 454 
 455     /* This is called by Swing passing in a fontconfig family name
 456      * such as "sans". In return Swing gets a FontUIResource instance
 457      * that has queried fontconfig to resolve the font(s) used for this.
 458      * Fontconfig will if asked return a list of fonts to give the largest
 459      * possible code point coverage.
 460      * For now we use only the first font returned by fontconfig, and
 461      * back it up with the most closely matching JDK logical font.
 462      * Essentially this means pre-pending what we return now with fontconfig's
 463      * preferred physical font. This could lead to some duplication in cases,
 464      * if we already included that font later. We probably should remove such
 465      * duplicates, but it is not a significant problem. It can be addressed
 466      * later as part of creating a Composite which uses more of the
 467      * same fonts as fontconfig. At that time we also should pay more
 468      * attention to the special rendering instructions fontconfig returns,
 469      * such as whether we should prefer embedded bitmaps over antialiasing.
 470      * There's no way to express that via a Font at present.
 471      */
 472     public static FontUIResource getFontConfigFUIR(String fcFamily,
 473                                                    int style, int size) {
 474 
 475         String mapped = mapFcName(fcFamily);
 476         if (mapped == null) {
 477             mapped = "sansserif";
 478         }
 479 
 480         FontUIResource fuir;
 481         FontManager fm = FontManagerFactory.getInstance();
 482         if (fm instanceof SunFontManager) {
 483             SunFontManager sfm = (SunFontManager) fm;
 484             fuir = sfm.getFontConfigFUIR(mapped, style, size);
 485         } else {
 486             fuir = new FontUIResource(mapped, style, size);
 487         }
 488         return fuir;
 489     }
 490 
 491 
 492     /**
 493      * Used by windows printing to assess if a font is likely to
 494      * be layout compatible with JDK
 495      * TrueType fonts should be, but if they have no GPOS table,
 496      * but do have a GSUB table, then they are probably older
 497      * fonts GDI handles differently.
 498      */
 499     public static boolean textLayoutIsCompatible(Font font) {
 500 
 501         Font2D font2D = getFont2D(font);
 502         if (font2D instanceof TrueTypeFont) {
 503             TrueTypeFont ttf = (TrueTypeFont) font2D;
 504             return
 505                 ttf.getDirectoryEntry(TrueTypeFont.GSUBTag) == null ||
 506                 ttf.getDirectoryEntry(TrueTypeFont.GPOSTag) != null;
 507         } else {
 508             return false;
 509         }
 510     }
 511 
 512 }
--- EOF ---