1 /*
   2  * Copyright (c) 2009, 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.GraphicsEnvironment;
  29 import java.io.BufferedReader;
  30 import java.io.File;
  31 import java.io.FileReader;
  32 import java.io.IOException;
  33 import java.io.StreamTokenizer;
  34 import java.util.HashMap;
  35 import java.util.HashSet;
  36 import java.util.Locale;
  37 import java.util.Map;
  38 import java.util.NoSuchElementException;
  39 import java.util.StringTokenizer;
  40 import java.util.Vector;
  41 
  42 import javax.swing.plaf.FontUIResource;
  43 import sun.awt.motif.MFontConfiguration;
  44 import sun.font.CompositeFont;
  45 import sun.font.FontManager;
  46 import sun.font.SunFontManager;
  47 import sun.font.FontConfigManager;
  48 import sun.font.FcFontConfiguration;
  49 import sun.font.FontAccess;
  50 import sun.font.FontUtilities;
  51 import sun.font.NativeFont;
  52 import sun.util.logging.PlatformLogger;
  53 
  54 /**
  55  * The X11 implementation of {@link FontManager}.
  56  */
  57 public final class X11FontManager extends FcFontManager {
  58 
  59     // constants identifying XLFD and font ID fields
  60     private static final int FOUNDRY_FIELD = 1;
  61     private static final int FAMILY_NAME_FIELD = 2;
  62     private static final int WEIGHT_NAME_FIELD = 3;
  63     private static final int SLANT_FIELD = 4;
  64     private static final int SETWIDTH_NAME_FIELD = 5;
  65     private static final int ADD_STYLE_NAME_FIELD = 6;
  66     private static final int PIXEL_SIZE_FIELD = 7;
  67     private static final int POINT_SIZE_FIELD = 8;
  68     private static final int RESOLUTION_X_FIELD = 9;
  69     private static final int RESOLUTION_Y_FIELD = 10;
  70     private static final int SPACING_FIELD = 11;
  71     private static final int AVERAGE_WIDTH_FIELD = 12;
  72     private static final int CHARSET_REGISTRY_FIELD = 13;
  73     private static final int CHARSET_ENCODING_FIELD = 14;
  74 
  75     /*
  76      * fontNameMap is a map from a fontID (which is a substring of an XLFD like
  77      * "-monotype-arial-bold-r-normal-iso8859-7")
  78      * to font file path like
  79      * /usr/openwin/lib/locale/iso_8859_7/X11/fonts/TrueType/ArialBoldItalic.ttf
  80      * It's used in a couple of methods like
  81      * getFileNameFomPlatformName(..) to help locate the font file.
  82      * We use this substring of a full XLFD because the font configuration files
  83      * define the XLFDs in a way that's easier to make into a request.
  84      * E.g., the -0-0-0-0-p-0- reported by X is -*-%d-*-*-p-*- in the font
  85      * configuration files. We need to remove that part for comparisons.
  86      */
  87     private static Map<String, String> fontNameMap = new HashMap<>();
  88 
  89     /*
  90      * xlfdMap is a map from a platform path like
  91      * /usr/openwin/lib/locale/ja/X11/fonts/TT/HG-GothicB.ttf to an XLFD like
  92      * "-ricoh-hg gothic b-medium-r-normal--0-0-0-0-m-0-jisx0201.1976-0"
  93      * Because there may be multiple native names, because the font is used
  94      * to support multiple X encodings for example, the value of an entry in
  95      * this map is always a vector where we store all the native names.
  96      * For fonts which we don't understand the key isn't a pathname, its
  97      * the full XLFD string like :-
  98      * "-ricoh-hg gothic b-medium-r-normal--0-0-0-0-m-0-jisx0201.1976-0"
  99      */
 100     private static Map<String, Vector<String>> xlfdMap = new HashMap<>();
 101 
 102     /* xFontDirsMap is also a map from a font ID to a font filepath.
 103      * The difference from fontNameMap is just that it does not have
 104      * resolved symbolic links. Normally this is not interesting except
 105      * that we need to know the directory in which a font was found to
 106      * add it to the X font server path, since although the files may
 107      * be linked, the fonts.dir is different and specific to the encoding
 108      * handled by that directory. This map is nulled out after use to free
 109      * heap space. If the optimal path is taken, such that all fonts in
 110      * font configuration files are referenced by filename, then the font
 111      * dir can be directly derived as its parent directory.
 112      * If a font is used by two XLFDs, each corresponding to a different
 113      * X11 font directory, then precautions must be taken to include both
 114      * directories.
 115      */
 116      private static Map<String, String> xFontDirsMap;
 117 
 118      /*
 119       * This is the set of font directories needed to be on the X font path
 120       * to enable AWT heavyweights to find all of the font configuration fonts.
 121       * It is populated by :
 122       * - awtfontpath entries in the fontconfig.properties
 123       * - parent directories of "core" fonts used in the fontconfig.properties
 124       * - looking up font dirs in the xFontDirsMap where the key is a fontID
 125       *   (cut down version of the XLFD read from the font configuration file).
 126       * This set is nulled out after use to free heap space.
 127       */
 128      private static HashSet<String> fontConfigDirs = null;
 129 
 130     /* These maps are used on Linux where we reference the Lucida oblique
 131      * fonts in fontconfig files even though they aren't in the standard
 132      * font directory. This explicitly remaps the XLFDs for these to the
 133      * correct base font. This is needed to prevent composite fonts from
 134      * defaulting to the Lucida Sans which is a bad substitute for the
 135      * monospaced Lucida Sans Typewriter. Also these maps prevent the
 136      * JRE from doing wasted work at start up.
 137      */
 138     HashMap<String, String> oblmap = null;
 139 
 140 
 141     /*
 142      * Used to eliminate redundant work. When a font directory is
 143      * registered it added to this list. Subsequent registrations for the
 144      * same directory can then be skipped by checking this Map.
 145      * Access to this map is not synchronised here since creation
 146      * of the singleton GE instance is already synchronised and that is
 147      * the only code path that accesses this map.
 148      */
 149      private static HashMap<String, Object> registeredDirs = new HashMap<>();
 150 
 151      /* Array of directories to be added to the X11 font path.
 152       * Used by static method called from Toolkits which use X11 fonts.
 153       * Specifically this means MToolkit
 154       */
 155      private static String[] fontdirs = null;
 156 
 157     public static X11FontManager getInstance() {
 158         return (X11FontManager) SunFontManager.getInstance();
 159     }
 160 
 161     /**
 162      * Takes family name property in the following format:
 163      * "-linotype-helvetica-medium-r-normal-sans-*-%d-*-*-p-*-iso8859-1"
 164      * and returns the name of the corresponding physical font.
 165      * This code is used to resolve font configuration fonts, and expects
 166      * only to get called for these fonts.
 167      */
 168     @Override
 169     public String getFileNameFromPlatformName(String platName) {
 170 
 171         /* If the FontConfig file doesn't use xlfds, or its
 172          * FcFontConfiguration, this may be already a file name.
 173          */
 174         if (platName.startsWith("/")) {
 175             return platName;
 176         }
 177 
 178         String fileName = null;
 179         String fontID = specificFontIDForName(platName);
 180 
 181         /* If the font filename has been explicitly assigned in the
 182          * font configuration file, use it. This avoids accessing
 183          * the wrong fonts on Linux, where different fonts (some
 184          * of which may not be usable by 2D) may share the same
 185          * specific font ID. It may also speed up the lookup.
 186          */
 187         fileName = super.getFileNameFromPlatformName(platName);
 188         if (fileName != null) {
 189             if (isHeadless() && fileName.startsWith("-")) {
 190                 /* if it's headless, no xlfd should be used */
 191                     return null;
 192             }
 193             if (fileName.startsWith("/")) {
 194                 /* If a path is assigned in the font configuration file,
 195                  * it is required that the config file also specify using the
 196                  * new awtfontpath key the X11 font directories
 197                  * which must be added to the X11 font path to support
 198                  * AWT access to that font. For that reason we no longer
 199                  * have code here to add the parent directory to the list
 200                  * of font config dirs, since the parent directory may not
 201                  * be sufficient if fonts are symbolically linked to a
 202                  * different directory.
 203                  *
 204                  * Add this XLFD (platform name) to the list of known
 205                  * ones for this file.
 206                  */
 207                 Vector<String> xVal = xlfdMap.get(fileName);
 208                 if (xVal == null) {
 209                     /* Try to be robust on Linux distros which move fonts
 210                      * around by verifying that the fileName represents a
 211                      * file that exists.  If it doesn't, set it to null
 212                      * to trigger a search.
 213                      */
 214                     if (getFontConfiguration().needToSearchForFile(fileName)) {
 215                         fileName = null;
 216                     }
 217                     if (fileName != null) {
 218                         xVal = new Vector<>();
 219                         xVal.add(platName);
 220                         xlfdMap.put(fileName, xVal);
 221                     }
 222                 } else {
 223                     if (!xVal.contains(platName)) {
 224                         xVal.add(platName);
 225                     }
 226                 }
 227             }
 228             if (fileName != null) {
 229                 fontNameMap.put(fontID, fileName);
 230                 return fileName;
 231             }
 232         }
 233 
 234         if (fontID != null) {
 235             fileName = fontNameMap.get(fontID);
 236             /* On Linux check for the Lucida Oblique fonts */
 237             if (fileName == null && FontUtilities.isLinux && !isOpenJDK()) {
 238                 if (oblmap == null) {
 239                     initObliqueLucidaFontMap();
 240                 }
 241                 String oblkey = getObliqueLucidaFontID(fontID);
 242                 if (oblkey != null) {
 243                     fileName = oblmap.get(oblkey);
 244                 }
 245             }
 246             if (fontPath == null &&
 247                 (fileName == null || !fileName.startsWith("/"))) {
 248                 if (FontUtilities.debugFonts()) {
 249                     FontUtilities.getLogger()
 250                           .warning("** Registering all font paths because " +
 251                                    "can't find file for " + platName);
 252                 }
 253                 fontPath = getPlatformFontPath(noType1Font);
 254                 registerFontDirs(fontPath);
 255                 if (FontUtilities.debugFonts()) {
 256                     FontUtilities.getLogger()
 257                             .warning("** Finished registering all font paths");
 258                 }
 259                 fileName = fontNameMap.get(fontID);
 260             }
 261             if (fileName == null && !isHeadless()) {
 262                 /* Query X11 directly to see if this font is available
 263                  * as a native font.
 264                  */
 265                 fileName = getX11FontName(platName);
 266             }
 267             if (fileName == null) {
 268                 fontID = switchFontIDForName(platName);
 269                 fileName = fontNameMap.get(fontID);
 270             }
 271             if (fileName != null) {
 272                 fontNameMap.put(fontID, fileName);
 273             }
 274         }
 275         return fileName;
 276     }
 277 
 278     @Override
 279     protected String[] getNativeNames(String fontFileName,
 280             String platformName) {
 281         Vector<String> nativeNames;
 282         if ((nativeNames=xlfdMap.get(fontFileName))==null) {
 283             if (platformName == null) {
 284                 return null;
 285             } else {
 286                 /* back-stop so that at least the name used in the
 287                  * font configuration file is known as a native name
 288                  */
 289                 String []natNames = new String[1];
 290                 natNames[0] = platformName;
 291                 return natNames;
 292             }
 293         } else {
 294             int len = nativeNames.size();
 295             return nativeNames.toArray(new String[len]);
 296         }
 297     }
 298 
 299     /* NOTE: this method needs to be executed in a privileged context.
 300      * The superclass constructor which is the primary caller of
 301      * this method executes entirely in such a context. Additionally
 302      * the loadFonts() method does too. So all should be well.
 303 
 304      */
 305     @Override
 306     protected void registerFontDir(String path) {
 307         /* fonts.dir file format looks like :-
 308          * 47
 309          * Arial.ttf -monotype-arial-regular-r-normal--0-0-0-0-p-0-iso8859-1
 310          * Arial-Bold.ttf -monotype-arial-bold-r-normal--0-0-0-0-p-0-iso8859-1
 311          * ...
 312          */
 313         if (FontUtilities.debugFonts()) {
 314             FontUtilities.getLogger().info("ParseFontDir " + path);
 315         }
 316         File fontsDotDir = new File(path + File.separator + "fonts.dir");
 317         FileReader fr = null;
 318         try {
 319             if (fontsDotDir.canRead()) {
 320                 fr = new FileReader(fontsDotDir);
 321                 BufferedReader br = new BufferedReader(fr, 8192);
 322                 StreamTokenizer st = new StreamTokenizer(br);
 323                 st.eolIsSignificant(true);
 324                 int ttype = st.nextToken();
 325                 if (ttype == StreamTokenizer.TT_NUMBER) {
 326                     int numEntries = (int)st.nval;
 327                     ttype = st.nextToken();
 328                     if (ttype == StreamTokenizer.TT_EOL) {
 329                         st.resetSyntax();
 330                         st.wordChars(32, 127);
 331                         st.wordChars(128 + 32, 255);
 332                         st.whitespaceChars(0, 31);
 333 
 334                         for (int i=0; i < numEntries; i++) {
 335                             ttype = st.nextToken();
 336                             if (ttype == StreamTokenizer.TT_EOF) {
 337                                 break;
 338                             }
 339                             if (ttype != StreamTokenizer.TT_WORD) {
 340                                 break;
 341                             }
 342                             int breakPos = st.sval.indexOf(' ');
 343                             if (breakPos <= 0) {
 344                                 /* On TurboLinux 8.0 a fonts.dir file had
 345                                  * a line with integer value "24" which
 346                                  * appeared to be the number of remaining
 347                                  * entries in the file. This didn't add to
 348                                  * the value on the first line of the file.
 349                                  * Seemed like XFree86 didn't like this line
 350                                  * much either. It failed to parse the file.
 351                                  * Ignore lines like this completely, and
 352                                  * don't let them count as an entry.
 353                                  */
 354                                 numEntries++;
 355                                 ttype = st.nextToken();
 356                                 if (ttype != StreamTokenizer.TT_EOL) {
 357                                     break;
 358                                 }
 359 
 360                                 continue;
 361                             }
 362                             if (st.sval.charAt(0) == '!') {
 363                                 /* TurboLinux 8.0 comment line: ignore.
 364                                  * can't use st.commentChar('!') to just
 365                                  * skip because this line mustn't count
 366                                  * against numEntries.
 367                                  */
 368                                 numEntries++;
 369                                 ttype = st.nextToken();
 370                                 if (ttype != StreamTokenizer.TT_EOL) {
 371                                     break;
 372                                 }
 373                                 continue;
 374                             }
 375                             String fileName = st.sval.substring(0, breakPos);
 376                             /* TurboLinux 8.0 uses some additional syntax to
 377                              * indicate algorithmic styling values.
 378                              * Ignore ':' separated files at the beginning
 379                              * of the fileName
 380                              */
 381                             int lastColon = fileName.lastIndexOf(':');
 382                             if (lastColon > 0) {
 383                                 if (lastColon+1 >= fileName.length()) {
 384                                     continue;
 385                                 }
 386                                 fileName = fileName.substring(lastColon+1);
 387                             }
 388                             String fontPart = st.sval.substring(breakPos+1);
 389                             String fontID = specificFontIDForName(fontPart);
 390                             String sVal = fontNameMap.get(fontID);
 391 
 392                             if (FontUtilities.debugFonts()) {
 393                                 PlatformLogger logger = FontUtilities.getLogger();
 394                                 logger.info("file=" + fileName +
 395                                             " xlfd=" + fontPart);
 396                                 logger.info("fontID=" + fontID +
 397                                             " sVal=" + sVal);
 398                             }
 399                             String fullPath = null;
 400                             try {
 401                                 File file = new File(path,fileName);
 402                                 /* we may have a resolved symbolic link
 403                                  * this becomes important for an xlfd we
 404                                  * still need to know the location it was
 405                                  * found to update the X server font path
 406                                  * for use by AWT heavyweights - and when 2D
 407                                  * wants to use the native rasteriser.
 408                                  */
 409                                 if (xFontDirsMap == null) {
 410                                     xFontDirsMap = new HashMap<>();
 411                                 }
 412                                 xFontDirsMap.put(fontID, path);
 413                                 fullPath = file.getCanonicalPath();
 414                             } catch (IOException e) {
 415                                 fullPath = path + File.separator + fileName;
 416                             }
 417                             Vector<String> xVal = xlfdMap.get(fullPath);
 418                             if (FontUtilities.debugFonts()) {
 419                                 FontUtilities.getLogger()
 420                                       .info("fullPath=" + fullPath +
 421                                             " xVal=" + xVal);
 422                             }
 423                             if ((xVal == null || !xVal.contains(fontPart)) &&
 424                                 (sVal == null) || !sVal.startsWith("/")) {
 425                                 if (FontUtilities.debugFonts()) {
 426                                     FontUtilities.getLogger()
 427                                           .info("Map fontID:"+fontID +
 428                                                 "to file:" + fullPath);
 429                                 }
 430                                 fontNameMap.put(fontID, fullPath);
 431                                 if (xVal == null) {
 432                                     xVal = new Vector<>();
 433                                     xlfdMap.put (fullPath, xVal);
 434                                 }
 435                                 xVal.add(fontPart);
 436                             }
 437 
 438                             ttype = st.nextToken();
 439                             if (ttype != StreamTokenizer.TT_EOL) {
 440                                 break;
 441                             }
 442                         }
 443                     }
 444                 }
 445                 fr.close();
 446             }
 447         } catch (IOException ioe1) {
 448         } finally {
 449             if (fr != null) {
 450                 try {
 451                     fr.close();
 452                 }  catch (IOException ioe2) {
 453                 }
 454             }
 455         }
 456     }
 457 
 458     @Override
 459     public void loadFonts() {
 460         super.loadFonts();
 461         /* These maps are greatly expanded during a loadFonts but
 462          * can be reset to their initial state afterwards.
 463          * Since preferLocaleFonts() and preferProportionalFonts() will
 464          * trigger a partial repopulating from the FontConfiguration
 465          * it has to be the inital (empty) state for the latter two, not
 466          * simply nulling out.
 467          * xFontDirsMap is a special case in that the implementation
 468          * will typically not ever need to initialise it so it can be null.
 469          */
 470         xFontDirsMap = null;
 471         xlfdMap = new HashMap<>(1);
 472         fontNameMap = new HashMap<>(1);
 473     }
 474 
 475     private String getObliqueLucidaFontID(String fontID) {
 476         if (fontID.startsWith("-lucidasans-medium-i-normal") ||
 477             fontID.startsWith("-lucidasans-bold-i-normal") ||
 478             fontID.startsWith("-lucidatypewriter-medium-i-normal") ||
 479             fontID.startsWith("-lucidatypewriter-bold-i-normal")) {
 480             return fontID.substring(0, fontID.indexOf("-i-"));
 481         } else {
 482             return null;
 483         }
 484     }
 485 
 486     private static String getX11FontName(String platName) {
 487         String xlfd = platName.replaceAll("%d", "*");
 488         if (NativeFont.fontExists(xlfd)) {
 489             return xlfd;
 490         } else {
 491             return null;
 492         }
 493     }
 494 
 495     private void initObliqueLucidaFontMap() {
 496         oblmap = new HashMap<String, String>();
 497         oblmap.put("-lucidasans-medium",
 498                    jreLibDirName+"/fonts/LucidaSansRegular.ttf");
 499         oblmap.put("-lucidasans-bold",
 500                    jreLibDirName+"/fonts/LucidaSansDemiBold.ttf");
 501         oblmap.put("-lucidatypewriter-medium",
 502                    jreLibDirName+"/fonts/LucidaTypewriterRegular.ttf");
 503         oblmap.put("-lucidatypewriter-bold",
 504                    jreLibDirName+"/fonts/LucidaTypewriterBold.ttf");
 505     }
 506 
 507     private boolean isHeadless() {
 508         GraphicsEnvironment ge =
 509             GraphicsEnvironment.getLocalGraphicsEnvironment();
 510         return GraphicsEnvironment.isHeadless();
 511     }
 512 
 513     private String specificFontIDForName(String name) {
 514 
 515         int[] hPos = new int[14];
 516         int hyphenCnt = 1;
 517         int pos = 1;
 518 
 519         while (pos != -1 && hyphenCnt < 14) {
 520             pos = name.indexOf('-', pos);
 521             if (pos != -1) {
 522                 hPos[hyphenCnt++] = pos;
 523                     pos++;
 524             }
 525         }
 526 
 527         if (hyphenCnt != 14) {
 528             if (FontUtilities.debugFonts()) {
 529                 FontUtilities.getLogger()
 530                     .severe("Font Configuration Font ID is malformed:" + name);
 531             }
 532             return name; // what else can we do?
 533         }
 534 
 535         StringBuffer sb =
 536             new StringBuffer(name.substring(hPos[FAMILY_NAME_FIELD-1],
 537                                             hPos[SETWIDTH_NAME_FIELD]));
 538         sb.append(name.substring(hPos[CHARSET_REGISTRY_FIELD-1]));
 539         String retval = sb.toString().toLowerCase (Locale.ENGLISH);
 540         return retval;
 541     }
 542 
 543     private String switchFontIDForName(String name) {
 544 
 545         int[] hPos = new int[14];
 546         int hyphenCnt = 1;
 547         int pos = 1;
 548 
 549         while (pos != -1 && hyphenCnt < 14) {
 550             pos = name.indexOf('-', pos);
 551             if (pos != -1) {
 552                 hPos[hyphenCnt++] = pos;
 553                     pos++;
 554             }
 555         }
 556 
 557         if (hyphenCnt != 14) {
 558             if (FontUtilities.debugFonts()) {
 559                 FontUtilities.getLogger()
 560                     .severe("Font Configuration Font ID is malformed:" + name);
 561             }
 562             return name; // what else can we do?
 563         }
 564 
 565         String slant = name.substring(hPos[SLANT_FIELD-1]+1,
 566                                            hPos[SLANT_FIELD]);
 567         String family = name.substring(hPos[FAMILY_NAME_FIELD-1]+1,
 568                                            hPos[FAMILY_NAME_FIELD]);
 569         String registry = name.substring(hPos[CHARSET_REGISTRY_FIELD-1]+1,
 570                                            hPos[CHARSET_REGISTRY_FIELD]);
 571         String encoding = name.substring(hPos[CHARSET_ENCODING_FIELD-1]+1);
 572 
 573         if (slant.equals("i")) {
 574             slant = "o";
 575         } else if (slant.equals("o")) {
 576             slant = "i";
 577         }
 578         // workaround for #4471000
 579         if (family.equals("itc zapfdingbats")
 580             && registry.equals("sun")
 581             && encoding.equals("fontspecific")){
 582             registry = "adobe";
 583         }
 584         StringBuffer sb =
 585             new StringBuffer(name.substring(hPos[FAMILY_NAME_FIELD-1],
 586                                             hPos[SLANT_FIELD-1]+1));
 587         sb.append(slant);
 588         sb.append(name.substring(hPos[SLANT_FIELD],
 589                                  hPos[SETWIDTH_NAME_FIELD]+1));
 590         sb.append(registry);
 591         sb.append(name.substring(hPos[CHARSET_ENCODING_FIELD-1]));
 592         String retval = sb.toString().toLowerCase (Locale.ENGLISH);
 593         return retval;
 594     }
 595 
 596     /**
 597      * Returns the face name for the given XLFD.
 598      */
 599     public String getFileNameFromXLFD(String name) {
 600         String fileName = null;
 601         String fontID = specificFontIDForName(name);
 602         if (fontID != null) {
 603             fileName = fontNameMap.get(fontID);
 604             if (fileName == null) {
 605                 fontID = switchFontIDForName(name);
 606                 fileName = fontNameMap.get(fontID);
 607             }
 608             if (fileName == null) {
 609                 fileName = getDefaultFontFile();
 610             }
 611         }
 612         return fileName;
 613     }
 614 
 615     /* Register just the paths, (it doesn't register the fonts).
 616      * If a font configuration file has specified a baseFontPath
 617      * fontPath is just those directories, unless on usage we
 618      * find it doesn't contain what we need for the logical fonts.
 619      * Otherwise, we register all the paths on Solaris, because
 620      * the fontPath we have here is the complete one from
 621      * parsing /var/sadm/install/contents, not just
 622      * what's on the X font path (may be this should be
 623      * changed).
 624      * But for now what it means is that if we didn't do
 625      * this then if the font weren't listed anywhere on the
 626      * less complete font path we'd trigger loadFonts which
 627      * actually registers the fonts. This may actually be
 628      * the right thing tho' since that would also set up
 629      * the X font path without which we wouldn't be able to
 630      * display some "native" fonts.
 631      * So something to revisit is that probably fontPath
 632      * here ought to be only the X font path + jre font dir.
 633      * loadFonts should have a separate native call to
 634      * get the rest of the platform font path.
 635      *
 636      * Registering the directories can now be avoided in the
 637      * font configuration initialisation when filename entries
 638      * exist in the font configuration file for all fonts.
 639      * (Perhaps a little confusingly a filename entry is
 640      * actually keyed using the XLFD used in the font entries,
 641      * and it maps *to* a real filename).
 642      * In the event any are missing, registration of all
 643      * directories will be invoked to find the real files.
 644      *
 645      * But registering the directory performed other
 646      * functions such as filling in the map of all native names
 647      * for the font. So when this method isn't invoked, they still
 648      * must be found. This is mitigated by getNativeNames now
 649      * being able to return at least the platform name, but mostly
 650      * by ensuring that when a filename key is found, that
 651      * xlfd key is stored as one of the set of platform names
 652      * for the font. Its a set because typical font configuration
 653      * files reference the same CJK font files using multiple
 654      * X11 encodings. For the code that adds this to the map
 655      * see X11GE.getFileNameFromPlatformName(..)
 656      * If you don't get all of these then some code points may
 657      * not use the Xserver, and will not get the PCF bitmaps
 658      * that are available for some point sizes.
 659      * So, in the event that there is such a problem,
 660      * unconditionally making this call may be necessary, at
 661      * some cost to JRE start-up
 662      */
 663     @Override
 664     protected void registerFontDirs(String pathName) {
 665 
 666         StringTokenizer parser = new StringTokenizer(pathName,
 667                                                      File.pathSeparator);
 668         try {
 669             while (parser.hasMoreTokens()) {
 670                 String dirPath = parser.nextToken();
 671                 if (dirPath != null && !registeredDirs.containsKey(dirPath)) {
 672                     registeredDirs.put(dirPath, null);
 673                     registerFontDir(dirPath);
 674                 }
 675             }
 676         } catch (NoSuchElementException e) {
 677         }
 678     }
 679 
 680     // An X font spec (xlfd) includes an encoding. The same TrueType font file
 681     // may be referenced from different X font directories in font.dir files
 682     // to support use in multiple encodings by X apps.
 683     // So for the purposes of font configuration logical fonts where AWT
 684     // heavyweights need to access the font via X APIs we need to ensure that
 685     // the directory for precisely the encodings needed by this are added to
 686     // the x font path. This requires that we note the platform names
 687     // specified in font configuration files and use that to identify the
 688     // X font directory that contains a font.dir file for that platform name
 689     // and add it to the X font path (if display is local)
 690     // Here we make use of an already built map of xlfds to font locations
 691     // to add the font location to the set of those required to build the
 692     // x font path needed by AWT.
 693     // These are added to the x font path later.
 694     // All this is necessary because on Solaris the font.dir directories
 695     // may contain not real font files, but symbolic links to the actual
 696     // location but that location is not suitable for the x font path, since
 697     // it probably doesn't have a font.dir at all and certainly not one
 698     // with the required encodings
 699     // If the fontconfiguration file is properly set up so that all fonts
 700     // are mapped to files then we will never trigger initialising
 701     // xFontDirsMap (it will be null). In this case the awtfontpath entries
 702     // must specify all the X11 directories needed by AWT.
 703     @Override
 704     protected void addFontToPlatformFontPath(String platformName) {
 705         // Lazily initialize fontConfigDirs.
 706         getPlatformFontPathFromFontConfig();
 707         if (xFontDirsMap != null) {
 708             String fontID = specificFontIDForName(platformName);
 709             String dirName = xFontDirsMap.get(fontID);
 710             if (dirName != null) {
 711                 fontConfigDirs.add(dirName);
 712             }
 713         }
 714         return;
 715     }
 716 
 717     private void getPlatformFontPathFromFontConfig() {
 718         if (fontConfigDirs == null) {
 719             fontConfigDirs = getFontConfiguration().getAWTFontPathSet();
 720             if (FontUtilities.debugFonts() && fontConfigDirs != null) {
 721                 String[] names = fontConfigDirs.toArray(new String[0]);
 722                 for (int i=0;i<names.length;i++) {
 723                     FontUtilities.getLogger().info("awtfontpath : " + names[i]);
 724                 }
 725             }
 726         }
 727     }
 728 
 729     @Override
 730     protected void registerPlatformFontsUsedByFontConfiguration() {
 731         // Lazily initialize fontConfigDirs.
 732         getPlatformFontPathFromFontConfig();
 733         if (fontConfigDirs == null) {
 734             return;
 735         }
 736         if (FontUtilities.isLinux) {
 737             fontConfigDirs.add(jreLibDirName+File.separator+"oblique-fonts");
 738         }
 739         fontdirs = fontConfigDirs.toArray(new String[0]);
 740     }
 741 
 742     // Implements SunGraphicsEnvironment.createFontConfiguration.
 743     protected FontConfiguration createFontConfiguration() {
 744         /* The logic here decides whether to use a preconfigured
 745          * fontconfig.properties file, or synthesise one using platform APIs.
 746          * On Solaris (as opposed to OpenSolaris) we try to use the
 747          * pre-configured ones, but if the files it specifies are missing
 748          * we fail-safe to synthesising one. This might happen if Solaris
 749          * changes its fonts.
 750          * For OpenSolaris I don't expect us to ever create fontconfig files,
 751          * so it will always synthesise. Note that if we misidentify
 752          * OpenSolaris as Solaris, then the test for the presence of
 753          * Solaris-only font files will correct this.
 754          * For Linux we require an exact match of distro and version to
 755          * use the preconfigured file, and also that it points to
 756          * existent fonts.
 757          * If synthesising fails, we fall back to any preconfigured file
 758          * and do the best we can. For the commercial JDK this will be
 759          * fine as it includes the Lucida fonts. OpenJDK should not hit
 760          * this as the synthesis should always work on its platforms.
 761          */
 762         FontConfiguration mFontConfig = new MFontConfiguration(this);
 763         if (FontUtilities.isOpenSolaris ||
 764             (FontUtilities.isLinux &&
 765              (!mFontConfig.foundOsSpecificFile() ||
 766               !mFontConfig.fontFilesArePresent()) ||
 767              (FontUtilities.isSolaris && !mFontConfig.fontFilesArePresent()))) {
 768             FcFontConfiguration fcFontConfig =
 769                 new FcFontConfiguration(this);
 770             if (fcFontConfig.init()) {
 771                 return fcFontConfig;
 772             }
 773         }
 774         mFontConfig.init();
 775         return mFontConfig;
 776     }
 777     public FontConfiguration
 778         createFontConfiguration(boolean preferLocaleFonts,
 779                                 boolean preferPropFonts) {
 780 
 781         return new MFontConfiguration(this,
 782                                       preferLocaleFonts, preferPropFonts);
 783     }
 784 
 785     protected synchronized String getFontPath(boolean noType1Fonts) {
 786         isHeadless(); // make sure GE is inited, as its the X11 lock.
 787         return getFontPathNative(noType1Fonts, true);
 788     }
 789 
 790     @Override
 791     protected FontUIResource getFontConfigFUIR(String family, int style, int size) {
 792 
 793         CompositeFont font2D = getFontConfigManager().getFontConfigFont(family, style);
 794 
 795         if (font2D == null) { // Not expected, just a precaution.
 796            return new FontUIResource(family, style, size);
 797         }
 798 
 799         /* The name of the font will be that of the physical font in slot,
 800          * but by setting the handle to that of the CompositeFont it
 801          * renders as that CompositeFont.
 802          * It also needs to be marked as a created font which is the
 803          * current mechanism to signal that deriveFont etc must copy
 804          * the handle from the original font.
 805          */
 806         FontUIResource fuir =
 807             new FontUIResource(font2D.getFamilyName(null), style, size);
 808         FontAccess.getFontAccess().setFont2D(fuir, font2D.handle);
 809         FontAccess.getFontAccess().setCreatedFont(fuir);
 810         return fuir;
 811     }
 812 }
--- EOF ---