| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * @author Ilya S. Okomin |
| * @version $Revision$ |
| */ |
| package org.apache.harmony.awt.gl.font; |
| |
| import java.awt.Font; |
| import java.awt.peer.FontPeer; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.lang.ref.ReferenceQueue; |
| import java.lang.ref.SoftReference; |
| import java.util.Enumeration; |
| import java.util.Hashtable; |
| import java.util.Locale; |
| import java.util.Properties; |
| import java.util.Vector; |
| |
| import org.apache.harmony.awt.gl.CommonGraphics2DFactory; |
| import org.apache.harmony.luni.util.NotImplementedException; |
| |
| |
| public abstract class FontManager { |
| |
| //???AWT |
| boolean NOT_IMP = false; |
| |
| /** |
| * array of font families names |
| */ |
| public String[] allFamilies; |
| |
| public static final String DEFAULT_NAME = "Default"; /* Default font name */ //$NON-NLS-1$ |
| public static final String DIALOG_NAME = "Dialog"; /* Dialog font name */ //$NON-NLS-1$ |
| |
| /** |
| * Set of constants applicable to the TrueType 'name' table. |
| */ |
| public static final byte FAMILY_NAME_ID = 1; /* Family name identifier */ |
| public static final byte FONT_NAME_ID = 4; /* Full font name identifier */ |
| public static final byte POSTSCRIPT_NAME_ID = 6; /* PostScript name identifier */ |
| public static final short ENGLISH_LANGID = 0x0409; /* English (United States)language identifier */ |
| |
| /** |
| * Set of constants describing font type. |
| */ |
| public static final byte FONT_TYPE_TT = 4; /* TrueType type (TRUETYPE_FONTTYPE) */ |
| public static final byte FONT_TYPE_T1 = 2; /* Type1 type (DEVICE_FONTTYPE) */ |
| public static final byte FONT_TYPE_UNDEF = 0; /* Undefined type */ |
| |
| // logical family types (indices in FontManager.LOGICAL_FONT_NAMES) |
| static final int DIALOG = 3; // FF_SWISS |
| static final int SANSSERIF = 1; // FF_SWISS |
| static final int DIALOGINPUT = 4; // FF_MODERN |
| static final int MONOSPACED = 2; // FF_MODERN |
| static final int SERIF = 0; // FF_ROMAN |
| |
| |
| /** |
| * FontProperty related constants. |
| */ |
| public static final String PLATFORM_FONT_NAME = "PlatformFontName"; //$NON-NLS-1$ |
| public static final String LOGICAL_FONT_NAME = "LogicalFontName"; //$NON-NLS-1$ |
| public static final String COMPONENT_INDEX = "ComponentIndex"; //$NON-NLS-1$ |
| public static final String STYLE_INDEX = "StyleIndex"; //$NON-NLS-1$ |
| |
| public static final String[] FONT_MAPPING_KEYS = { |
| "LogicalFontName.StyleName.ComponentIndex", "LogicalFontName.ComponentIndex" //$NON-NLS-1$ //$NON-NLS-2$ |
| }; |
| |
| public static final String FONT_CHARACTER_ENCODING = "fontcharset.LogicalFontName.ComponentIndex"; //$NON-NLS-1$ |
| |
| public static final String EXCLUSION_RANGES = "exclusion.LogicalFontName.ComponentIndex"; //$NON-NLS-1$ |
| |
| public static final String FONT_FILE_NAME = "filename.PlatformFontName"; //$NON-NLS-1$ |
| |
| /** |
| * Available logical font families names. |
| */ |
| public static final String[] LOGICAL_FONT_FAMILIES = { |
| "Serif", "SansSerif", "Monospaced", "Dialog", "DialogInput" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ |
| }; |
| |
| /** |
| * Available logical font names. |
| */ |
| public static final String[] LOGICAL_FONT_NAMES = { |
| "serif", "serif.plain", "serif.bold", "serif.italic", "serif.bolditalic", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ |
| "sansserif", "sansserif.plain", "sansserif.bold", "sansserif.italic", "sansserif.bolditalic", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ |
| "monospaced", "monospaced.plain", "monospaced.bold", "monospaced.italic", "monospaced.bolditalic", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ |
| "dialog", "dialog.plain", "dialog.bold", "dialog.italic", "dialog.bolditalic", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ |
| "dialoginput", "dialoginput.plain", "dialoginput.bold", "dialoginput.italic", "dialoginput.bolditalic" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ |
| }; |
| |
| /** |
| * Available logical font face names. |
| */ |
| public static final String[] LOGICAL_FONT_FACES = { |
| "Serif", "Serif.plain", "Serif.bold", "Serif.italic", "Serif.bolditalic", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ |
| "Sansserif", "Sansserif.plain", "Sansserif.bold", "Sansserif.italic", "Sansserif.bolditalic", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ |
| "Monospaced", "Monospaced.plain", "Monospaced.bold", "Monospaced.italic", "Monospaced.bolditalic", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ |
| "Dialog", "Dialog.plain", "Dialog.bold", "Dialog.italic", "Dialog.bolditalic", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ |
| "Dialoginput", "Dialoginput.plain", "Dialoginput.bold", "Dialoginput.italic", "Dialoginput.bolditalic" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ |
| }; |
| |
| /** |
| * Set of font style names. |
| * Font.getStyle() corresponds to indexes in STYLE_NAMES array. |
| */ |
| public static final String[] STYLE_NAMES = { |
| "plain", "bold", "italic", "bolditalic" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ |
| }; |
| |
| /** |
| * Logical font styles names table where font styles names used |
| * as the key and the value is the index of this style name. |
| */ |
| private static final Hashtable<String, Integer> style_keys = new Hashtable<String, Integer>(4); |
| |
| /** |
| * Initialize font styles keys table. |
| */ |
| static { |
| for (int i = 0; i < STYLE_NAMES.length; i++){ |
| style_keys.put(STYLE_NAMES[i], Integer.valueOf(i)); |
| } |
| } |
| |
| /** |
| * Return font style from the logical style name. |
| * |
| * @param lName style name of the logical face |
| */ |
| public static int getLogicalStyle(String lName){ |
| Integer value = style_keys.get(lName); |
| return value != null ? value.intValue(): -1; |
| } |
| |
| /** |
| * Set of possible "os" property values. |
| */ |
| public static final String[] OS_VALUES = { |
| "NT", "98", "2000", "Me", "XP", // For Windows //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ |
| "Redhat", "Turbo", "SuSE" // For Linux //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| }; |
| |
| /** |
| * Set of possible font.property file names. |
| * Language, Country, Encoding, OS, Version should be replaced with |
| * the values from current configuration. |
| */ |
| public static final String[] FP_FILE_NAMES = { |
| "/lib/font.properties.Language_Country_Encoding.OSVersion", //$NON-NLS-1$ |
| "/lib/font.properties.Language_Country_Encoding.OS", //$NON-NLS-1$ |
| "/lib/font.properties.Language_Country_Encoding.Version", //$NON-NLS-1$ |
| "/lib/font.properties.Language_Country_Encoding", //$NON-NLS-1$ |
| "/lib/font.properties.Language_Country.OSVersion", //$NON-NLS-1$ |
| "/lib/font.properties.Language_Country.OS", //$NON-NLS-1$ |
| "/lib/font.properties.Language_Country.Version", //$NON-NLS-1$ |
| "/lib/font.properties.Language_Country", //$NON-NLS-1$ |
| "/lib/font.properties.Language_Encoding.OSVersion", //$NON-NLS-1$ |
| "/lib/font.properties.Language_Encoding.OS", //$NON-NLS-1$ |
| "/lib/font.properties.Language_Encoding.Version", //$NON-NLS-1$ |
| "/lib/font.properties.Language_Encoding", //$NON-NLS-1$ |
| "/lib/font.properties.Language.OSVersion", //$NON-NLS-1$ |
| "/lib/font.properties.Language.OS", //$NON-NLS-1$ |
| "/lib/font.properties.Language.Version", //$NON-NLS-1$ |
| "/lib/font.properties.Language", //$NON-NLS-1$ |
| "/lib/font.properties.Encoding.OSVersion", //$NON-NLS-1$ |
| "/lib/font.properties.Encoding.OS", //$NON-NLS-1$ |
| "/lib/font.properties.Encoding.Version", //$NON-NLS-1$ |
| "/lib/font.properties.Encoding", //$NON-NLS-1$ |
| "/lib/font.properties.OSVersion", //$NON-NLS-1$ |
| "/lib/font.properties.OS", //$NON-NLS-1$ |
| "/lib/font.properties.Version", //$NON-NLS-1$ |
| "/lib/font.properties" //$NON-NLS-1$ |
| }; |
| |
| /** |
| * Table with all available font properties corresponding |
| * to the current system configuration. |
| */ |
| public Hashtable<String, Vector<FontProperty>> fProperties = new Hashtable<String, Vector<FontProperty>>(); |
| |
| public FontManager(){ |
| allFamilies = getAllFamilies(); |
| /* |
| * Creating and registering shutdown hook to free resources |
| * before object is destroyed. |
| */ |
| //???AWT |
| //DisposeNativeHook shutdownHook = new DisposeNativeHook(); |
| //Runtime.getRuntime().addShutdownHook(shutdownHook); |
| } |
| |
| /** |
| * Maximum number of unreferenced font peers to keep. |
| */ |
| public static final int EMPTY_FONTS_CAPACITY = 10; |
| |
| /** |
| * Locale - Language ID hash table. |
| */ |
| Hashtable<String, Short> tableLCID = new Hashtable<String, Short>(); |
| |
| /** |
| * Hash table that contains FontPeers instances. |
| */ |
| public Hashtable<String, HashMapReference> fontsTable = new Hashtable<String, HashMapReference>(); |
| |
| /** |
| * ReferenceQueue for HashMapReference objects to check |
| * if they were collected by garbage collector. |
| */ |
| public ReferenceQueue<FontPeer> queue = new ReferenceQueue<FontPeer>(); |
| |
| /** |
| * Singleton instance |
| */ |
| public final static FontManager inst = CommonGraphics2DFactory.inst.getFontManager(); |
| |
| /** |
| * Gets singleton instance of FontManager |
| * |
| * @return instance of FontManager implementation |
| */ |
| public static FontManager getInstance() { |
| return inst; |
| } |
| |
| /** |
| * Returns platform-dependent Font peer created from the specified |
| * Font object from the table with cached FontPeers instances. |
| * |
| * Note, this method checks whether FontPeer with specified parameters |
| * exists in the table with cached FontPeers' instances. If there is no needed |
| * instance - it is created and cached. |
| * |
| * @param fontName name of the font |
| * @param _fontStyle style of the font |
| * @param size font size |
| * |
| * @return platform dependent FontPeer implementation created from |
| * the specified parameters |
| */ |
| public FontPeer getFontPeer(String fontName, int _fontStyle, int size) { |
| updateFontsTable(); |
| |
| FontPeer peer = null; |
| String key; |
| String name; |
| int fontStyle = _fontStyle; |
| |
| int logicalIndex = getLogicalFaceIndex(fontName); |
| |
| if (logicalIndex != -1){ |
| name = getLogicalFaceFromFont(fontStyle, logicalIndex); |
| fontStyle = getStyleFromLogicalFace(name); |
| key = name.concat(String.valueOf(size)); |
| } else { |
| name = fontName; |
| key = name.concat(String.valueOf(fontStyle)). |
| concat(String.valueOf(size)); |
| } |
| |
| HashMapReference hmr = fontsTable.get(key); |
| if (hmr != null) { |
| peer = hmr.get(); |
| } |
| |
| if (peer == null) { |
| peer = createFontPeer(name, fontStyle, size, logicalIndex); |
| if (peer == null){ |
| peer = getFontPeer(DIALOG_NAME, fontStyle, size); |
| } |
| fontsTable.put(key, new HashMapReference(key, peer, queue)); |
| } |
| |
| return peer; |
| } |
| |
| /** |
| * Returns instance of font peer (logical or physical) according to the |
| * specified parameters. |
| * |
| * @param name font face name |
| * @param style style of the font |
| * @param size size of the font |
| * @param logicalIndex index of the logical face name in LOGICAL_FONT_FACES |
| * array or -1 if desired font peer is not logical. |
| */ |
| private FontPeer createFontPeer(String name, int style, int size, int logicalIndex){ |
| FontPeer peer; |
| if (logicalIndex != -1){ |
| peer = createLogicalFontPeer(name, style, size); |
| }else { |
| peer = createPhysicalFontPeer(name, style, size); |
| } |
| |
| return peer; |
| } |
| |
| /** |
| * Returns family name for logical face names as a parameter. |
| * |
| * @param faceName logical font face name |
| */ |
| public String getFamilyFromLogicalFace(String faceName){ |
| int pos = faceName.indexOf("."); //$NON-NLS-1$ |
| if (pos == -1){ |
| return faceName; |
| } |
| |
| return faceName.substring(0, pos); |
| } |
| |
| /** |
| * Returns new logical font peer for the parameters specified using font |
| * properties. |
| * |
| * @param faceName face name of the logical font |
| * @param style style of the font |
| * @param size font size |
| * |
| */ |
| private FontPeer createLogicalFontPeer(String faceName, int style, int size){ |
| String family = getFamilyFromLogicalFace(faceName); |
| FontProperty[] fps = getFontProperties(family.toLowerCase() + "." + style); //$NON-NLS-1$ |
| if (fps != null){ |
| int numFonts = fps.length; |
| FontPeerImpl[] physicalFonts = new FontPeerImpl[numFonts]; |
| for (int i = 0; i < numFonts; i++){ |
| FontProperty fp = fps[i]; |
| |
| String name = fp.getName(); |
| int fpStyle = fp.getStyle(); |
| String key = name.concat(String.valueOf(fpStyle)). |
| concat(String.valueOf(size)); |
| |
| HashMapReference hmr = fontsTable.get(key); |
| if (hmr != null) { |
| physicalFonts[i] = (FontPeerImpl)hmr.get(); |
| } |
| |
| if (physicalFonts[i] == null){ |
| physicalFonts[i] = (FontPeerImpl)createPhysicalFontPeer(name, fpStyle, size); |
| fontsTable.put(key, new HashMapReference(key, physicalFonts[i], queue)); |
| } |
| |
| if (physicalFonts[i] == null){ |
| physicalFonts[i] = (FontPeerImpl)getDefaultFont(style, size); |
| } |
| } |
| return new CompositeFont(family, faceName, style, size, fps, physicalFonts); |
| } |
| |
| // if there is no property for this logical font - default font is to be |
| // created |
| FontPeerImpl peer = (FontPeerImpl)getDefaultFont(style, size); |
| |
| return peer; |
| } |
| |
| /** |
| * Returns new physical font peer for the parameters specified using font properties |
| * This method must be overridden by subclasses implementations. |
| * |
| * @param faceName face name or family name of the font |
| * @param style style of the font |
| * @param size font size |
| * |
| */ |
| public abstract FontPeer createPhysicalFontPeer(String name, int style, int size); |
| |
| /** |
| * Returns default font peer class with "Default" name that is usually |
| * used when font with specified font names and style doesn't exsist |
| * on a system. |
| * |
| * @param style style of the font |
| * @param size size of the font |
| */ |
| public FontPeer getDefaultFont(int style, int size){ |
| updateFontsTable(); |
| |
| FontPeer peer = null; |
| String key = DEFAULT_NAME.concat(String.valueOf(style)). |
| concat(String.valueOf(size)); |
| |
| HashMapReference hmr = fontsTable.get(key); |
| if (hmr != null) { |
| peer = hmr.get(); |
| } |
| |
| if (peer == null) { |
| peer = createDefaultFont(style, size); |
| |
| ((FontPeerImpl)peer).setFamily(DEFAULT_NAME); |
| ((FontPeerImpl)peer).setPSName(DEFAULT_NAME); |
| ((FontPeerImpl)peer).setFontName(DEFAULT_NAME); |
| |
| fontsTable.put(key, new HashMapReference(key, peer, queue)); |
| } |
| |
| return peer; |
| } |
| |
| /** |
| * |
| * Returns new default font peer with "Default" name for the parameters |
| * specified. This method must be overridden by subclasses implementations. |
| * |
| * @param style style of the font |
| * @param size size of the font |
| */ |
| public abstract FontPeer createDefaultFont(int style, int size); |
| |
| /** |
| * Returns face name of the logical font, which is the result |
| * of specified font style and face style union. |
| * |
| * @param fontStyle specified style of the font |
| * @param logicalIndex index of the specified face from the |
| * LOGICAL_FONT_FACES array |
| * @return resulting face name |
| */ |
| public String getLogicalFaceFromFont(int fontStyle, int logicalIndex){ |
| int style = 0; |
| String name = LOGICAL_FONT_FACES[logicalIndex]; |
| int pos = name.indexOf("."); //$NON-NLS-1$ |
| |
| if (pos == -1){ |
| return createLogicalFace(name, fontStyle); |
| } |
| |
| String styleName = name.substring(pos+1); |
| name = name.substring(0, pos); |
| |
| // appending font style to the face style |
| style = fontStyle | getLogicalStyle(styleName); |
| |
| return createLogicalFace(name, style); |
| } |
| |
| /** |
| * Function returns style value from logical face name. |
| * |
| * @param name face name |
| * @return font style |
| */ |
| public int getStyleFromLogicalFace(String name){ |
| int style; |
| int pos = name.indexOf("."); //$NON-NLS-1$ |
| |
| if (pos == -1){ |
| return Font.PLAIN; |
| } |
| |
| String styleName = name.substring(pos+1); |
| |
| style = getLogicalStyle(styleName); |
| |
| return style; |
| } |
| |
| /** |
| * Returns logical face name corresponding to the logical |
| * family name and style of the font. |
| * |
| * @param family font family |
| * @param styleIndex index of the style name from the STYLE_NAMES array |
| */ |
| public String createLogicalFace(String family, int styleIndex){ |
| return family + "." + STYLE_NAMES[styleIndex]; //$NON-NLS-1$ |
| } |
| |
| /** |
| * Return language Id from LCID hash corresponding to the specified locale |
| * |
| * @param l specified locale |
| */ |
| public Short getLCID(Locale l){ |
| if (this.tableLCID.size() == 0){ |
| initLCIDTable(); |
| } |
| |
| return tableLCID.get(l.toString()); |
| } |
| |
| /** |
| * Platform-dependent LCID table init. |
| */ |
| public abstract void initLCIDTable(); |
| |
| /** |
| * Freeing native resources. This hook is used to avoid |
| * sudden application exit and to free resources created in native code. |
| */ |
| private class DisposeNativeHook extends Thread { |
| |
| @Override |
| public void run() { |
| try{ |
| /* Disposing native font peer's resources */ |
| Enumeration<String> kEnum = fontsTable.keys(); |
| |
| while(kEnum.hasMoreElements()){ |
| Object key = kEnum.nextElement(); |
| HashMapReference hmr = fontsTable.remove(key); |
| FontPeerImpl delPeer = (FontPeerImpl)hmr.get(); |
| |
| if ((delPeer != null) && (delPeer.getClass() != CompositeFont.class)){ |
| // there's nothing to dispose in CompositeFont objects |
| delPeer.dispose(); |
| } |
| } |
| } catch (Throwable t){ |
| throw new RuntimeException(t); |
| } |
| } |
| } |
| |
| /** |
| * Returns File object, created in a directory |
| * according to the System, where JVM is being ran. |
| * |
| * In Linux case we use ".fonts" directory (for fontconfig purpose), |
| * where font file from the stream will be stored, hence in LinuxFontManager this |
| * method is overridden. |
| * In Windows case we use Windows temp directory (default implementation) |
| * |
| */ |
| public File getTempFontFile()throws IOException{ |
| //???AWT |
| /* |
| File fontFile = File.createTempFile("jFont", ".ttf"); //$NON-NLS-1$ //$NON-NLS-2$ |
| fontFile.deleteOnExit(); |
| |
| return fontFile; |
| */ |
| if(NOT_IMP) |
| throw new NotImplementedException("getTempFontFile not Implemented"); |
| return null; |
| } |
| |
| /** |
| * Returns File object with font properties. It's name obtained using current |
| * system configuration properties and locale settings. If no appropriate |
| * file is found method returns null. |
| */ |
| public static File getFontPropertyFile(){ |
| File file = null; |
| |
| String javaHome = System.getProperty("java.home"); //$NON-NLS-1$ |
| Locale l = Locale.getDefault(); |
| String language = l.getLanguage(); |
| String country = l.getCountry(); |
| String fileEncoding = System.getProperty("file.encoding"); //$NON-NLS-1$ |
| |
| String os = System.getProperty("os.name"); //$NON-NLS-1$ |
| |
| int i = 0; |
| |
| // OS names from system properties don't match |
| // OS identifiers used in font.property files |
| for (; i < OS_VALUES.length; i++){ |
| if (os.endsWith(OS_VALUES[i])){ |
| os = OS_VALUES[i]; |
| break; |
| } |
| } |
| |
| if (i == OS_VALUES.length){ |
| os = null; |
| } |
| |
| String version = System.getProperty("os.version"); //$NON-NLS-1$ |
| String pathname; |
| |
| for (i = 0; i < FP_FILE_NAMES.length; i++){ |
| pathname = FP_FILE_NAMES[i]; |
| if (os != null){ |
| pathname = pathname.replaceFirst("OS", os); //$NON-NLS-1$ |
| } |
| |
| pathname = javaHome + pathname; |
| |
| pathname = pathname.replaceAll("Language", language). //$NON-NLS-1$ |
| replaceAll("Country", country). //$NON-NLS-1$ |
| replaceAll("Encoding", fileEncoding). //$NON-NLS-1$ |
| replaceAll("Version", version); //$NON-NLS-1$ |
| |
| file = new File(pathname); |
| |
| if (file.exists()){ |
| break; |
| } |
| } |
| |
| return file.exists() ? file : null; |
| } |
| |
| /** |
| * Returns an array of integer range values |
| * if the parameter exclusionString has format: |
| * Range |
| * Range [, exclusionString] |
| * |
| * Range: |
| * Char-Char |
| * |
| * Char: |
| * HexDigit HexDigit HexDigit HexDigit |
| * |
| * Method returns null if the specified string is null. |
| * |
| * @param exclusionString string parameter in specified format |
| */ |
| public static int[] parseIntervals(String exclusionString){ |
| int[] results = null; |
| |
| if (exclusionString == null){ |
| return null; |
| } |
| |
| String[] intervals = exclusionString.split(","); //$NON-NLS-1$ |
| |
| if (intervals != null){ |
| int num = intervals.length; |
| if (num > 0){ |
| results = new int[intervals.length << 1]; |
| for (int i = 0; i < intervals.length; i++){ |
| String ranges[] = intervals[i].split("-"); //$NON-NLS-1$ |
| results[i*2] = Integer.parseInt(ranges[0], 16); |
| results[i*2+1] = Integer.parseInt(ranges[1], 16); |
| |
| } |
| } |
| } |
| return results; |
| } |
| |
| /** |
| * Returns Properties from the properties file or null if |
| * there is an error with FileInputStream processing. |
| * |
| * @param file File object containing properties |
| */ |
| public static Properties getProperties(File file){ |
| Properties props = null; |
| FileInputStream fis = null; |
| try{ |
| fis = new FileInputStream(file); |
| props = new Properties(); |
| props.load(fis); |
| } catch (Exception e){ |
| System.out.println(e); |
| } |
| return props; |
| } |
| |
| /** |
| * Returns an array of FontProperties from the properties file |
| * with the specified property name "logical face.style". E.g. |
| * "dialog.2" corresponds to the font family Dialog with bold style. |
| * |
| * @param fpName key of the font properties in the properties set |
| */ |
| public FontProperty[] getFontProperties(String fpName){ |
| Vector<FontProperty> props = fProperties.get(fpName); |
| |
| if (props == null){ |
| return null; |
| } |
| |
| int size = props.size(); |
| |
| if (size == 0){ |
| return null; |
| } |
| |
| FontProperty[] fps = new FontProperty[size]; |
| for (int i=0; i < fps.length; i++){ |
| fps[i] = props.elementAt(i); |
| } |
| return fps; |
| } |
| |
| /** |
| * Returns index of the font name in array of font names or -1 if |
| * this font is not logical. |
| * |
| * @param fontName specified font name |
| */ |
| public static int getLogicalFaceIndex(String fontName){ |
| for (int i=0; i<LOGICAL_FONT_NAMES.length; i++ ){ |
| if (LOGICAL_FONT_NAMES[i].equalsIgnoreCase(fontName)){ |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * Returns true if specified family name is available in this |
| * GraphicsEnvironment. |
| * |
| * @param familyName the specified font family name |
| */ |
| public boolean isFamilyExist(String familyName){ |
| return (getFamilyIndex(familyName) != -1); |
| } |
| |
| /** |
| * Returns index of family name from the array of family names available in |
| * this GraphicsEnvironment or -1 if no family name was found. |
| * |
| * @param familyName specified font family name |
| */ |
| public int getFamilyIndex(String familyName){ |
| for (int i=0; i<allFamilies.length; i++ ){ |
| if (familyName.equalsIgnoreCase(allFamilies[i])){ |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * Returns family with index specified from the array of family names available in |
| * this GraphicsEnvironment. |
| * |
| * @param index index of the family in families names array |
| */ |
| public String getFamily(int index){ |
| return allFamilies[index]; |
| } |
| /** |
| * Returns index of face name from the array of face names available in |
| * this GraphicsEnvironment or -1 if no face name was found. Default return |
| * value is -1, method must be overridden by FontManager implementation. |
| * |
| * @param faceName font face name which index is to be searched |
| */ |
| public int getFaceIndex(String faceName){ |
| return -1; |
| } |
| |
| public abstract String[] getAllFamilies(); |
| |
| public abstract Font[] getAllFonts(); |
| |
| /** |
| * Class contains SoftReference instance that can be stored in the |
| * Hashtable by means of key field corresponding to it. |
| */ |
| private class HashMapReference extends SoftReference<FontPeer> { |
| |
| /** |
| * The key for Hashtable. |
| */ |
| private final String key; |
| |
| /** |
| * Creates a new soft reference with the key specified and |
| * adding this reference in the reference queue specified. |
| * |
| * @param key the key in Hashtable |
| * @param value object that corresponds to the key |
| * @param queue reference queue where reference is to be added |
| */ |
| public HashMapReference(final String key, final FontPeer value, |
| final ReferenceQueue<FontPeer> queue) { |
| super(value, queue); |
| this.key = key; |
| } |
| |
| /** |
| * Returns the key that corresponds to the SoftReference instance |
| * |
| * @return the key in Hashtable with cached references |
| */ |
| public Object getKey() { |
| return key; |
| } |
| } |
| |
| /** |
| * Removes keys from the Hashtable with font peers which corresponding |
| * HashMapReference objects were garbage collected. |
| */ |
| private void updateFontsTable() { |
| HashMapReference r; |
| //???AWT |
| //while ((r = (HashMapReference)queue.poll()) != null) { |
| // fontsTable.remove(r.getKey()); |
| //} |
| } |
| |
| } |
| |
| |