FontFamily.java

/*
 * Copyright (c) 2003, 2020, 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
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * 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.font;

import java.io.File;
import java.awt.Font;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Locale;

public class FontFamily {

    private static ConcurrentHashMap<String, FontFamily>
        familyNameMap = new ConcurrentHashMap<String, FontFamily>();
    private static HashMap<String, FontFamily> allLocaleNames;

    protected String familyName;
    protected Font2D plain;
    protected Font2D bold;
    protected Font2D italic;
    protected Font2D bolditalic;
    protected boolean logicalFont = false;
    protected int familyRank;

    public static FontFamily getFamily(String name) {
        return familyNameMap.get(name.toLowerCase(Locale.ENGLISH));
    }

    public static String[] getAllFamilyNames() {
        return null;
    }

    /* Only for use by FontManager.deRegisterBadFont(..).
     * If this was the only font in the family, the family is removed
     * from the map
     */
    static void remove(Font2D font2D) {

        String name = font2D.getFamilyName(Locale.ENGLISH);
        FontFamily family = getFamily(name);
        if (family == null) {
            return;
        }
        if (family.plain == font2D) {
            family.plain = null;
        }
        if (family.bold == font2D) {
            family.bold = null;
        }
        if (family.italic == font2D) {
            family.italic = null;
        }
        if (family.bolditalic == font2D) {
            family.bolditalic = null;
        }
        if (family.plain == null && family.bold == null &&
            family.italic == null && family.bolditalic == null) {
            familyNameMap.remove(name);
        }
    }

    public FontFamily(String name, boolean isLogFont, int rank) {
        logicalFont = isLogFont;
        familyName = name;
        familyRank = rank;
        familyNameMap.put(name.toLowerCase(Locale.ENGLISH), this);
    }

    /* Create a family for created fonts which aren't listed in the
     * main map.
     */
    FontFamily(String name) {
        logicalFont = false;
        familyName = name;
        familyRank = Font2D.DEFAULT_RANK;
    }

    public String getFamilyName() {
        return familyName;
    }

    public int getRank() {
        return familyRank;
    }

    private boolean isFromSameSource(Font2D font) {
        if (!(font instanceof FileFont)) {
            return false;
        }

        FileFont existingFont = null;
        if (plain instanceof FileFont) {
            existingFont = (FileFont)plain;
        } else if (bold instanceof FileFont) {
            existingFont = (FileFont)bold;
        } else if (italic instanceof FileFont) {
             existingFont = (FileFont)italic;
        } else if (bolditalic instanceof FileFont) {
             existingFont = (FileFont)bolditalic;
        }
        // A family isn't created until there's a font.
        // So if we didn't find a file font it means this
        // isn't a file-based family.
        if (existingFont == null) {
            return false;
        }
        File existDir = (new File(existingFont.platName)).getParentFile();

        FileFont newFont = (FileFont)font;
        File newDir = (new File(newFont.platName)).getParentFile();
        if (existDir != null) {
            try {
                existDir = existDir.getCanonicalFile();
            } catch (IOException ignored) {}
        }
        if (newDir != null) {
            try {
                newDir = newDir.getCanonicalFile();
            } catch (IOException ignored) {}
        }
        return java.util.Objects.equals(newDir, existDir);
    }

    /*
     * We want a family to be of the same width and prefer medium/normal width.
     * Once we find a particular width we accept more of the same width
     * until we find one closer to normal when we 'evict' all existing fonts.
     * So once we see a 'normal' width font we evict all members that are not
     * normal width and then accept only new ones that are normal width.
     *
     * Once a font passes the width test we subject it to the weight test.
     * For Plain we target the weight the closest that is <= NORMAL (400)
     * For Bold we target the weight that is closest to BOLD (700).
     *
     * In the future, rather than discarding these fonts, we should
     * extend the family to include these so lookups on these properties
     * can locate them, as presently they will only be located by full name
     * based lookup.
     */

    private int familyWidth = 0;
    private boolean preferredWidth(Font2D font) {

        int newWidth = font.getWidth();

        if (familyWidth == 0) {
            familyWidth = newWidth;
            return true;
        }

        if (newWidth == familyWidth) {
            return true;
        }

        if (Math.abs(Font2D.FWIDTH_NORMAL - newWidth) <
            Math.abs(Font2D.FWIDTH_NORMAL - familyWidth))
        {
           if (FontUtilities.debugFonts()) {
               FontUtilities.logInfo(
               "Found more preferred width. New width = " + newWidth +
               " Old width = " + familyWidth + " in font " + font +
               " nulling out fonts plain: " + plain + " bold: " + bold +
               " italic: " + italic + " bolditalic: " + bolditalic);
           }
           familyWidth = newWidth;
           plain = bold = italic = bolditalic = null;
           return true;
        } else if (FontUtilities.debugFonts()) {
               FontUtilities.logInfo(
               "Family rejecting font " + font +
               " of less preferred width " + newWidth);
        }
        return false;
    }

    private boolean closerWeight(Font2D currFont, Font2D font, int style) {
        if (familyWidth != font.getWidth()) {
            return false;
        }

        if (currFont == null) {
            return true;
        }

        if (FontUtilities.debugFonts()) {
            FontUtilities.logInfo(
            "New weight for style " + style + ". Curr.font=" + currFont +
            " New font="+font+" Curr.weight="+ + currFont.getWeight()+
            " New weight="+font.getWeight());
        }

        int newWeight = font.getWeight();
        switch (style) {
            case Font.PLAIN:
            case Font.ITALIC:
                return (newWeight <= Font2D.FWEIGHT_NORMAL &&
                        newWeight > currFont.getWeight());

            case Font.BOLD:
            case Font.BOLD|Font.ITALIC:
                return (Math.abs(newWeight - Font2D.FWEIGHT_BOLD) <
                        Math.abs(currFont.getWeight() - Font2D.FWEIGHT_BOLD));

            default:
               return false;
        }
    }

    public void setFont(Font2D font, int style) {

        if (FontUtilities.isLogging()) {
            String msg;
            if (font instanceof CompositeFont) {
                msg = "Request to add " + font.getFamilyName(null) +
                      " with style " + style + " to family " + familyName;
            } else {
                msg = "Request to add " + font +
                      " with style " + style + " to family " + this;
            }
            FontUtilities.logInfo(msg);
        }
        /* Allow a lower-rank font only if its a file font
         * from the exact same source as any previous font.
         */
        if ((font.getRank() > familyRank) && !isFromSameSource(font)) {
            if (FontUtilities.isLogging()) {
                FontUtilities.logWarning("Rejecting adding " + font +
                                         " of lower rank " + font.getRank() +
                                         " to family " + this +
                                         " of rank " + familyRank);
            }
            return;
        }

        switch (style) {

        case Font.PLAIN:
            if (preferredWidth(font) && closerWeight(plain, font, style)) {
                plain = font;
            }
            break;

        case Font.BOLD:
            if (preferredWidth(font) && closerWeight(bold, font, style)) {
                bold = font;
            }
            break;

        case Font.ITALIC:
            if (preferredWidth(font) && closerWeight(italic, font, style)) {
                italic = font;
            }
            break;

        case Font.BOLD|Font.ITALIC:
            if (preferredWidth(font) && closerWeight(bolditalic, font, style)) {
                bolditalic = font;
            }
            break;

        default:
            break;
        }
    }

    public Font2D getFontWithExactStyleMatch(int style) {

        switch (style) {

        case Font.PLAIN:
            return plain;

        case Font.BOLD:
            return bold;

        case Font.ITALIC:
            return italic;

        case Font.BOLD|Font.ITALIC:
            return bolditalic;

        default:
            return null;
        }
    }

    /* REMIND: if the callers of this method are operating in an
     * environment in which not all fonts are registered, the returned
     * font may be a algorithmically styled one, where in fact if loadfonts
     * were executed, a styled font may be located. Our present "solution"
     * to this is to register all fonts in a directory and assume that this
     * registered all the styles of a font, since they would all be in the
     * same location.
     */
    public Font2D getFont(int style) {

        switch (style) {

        case Font.PLAIN:
            return plain;

        case Font.BOLD:
            if (bold != null) {
                return bold;
            } else if (plain != null && plain.canDoStyle(style)) {
                    return plain;
            } else {
                return null;
            }

        case Font.ITALIC:
            if (italic != null) {
                return italic;
            } else if (plain != null && plain.canDoStyle(style)) {
                    return plain;
            } else {
                return null;
            }

        case Font.BOLD|Font.ITALIC:
            if (bolditalic != null) {
                return bolditalic;
            } else if (bold != null && bold.canDoStyle(style)) {
                return bold;
            } else if (italic != null && italic.canDoStyle(style)) {
                    return italic;
            } else if (plain != null && plain.canDoStyle(style)) {
                    return plain;
            } else {
                return null;
            }
        default:
            return null;
        }
    }

    /* Only to be called if getFont(style) returns null
     * This method will only return null if the family is completely empty!
     * Note that it assumes the font of the style you need isn't in the
     * family. The logic here is that if we must substitute something
     * it might as well be from the same family.
     */
     Font2D getClosestStyle(int style) {

        switch (style) {
            /* if you ask for a plain font try to return a non-italic one,
             * then a italic one, finally a bold italic one */
        case Font.PLAIN:
            if (bold != null) {
                return bold;
            } else if (italic != null) {
                return italic;
            } else {
                return bolditalic;
            }

            /* if you ask for a bold font try to return a non-italic one,
             * then a bold italic one, finally an italic one */
        case Font.BOLD:
            if (plain != null) {
                return plain;
            } else if (bolditalic != null) {
                return bolditalic;
            } else {
                return italic;
            }

            /* if you ask for a italic font try to return a  bold italic one,
             * then a plain one, finally an bold one */
        case Font.ITALIC:
            if (bolditalic != null) {
                return bolditalic;
            } else if (plain != null) {
                return plain;
            } else {
                return bold;
            }

        case Font.BOLD|Font.ITALIC:
            if (italic != null) {
                return italic;
            } else if (bold != null) {
                return bold;
            } else {
                return plain;
            }
        }
        return null;
    }

    /* Font may have localized names. Store these in a separate map, so
     * that only clients who use these names need be affected.
     */
    static synchronized void addLocaleNames(FontFamily family, String[] names){
        if (allLocaleNames == null) {
            allLocaleNames = new HashMap<String, FontFamily>();
        }
        for (int i=0; i<names.length; i++) {
            allLocaleNames.put(names[i].toLowerCase(), family);
        }
    }

    public static synchronized FontFamily getLocaleFamily(String name) {
        if (allLocaleNames == null) {
            return null;
        }
        return allLocaleNames.get(name.toLowerCase());
    }

    public static FontFamily[] getAllFontFamilies() {
       Collection<FontFamily> families = familyNameMap.values();
       return families.toArray(new FontFamily[0]);
    }

    public String toString() {
        return
            "Font family: " + familyName +
            " plain="+plain+
            " bold=" + bold +
            " italic=" + italic +
            " bolditalic=" + bolditalic;

    }

}