mirror of
https://github.com/openjdk/jdk.git
synced 2025-09-24 04:54:40 +02:00
d090606f36
On Mac OS X, align system property "os.arch" with Apple legacy JDKs. Also, improve os.name string matching by using .contains() method instead of .startsWith(). This fix spans multiple repositories. Reviewed-by: dcubed, phh, ohair, katleman
516 lines
21 KiB
Java
516 lines
21 KiB
Java
/*
|
|
* Copyright (c) 2008, 2012, 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.awt.Font;
|
|
import java.io.BufferedReader;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.InputStreamReader;
|
|
import java.lang.ref.SoftReference;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.security.AccessController;
|
|
|
|
import java.security.PrivilegedAction;
|
|
import javax.swing.plaf.FontUIResource;
|
|
|
|
import sun.util.logging.PlatformLogger;
|
|
|
|
/**
|
|
* A collection of utility methods.
|
|
*/
|
|
public final class FontUtilities {
|
|
|
|
public static boolean isSolaris;
|
|
|
|
public static boolean isLinux;
|
|
|
|
public static boolean isMacOSX;
|
|
|
|
public static boolean isSolaris8;
|
|
|
|
public static boolean isSolaris9;
|
|
|
|
public static boolean isOpenSolaris;
|
|
|
|
public static boolean useT2K;
|
|
|
|
public static boolean isWindows;
|
|
|
|
public static boolean isOpenJDK;
|
|
|
|
static final String LUCIDA_FILE_NAME = "LucidaSansRegular.ttf";
|
|
|
|
private static boolean debugFonts = false;
|
|
private static PlatformLogger logger = null;
|
|
private static boolean logging;
|
|
|
|
// This static initializer block figures out the OS constants.
|
|
static {
|
|
|
|
AccessController.doPrivileged(new PrivilegedAction () {
|
|
public Object run() {
|
|
String osName = System.getProperty("os.name", "unknownOS");
|
|
isSolaris = osName.startsWith("SunOS");
|
|
|
|
isLinux = osName.startsWith("Linux");
|
|
|
|
isMacOSX = osName.contains("OS X"); // TODO: MacOSX
|
|
|
|
String t2kStr = System.getProperty("sun.java2d.font.scaler");
|
|
if (t2kStr != null) {
|
|
useT2K = "t2k".equals(t2kStr);
|
|
} else {
|
|
useT2K = false;
|
|
}
|
|
if (isSolaris) {
|
|
String version = System.getProperty("os.version", "0.0");
|
|
isSolaris8 = version.startsWith("5.8");
|
|
isSolaris9 = version.startsWith("5.9");
|
|
float ver = Float.parseFloat(version);
|
|
if (ver > 5.10f) {
|
|
File f = new File("/etc/release");
|
|
String line = null;
|
|
try {
|
|
FileInputStream fis = new FileInputStream(f);
|
|
InputStreamReader isr = new InputStreamReader(
|
|
fis, "ISO-8859-1");
|
|
BufferedReader br = new BufferedReader(isr);
|
|
line = br.readLine();
|
|
fis.close();
|
|
} catch (Exception ex) {
|
|
// Nothing to do here.
|
|
}
|
|
if (line != null && line.indexOf("OpenSolaris") >= 0) {
|
|
isOpenSolaris = true;
|
|
} else {
|
|
isOpenSolaris = false;
|
|
}
|
|
} else {
|
|
isOpenSolaris = false;
|
|
}
|
|
} else {
|
|
isSolaris8 = false;
|
|
isSolaris9 = false;
|
|
isOpenSolaris = false;
|
|
}
|
|
isWindows = osName.startsWith("Windows");
|
|
String jreLibDirName = System.getProperty("java.home", "")
|
|
+ File.separator + "lib";
|
|
String jreFontDirName =
|
|
jreLibDirName + File.separator + "fonts";
|
|
File lucidaFile = new File(jreFontDirName + File.separator
|
|
+ LUCIDA_FILE_NAME);
|
|
isOpenJDK = !lucidaFile.exists();
|
|
|
|
String debugLevel =
|
|
System.getProperty("sun.java2d.debugfonts");
|
|
|
|
if (debugLevel != null && !debugLevel.equals("false")) {
|
|
debugFonts = true;
|
|
logger = PlatformLogger.getLogger("sun.java2d");
|
|
if (debugLevel.equals("warning")) {
|
|
logger.setLevel(PlatformLogger.WARNING);
|
|
} else if (debugLevel.equals("severe")) {
|
|
logger.setLevel(PlatformLogger.SEVERE);
|
|
}
|
|
}
|
|
|
|
if (debugFonts) {
|
|
logger = PlatformLogger.getLogger("sun.java2d");
|
|
logging = logger.isEnabled();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Referenced by code in the JDK which wants to test for the
|
|
* minimum char code for which layout may be required.
|
|
* Note that even basic latin text can benefit from ligatures,
|
|
* eg "ffi" but we presently apply those only if explicitly
|
|
* requested with TextAttribute.LIGATURES_ON.
|
|
* The value here indicates the lowest char code for which failing
|
|
* to invoke layout would prevent acceptable rendering.
|
|
*/
|
|
public static final int MIN_LAYOUT_CHARCODE = 0x0300;
|
|
|
|
/**
|
|
* Referenced by code in the JDK which wants to test for the
|
|
* maximum char code for which layout may be required.
|
|
* Note this does not account for supplementary characters
|
|
* where the caller interprets 'layout' to mean any case where
|
|
* one 'char' (ie the java type char) does not map to one glyph
|
|
*/
|
|
public static final int MAX_LAYOUT_CHARCODE = 0x206F;
|
|
|
|
/**
|
|
* Calls the private getFont2D() method in java.awt.Font objects.
|
|
*
|
|
* @param font the font object to call
|
|
*
|
|
* @return the Font2D object returned by Font.getFont2D()
|
|
*/
|
|
public static Font2D getFont2D(Font font) {
|
|
return FontAccess.getFontAccess().getFont2D(font);
|
|
}
|
|
|
|
/**
|
|
* If there is anything in the text which triggers a case
|
|
* where char->glyph does not map 1:1 in straightforward
|
|
* left->right ordering, then this method returns true.
|
|
* Scripts which might require it but are not treated as such
|
|
* due to JDK implementations will not return true.
|
|
* ie a 'true' return is an indication of the treatment by
|
|
* the implementation.
|
|
* Whether supplementary characters should be considered is dependent
|
|
* on the needs of the caller. Since this method accepts the 'char' type
|
|
* then such chars are always represented by a pair. From a rendering
|
|
* perspective these will all (in the cases I know of) still be one
|
|
* unicode character -> one glyph. But if a caller is using this to
|
|
* discover any case where it cannot make naive assumptions about
|
|
* the number of chars, and how to index through them, then it may
|
|
* need the option to have a 'true' return in such a case.
|
|
*/
|
|
public static boolean isComplexText(char [] chs, int start, int limit) {
|
|
|
|
for (int i = start; i < limit; i++) {
|
|
if (chs[i] < MIN_LAYOUT_CHARCODE) {
|
|
continue;
|
|
}
|
|
else if (isNonSimpleChar(chs[i])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* This is almost the same as the method above, except it takes a
|
|
* char which means it may include undecoded surrogate pairs.
|
|
* The distinction is made so that code which needs to identify all
|
|
* cases in which we do not have a simple mapping from
|
|
* char->unicode character->glyph can be be identified.
|
|
* For example measurement cannot simply sum advances of 'chars',
|
|
* the caret in editable text cannot advance one 'char' at a time, etc.
|
|
* These callers really are asking for more than whether 'layout'
|
|
* needs to be run, they need to know if they can assume 1->1
|
|
* char->glyph mapping.
|
|
*/
|
|
public static boolean isNonSimpleChar(char ch) {
|
|
return
|
|
isComplexCharCode(ch) ||
|
|
(ch >= CharToGlyphMapper.HI_SURROGATE_START &&
|
|
ch <= CharToGlyphMapper.LO_SURROGATE_END);
|
|
}
|
|
|
|
/* If the character code falls into any of a number of unicode ranges
|
|
* where we know that simple left->right layout mapping chars to glyphs
|
|
* 1:1 and accumulating advances is going to produce incorrect results,
|
|
* we want to know this so the caller can use a more intelligent layout
|
|
* approach. A caller who cares about optimum performance may want to
|
|
* check the first case and skip the method call if its in that range.
|
|
* Although there's a lot of tests in here, knowing you can skip
|
|
* CTL saves a great deal more. The rest of the checks are ordered
|
|
* so that rather than checking explicitly if (>= start & <= end)
|
|
* which would mean all ranges would need to be checked so be sure
|
|
* CTL is not needed, the method returns as soon as it recognises
|
|
* the code point is outside of a CTL ranges.
|
|
* NOTE: Since this method accepts an 'int' it is asssumed to properly
|
|
* represent a CHARACTER. ie it assumes the caller has already
|
|
* converted surrogate pairs into supplementary characters, and so
|
|
* can handle this case and doesn't need to be told such a case is
|
|
* 'complex'.
|
|
*/
|
|
public static boolean isComplexCharCode(int code) {
|
|
|
|
if (code < MIN_LAYOUT_CHARCODE || code > MAX_LAYOUT_CHARCODE) {
|
|
return false;
|
|
}
|
|
else if (code <= 0x036f) {
|
|
// Trigger layout for combining diacriticals 0x0300->0x036f
|
|
return true;
|
|
}
|
|
else if (code < 0x0590) {
|
|
// No automatic layout for Greek, Cyrillic, Armenian.
|
|
return false;
|
|
}
|
|
else if (code <= 0x06ff) {
|
|
// Hebrew 0590 - 05ff
|
|
// Arabic 0600 - 06ff
|
|
return true;
|
|
}
|
|
else if (code < 0x0900) {
|
|
return false; // Syriac and Thaana
|
|
}
|
|
else if (code <= 0x0e7f) {
|
|
// if Indic, assume shaping for conjuncts, reordering:
|
|
// 0900 - 097F Devanagari
|
|
// 0980 - 09FF Bengali
|
|
// 0A00 - 0A7F Gurmukhi
|
|
// 0A80 - 0AFF Gujarati
|
|
// 0B00 - 0B7F Oriya
|
|
// 0B80 - 0BFF Tamil
|
|
// 0C00 - 0C7F Telugu
|
|
// 0C80 - 0CFF Kannada
|
|
// 0D00 - 0D7F Malayalam
|
|
// 0D80 - 0DFF Sinhala
|
|
// 0E00 - 0E7F if Thai, assume shaping for vowel, tone marks
|
|
return true;
|
|
}
|
|
else if (code < 0x0f00) {
|
|
return false;
|
|
}
|
|
else if (code <= 0x0fff) { // U+0F00 - U+0FFF Tibetan
|
|
return true;
|
|
}
|
|
else if (code < 0x1100) {
|
|
return false;
|
|
}
|
|
else if (code < 0x11ff) { // U+1100 - U+11FF Old Hangul
|
|
return true;
|
|
}
|
|
else if (code < 0x1780) {
|
|
return false;
|
|
}
|
|
else if (code <= 0x17ff) { // 1780 - 17FF Khmer
|
|
return true;
|
|
}
|
|
else if (code < 0x200c) {
|
|
return false;
|
|
}
|
|
else if (code <= 0x200d) { // zwj or zwnj
|
|
return true;
|
|
}
|
|
else if (code >= 0x202a && code <= 0x202e) { // directional control
|
|
return true;
|
|
}
|
|
else if (code >= 0x206a && code <= 0x206f) { // directional control
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static PlatformLogger getLogger() {
|
|
return logger;
|
|
}
|
|
|
|
public static boolean isLogging() {
|
|
return logging;
|
|
}
|
|
|
|
public static boolean debugFonts() {
|
|
return debugFonts;
|
|
}
|
|
|
|
|
|
// The following methods are used by Swing.
|
|
|
|
/* Revise the implementation to in fact mean "font is a composite font.
|
|
* This ensures that Swing components will always benefit from the
|
|
* fall back fonts
|
|
*/
|
|
public static boolean fontSupportsDefaultEncoding(Font font) {
|
|
return getFont2D(font) instanceof CompositeFont;
|
|
}
|
|
|
|
/**
|
|
* This method is provided for internal and exclusive use by Swing.
|
|
*
|
|
* It may be used in conjunction with fontSupportsDefaultEncoding(Font)
|
|
* In the event that a desktop properties font doesn't directly
|
|
* support the default encoding, (ie because the host OS supports
|
|
* adding support for the current locale automatically for native apps),
|
|
* then Swing calls this method to get a font which uses the specified
|
|
* font for the code points it covers, but also supports this locale
|
|
* just as the standard composite fonts do.
|
|
* Note: this will over-ride any setting where an application
|
|
* specifies it prefers locale specific composite fonts.
|
|
* The logic for this, is that this method is used only where the user or
|
|
* application has specified that the native L&F be used, and that
|
|
* we should honour that request to use the same font as native apps use.
|
|
*
|
|
* The behaviour of this method is to construct a new composite
|
|
* Font object that uses the specified physical font as its first
|
|
* component, and adds all the components of "dialog" as fall back
|
|
* components.
|
|
* The method currently assumes that only the size and style attributes
|
|
* are set on the specified font. It doesn't copy the font transform or
|
|
* other attributes because they aren't set on a font created from
|
|
* the desktop. This will need to be fixed if use is broadened.
|
|
*
|
|
* Operations such as Font.deriveFont will work properly on the
|
|
* font returned by this method for deriving a different point size.
|
|
* Additionally it tries to support a different style by calling
|
|
* getNewComposite() below. That also supports replacing slot zero
|
|
* with a different physical font but that is expected to be "rare".
|
|
* Deriving with a different style is needed because its been shown
|
|
* that some applications try to do this for Swing FontUIResources.
|
|
* Also operations such as new Font(font.getFontName(..), Font.PLAIN, 14);
|
|
* will NOT yield the same result, as the new underlying CompositeFont
|
|
* cannot be "looked up" in the font registry.
|
|
* This returns a FontUIResource as that is the Font sub-class needed
|
|
* by Swing.
|
|
* Suggested usage is something like :
|
|
* FontUIResource fuir;
|
|
* Font desktopFont = getDesktopFont(..);
|
|
* // NOTE even if fontSupportsDefaultEncoding returns true because
|
|
* // you get Tahoma and are running in an English locale, you may
|
|
* // still want to just call getCompositeFontUIResource() anyway
|
|
* // as only then will you get fallback fonts - eg for CJK.
|
|
* if (FontManager.fontSupportsDefaultEncoding(desktopFont)) {
|
|
* fuir = new FontUIResource(..);
|
|
* } else {
|
|
* fuir = FontManager.getCompositeFontUIResource(desktopFont);
|
|
* }
|
|
* return fuir;
|
|
*/
|
|
private static volatile
|
|
SoftReference<ConcurrentHashMap<PhysicalFont, CompositeFont>>
|
|
compMapRef = new SoftReference(null);
|
|
|
|
public static FontUIResource getCompositeFontUIResource(Font font) {
|
|
|
|
FontUIResource fuir = new FontUIResource(font);
|
|
Font2D font2D = FontUtilities.getFont2D(font);
|
|
|
|
if (!(font2D instanceof PhysicalFont)) {
|
|
/* Swing should only be calling this when a font is obtained
|
|
* from desktop properties, so should generally be a physical font,
|
|
* an exception might be for names like "MS Serif" which are
|
|
* automatically mapped to "Serif", so there's no need to do
|
|
* anything special in that case. But note that suggested usage
|
|
* is first to call fontSupportsDefaultEncoding(Font) and this
|
|
* method should not be called if that were to return true.
|
|
*/
|
|
return fuir;
|
|
}
|
|
|
|
FontManager fm = FontManagerFactory.getInstance();
|
|
Font2D dialog = fm.findFont2D("dialog", font.getStyle(), FontManager.NO_FALLBACK);
|
|
// Should never be null, but MACOSX fonts are not CompositeFonts
|
|
if (dialog == null || !(dialog instanceof CompositeFont)) {
|
|
return fuir;
|
|
}
|
|
CompositeFont dialog2D = (CompositeFont)dialog;
|
|
PhysicalFont physicalFont = (PhysicalFont)font2D;
|
|
ConcurrentHashMap<PhysicalFont, CompositeFont> compMap = compMapRef.get();
|
|
if (compMap == null) { // Its been collected.
|
|
compMap = new ConcurrentHashMap<PhysicalFont, CompositeFont>();
|
|
compMapRef = new SoftReference(compMap);
|
|
}
|
|
CompositeFont compFont = compMap.get(physicalFont);
|
|
if (compFont == null) {
|
|
compFont = new CompositeFont(physicalFont, dialog2D);
|
|
compMap.put(physicalFont, compFont);
|
|
}
|
|
FontAccess.getFontAccess().setFont2D(fuir, compFont.handle);
|
|
/* marking this as a created font is needed as only created fonts
|
|
* copy their creator's handles.
|
|
*/
|
|
FontAccess.getFontAccess().setCreatedFont(fuir);
|
|
return fuir;
|
|
}
|
|
|
|
/* A small "map" from GTK/fontconfig names to the equivalent JDK
|
|
* logical font name.
|
|
*/
|
|
private static final String[][] nameMap = {
|
|
{"sans", "sansserif"},
|
|
{"sans-serif", "sansserif"},
|
|
{"serif", "serif"},
|
|
{"monospace", "monospaced"}
|
|
};
|
|
|
|
public static String mapFcName(String name) {
|
|
for (int i = 0; i < nameMap.length; i++) {
|
|
if (name.equals(nameMap[i][0])) {
|
|
return nameMap[i][1];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
/* This is called by Swing passing in a fontconfig family name
|
|
* such as "sans". In return Swing gets a FontUIResource instance
|
|
* that has queried fontconfig to resolve the font(s) used for this.
|
|
* Fontconfig will if asked return a list of fonts to give the largest
|
|
* possible code point coverage.
|
|
* For now we use only the first font returned by fontconfig, and
|
|
* back it up with the most closely matching JDK logical font.
|
|
* Essentially this means pre-pending what we return now with fontconfig's
|
|
* preferred physical font. This could lead to some duplication in cases,
|
|
* if we already included that font later. We probably should remove such
|
|
* duplicates, but it is not a significant problem. It can be addressed
|
|
* later as part of creating a Composite which uses more of the
|
|
* same fonts as fontconfig. At that time we also should pay more
|
|
* attention to the special rendering instructions fontconfig returns,
|
|
* such as whether we should prefer embedded bitmaps over antialiasing.
|
|
* There's no way to express that via a Font at present.
|
|
*/
|
|
public static FontUIResource getFontConfigFUIR(String fcFamily,
|
|
int style, int size) {
|
|
|
|
String mapped = mapFcName(fcFamily);
|
|
if (mapped == null) {
|
|
mapped = "sansserif";
|
|
}
|
|
|
|
FontUIResource fuir;
|
|
FontManager fm = FontManagerFactory.getInstance();
|
|
if (fm instanceof SunFontManager) {
|
|
SunFontManager sfm = (SunFontManager) fm;
|
|
fuir = sfm.getFontConfigFUIR(mapped, style, size);
|
|
} else {
|
|
fuir = new FontUIResource(mapped, style, size);
|
|
}
|
|
return fuir;
|
|
}
|
|
|
|
|
|
/**
|
|
* Used by windows printing to assess if a font is likely to
|
|
* be layout compatible with JDK
|
|
* TrueType fonts should be, but if they have no GPOS table,
|
|
* but do have a GSUB table, then they are probably older
|
|
* fonts GDI handles differently.
|
|
*/
|
|
public static boolean textLayoutIsCompatible(Font font) {
|
|
|
|
Font2D font2D = getFont2D(font);
|
|
if (font2D instanceof TrueTypeFont) {
|
|
TrueTypeFont ttf = (TrueTypeFont) font2D;
|
|
return
|
|
ttf.getDirectoryEntry(TrueTypeFont.GSUBTag) == null ||
|
|
ttf.getDirectoryEntry(TrueTypeFont.GPOSTag) != null;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
}
|