META-INF.modules.java.desktop.classes.sun.font.FontFamily Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of java.desktop Show documentation
Show all versions of java.desktop Show documentation
Bytecoder java.desktop Module
/*
* Copyright (c) 2003, 2006, 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
familyNameMap = new ConcurrentHashMap();
private static HashMap 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.getLogger().info(
"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.getLogger().info(
"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.getLogger().info(
"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.getLogger().info(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.getLogger()
.warning("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();
}
for (int i=0; i families = familyNameMap.values();
return families.toArray(new FontFamily[0]);
}
public String toString() {
return
"Font family: " + familyName +
" plain="+plain+
" bold=" + bold +
" italic=" + italic +
" bolditalic=" + bolditalic;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy