/**
* The X11 implementation of {@link FontManager}.
*/
// constants identifying XLFD and font ID fields
/*
* fontNameMap is a map from a fontID (which is a substring of an XLFD like
* "-monotype-arial-bold-r-normal-iso8859-7")
* to font file path like
* It's used in a couple of methods like
* getFileNameFomPlatformName(..) to help locate the font file.
* We use this substring of a full XLFD because the font configuration files
* define the XLFDs in a way that's easier to make into a request.
* E.g., the -0-0-0-0-p-0- reported by X is -*-%d-*-*-p-*- in the font
* configuration files. We need to remove that part for comparisons.
*/
/*
* xlfdMap is a map from a platform path like
* "-ricoh-hg gothic b-medium-r-normal--0-0-0-0-m-0-jisx0201.1976-0"
* Because there may be multiple native names, because the font is used
* to support multiple X encodings for example, the value of an entry in
* this map is always a vector where we store all the native names.
* For fonts which we don't understand the key isn't a pathname, its
* the full XLFD string like :-
* "-ricoh-hg gothic b-medium-r-normal--0-0-0-0-m-0-jisx0201.1976-0"
*/
/* xFontDirsMap is also a map from a font ID to a font filepath.
* The difference from fontNameMap is just that it does not have
* resolved symbolic links. Normally this is not interesting except
* that we need to know the directory in which a font was found to
* add it to the X font server path, since although the files may
* be linked, the fonts.dir is different and specific to the encoding
* handled by that directory. This map is nulled out after use to free
* heap space. If the optimal path is taken, such that all fonts in
* font configuration files are referenced by filename, then the font
* dir can be directly derived as its parent directory.
* If a font is used by two XLFDs, each corresponding to a different
* X11 font directory, then precautions must be taken to include both
* directories.
*/
/*
* This is the set of font directories needed to be on the X font path
* to enable AWT heavyweights to find all of the font configuration fonts.
* It is populated by :
* - awtfontpath entries in the fontconfig.properties
* - parent directories of "core" fonts used in the fontconfig.properties
* - looking up font dirs in the xFontDirsMap where the key is a fontID
* (cut down version of the XLFD read from the font configuration file).
* This set is nulled out after use to free heap space.
*/
/* These maps are used on Linux where we reference the Lucida oblique
* fonts in fontconfig files even though they aren't in the standard
* font directory. This explicitly remaps the XLFDs for these to the
* correct base font. This is needed to prevent composite fonts from
* defaulting to the Lucida Sans which is a bad substitute for the
* monospaced Lucida Sans Typewriter. Also these maps prevent the
* JRE from doing wasted work at start up.
*/
/*
* Used to eliminate redundant work. When a font directory is
* registered it added to this list. Subsequent registrations for the
* same directory can then be skipped by checking this Map.
* Access to this map is not synchronised here since creation
* of the singleton GE instance is already synchronised and that is
* the only code path that accesses this map.
*/
/* Array of directories to be added to the X11 font path.
* Used by static method called from Toolkits which use X11 fonts.
* Specifically this means MToolkit
*/
}
/**
* Takes family name property in the following format:
* "-linotype-helvetica-medium-r-normal-sans-*-%d-*-*-p-*-iso8859-1"
* and returns the name of the corresponding physical font.
* This code is used to resolve font configuration fonts, and expects
* only to get called for these fonts.
*/
/* If the FontConfig file doesn't use xlfds, or its
* FcFontConfiguration, this may be already a file name.
*/
return platName;
}
/* If the font filename has been explicitly assigned in the
* font configuration file, use it. This avoids accessing
* the wrong fonts on Linux, where different fonts (some
* of which may not be usable by 2D) may share the same
* specific font ID. It may also speed up the lookup.
*/
/* if it's headless, no xlfd should be used */
return null;
}
/* If a path is assigned in the font configuration file,
* it is required that the config file also specify using the
* new awtfontpath key the X11 font directories
* which must be added to the X11 font path to support
* AWT access to that font. For that reason we no longer
* have code here to add the parent directory to the list
* of font config dirs, since the parent directory may not
* be sufficient if fonts are symbolically linked to a
* different directory.
*
* Add this XLFD (platform name) to the list of known
* ones for this file.
*/
/* Try to be robust on Linux distros which move fonts
* around by verifying that the fileName represents a
* file that exists. If it doesn't, set it to null
* to trigger a search.
*/
}
}
} else {
}
}
}
return fileName;
}
}
/* On Linux check for the Lucida Oblique fonts */
}
}
}
if (FontUtilities.debugFonts()) {
.warning("** Registering all font paths because " +
"can't find file for " + platName);
}
if (FontUtilities.debugFonts()) {
.warning("** Finished registering all font paths");
}
}
/* Query X11 directly to see if this font is available
* as a native font.
*/
}
}
}
}
return fileName;
}
if (platformName == null) {
return null;
} else {
/* back-stop so that at least the name used in the
* font configuration file is known as a native name
*/
return natNames;
}
} else {
}
}
/* NOTE: this method needs to be executed in a privileged context.
* The superclass constructor which is the primary caller of
* this method executes entirely in such a context. Additionally
* the loadFonts() method does too. So all should be well.
*/
/* fonts.dir file format looks like :-
* 47
* Arial.ttf -monotype-arial-regular-r-normal--0-0-0-0-p-0-iso8859-1
* Arial-Bold.ttf -monotype-arial-bold-r-normal--0-0-0-0-p-0-iso8859-1
* ...
*/
if (FontUtilities.debugFonts()) {
}
try {
if (fontsDotDir.canRead()) {
st.eolIsSignificant(true);
st.resetSyntax();
for (int i=0; i < numEntries; i++) {
break;
}
break;
}
if (breakPos <= 0) {
/* On TurboLinux 8.0 a fonts.dir file had
* a line with integer value "24" which
* appeared to be the number of remaining
* entries in the file. This didn't add to
* the value on the first line of the file.
* Seemed like XFree86 didn't like this line
* much either. It failed to parse the file.
* Ignore lines like this completely, and
* don't let them count as an entry.
*/
numEntries++;
break;
}
continue;
}
/* TurboLinux 8.0 comment line: ignore.
* can't use st.commentChar('!') to just
* skip because this line mustn't count
* against numEntries.
*/
numEntries++;
break;
}
continue;
}
/* TurboLinux 8.0 uses some additional syntax to
* indicate algorithmic styling values.
* Ignore ':' separated files at the beginning
* of the fileName
*/
if (lastColon > 0) {
continue;
}
}
if (FontUtilities.debugFonts()) {
" xlfd=" + fontPart);
" sVal=" + sVal);
}
try {
/* we may have a resolved symbolic link
* this becomes important for an xlfd we
* still need to know the location it was
* found to update the X server font path
* for use by AWT heavyweights - and when 2D
* wants to use the native rasteriser.
*/
if (xFontDirsMap == null) {
xFontDirsMap = new HashMap();
}
} catch (IOException e) {
}
if (FontUtilities.debugFonts()) {
" xVal=" + xVal);
}
if (FontUtilities.debugFonts()) {
"to file:" + fullPath);
}
}
}
break;
}
}
}
}
}
} catch (IOException ioe1) {
} finally {
try {
} catch (IOException ioe2) {
}
}
}
}
public void loadFonts() {
super.loadFonts();
/* These maps are greatly expanded during a loadFonts but
* can be reset to their initial state afterwards.
* Since preferLocaleFonts() and preferProportionalFonts() will
* trigger a partial repopulating from the FontConfiguration
* it has to be the inital (empty) state for the latter two, not
* simply nulling out.
* xFontDirsMap is a special case in that the implementation
* will typically not ever need to initialise it so it can be null.
*/
xFontDirsMap = null;
}
} else {
return null;
}
}
return xlfd;
} else {
return null;
}
}
private void initObliqueLucidaFontMap() {
}
private boolean isHeadless() {
return GraphicsEnvironment.isHeadless();
}
int[] hPos = new int[14];
int hyphenCnt = 1;
int pos = 1;
if (pos != -1) {
pos++;
}
}
if (hyphenCnt != 14) {
if (FontUtilities.debugFonts()) {
}
return name; // what else can we do?
}
return retval;
}
int[] hPos = new int[14];
int hyphenCnt = 1;
int pos = 1;
if (pos != -1) {
pos++;
}
}
if (hyphenCnt != 14) {
if (FontUtilities.debugFonts()) {
}
return name; // what else can we do?
}
hPos[SLANT_FIELD]);
slant = "o";
slant = "i";
}
// workaround for #4471000
registry = "adobe";
}
return retval;
}
/**
* Returns the face name for the given XLFD.
*/
}
}
}
return fileName;
}
/* Register just the paths, (it doesn't register the fonts).
* If a font configuration file has specified a baseFontPath
* fontPath is just those directories, unless on usage we
* find it doesn't contain what we need for the logical fonts.
* Otherwise, we register all the paths on Solaris, because
* the fontPath we have here is the complete one from
* what's on the X font path (may be this should be
* changed).
* But for now what it means is that if we didn't do
* this then if the font weren't listed anywhere on the
* less complete font path we'd trigger loadFonts which
* actually registers the fonts. This may actually be
* the right thing tho' since that would also set up
* the X font path without which we wouldn't be able to
* display some "native" fonts.
* So something to revisit is that probably fontPath
* here ought to be only the X font path + jre font dir.
* loadFonts should have a separate native call to
* get the rest of the platform font path.
*
* Registering the directories can now be avoided in the
* font configuration initialisation when filename entries
* exist in the font configuration file for all fonts.
* (Perhaps a little confusingly a filename entry is
* actually keyed using the XLFD used in the font entries,
* and it maps *to* a real filename).
* In the event any are missing, registration of all
* directories will be invoked to find the real files.
*
* But registering the directory performed other
* functions such as filling in the map of all native names
* for the font. So when this method isn't invoked, they still
* must be found. This is mitigated by getNativeNames now
* being able to return at least the platform name, but mostly
* by ensuring that when a filename key is found, that
* xlfd key is stored as one of the set of platform names
* for the font. Its a set because typical font configuration
* files reference the same CJK font files using multiple
* X11 encodings. For the code that adds this to the map
* see X11GE.getFileNameFromPlatformName(..)
* If you don't get all of these then some code points may
* not use the Xserver, and will not get the PCF bitmaps
* that are available for some point sizes.
* So, in the event that there is such a problem,
* unconditionally making this call may be necessary, at
* some cost to JRE start-up
*/
try {
while (parser.hasMoreTokens()) {
}
}
} catch (NoSuchElementException e) {
}
}
// An X font spec (xlfd) includes an encoding. The same TrueType font file
// may be referenced from different X font directories in font.dir files
// to support use in multiple encodings by X apps.
// So for the purposes of font configuration logical fonts where AWT
// heavyweights need to access the font via X APIs we need to ensure that
// the directory for precisely the encodings needed by this are added to
// the x font path. This requires that we note the platform names
// specified in font configuration files and use that to identify the
// X font directory that contains a font.dir file for that platform name
// and add it to the X font path (if display is local)
// Here we make use of an already built map of xlfds to font locations
// to add the font location to the set of those required to build the
// x font path needed by AWT.
// These are added to the x font path later.
// All this is necessary because on Solaris the font.dir directories
// may contain not real font files, but symbolic links to the actual
// location but that location is not suitable for the x font path, since
// it probably doesn't have a font.dir at all and certainly not one
// with the required encodings
// If the fontconfiguration file is properly set up so that all fonts
// are mapped to files then we will never trigger initialising
// xFontDirsMap (it will be null). In this case the awtfontpath entries
// must specify all the X11 directories needed by AWT.
// Lazily initialize fontConfigDirs.
if (xFontDirsMap != null) {
}
}
return;
}
private void getPlatformFontPathFromFontConfig() {
if (fontConfigDirs == null) {
}
}
}
}
protected void registerPlatformFontsUsedByFontConfiguration() {
// Lazily initialize fontConfigDirs.
if (fontConfigDirs == null) {
return;
}
if (FontUtilities.isLinux) {
}
}
// Implements SunGraphicsEnvironment.createFontConfiguration.
/* The logic here decides whether to use a preconfigured
* fontconfig.properties file, or synthesise one using platform APIs.
* On Solaris (as opposed to OpenSolaris) we try to use the
* pre-configured ones, but if the files it specifies are missing
* we fail-safe to synthesising one. This might happen if Solaris
* changes its fonts.
* For OpenSolaris I don't expect us to ever create fontconfig files,
* so it will always synthesise. Note that if we misidentify
* OpenSolaris as Solaris, then the test for the presence of
* Solaris-only font files will correct this.
* For Linux we require an exact match of distro and version to
* use the preconfigured file, and also that it points to
* existent fonts.
* If synthesising fails, we fall back to any preconfigured file
* and do the best we can. For the commercial JDK this will be
* fine as it includes the Lucida fonts. OpenJDK should not hit
* this as the synthesis should always work on its platforms.
*/
if (FontUtilities.isOpenSolaris ||
(FontUtilities.isLinux &&
(!mFontConfig.foundOsSpecificFile() ||
!mFontConfig.fontFilesArePresent()) ||
new FcFontConfiguration(this);
if (fcFontConfig.init()) {
return fcFontConfig;
}
}
mFontConfig.init();
return mFontConfig;
}
public FontConfiguration
boolean preferPropFonts) {
return new MFontConfiguration(this,
}
isHeadless(); // make sure GE is inited, as its the X11 lock.
return getFontPathNative(noType1Fonts);
}
if (defaultPlatformFont != null) {
return defaultPlatformFont;
}
getFontConfigManager().initFontConfigFonts(false);
break;
}
}
/* Absolute last ditch attempt in the face of fontconfig problems.
* If we didn't match, pick the first, or just make something
* up so we don't NPE.
*/
} else {
}
}
return defaultPlatformFont;
}
fcManager = new FontConfigManager();
}
return fcManager;
}
}
/* The name of the font will be that of the physical font in slot,
* but by setting the handle to that of the CompositeFont it
* renders as that CompositeFont.
* It also needs to be marked as a created font which is the
* current mechanism to signal that deriveFont etc must copy
* the handle from the original font.
*/
return fuir;
}
}