source: trunk/src/org/expeditee/gio/swing/SwingFontManager.java@ 1125

package org.expeditee.gio.swing;

import java.awt.GraphicsEnvironment;
import java.io.File;
import java.util.HashMap;
import java.util.HashSet;

import org.expeditee.core.Font;
import org.expeditee.gio.FontManager;

/**
 * The font manager for a Swing system.
 * 
 * @author cts16
 */
public class SwingFontManager extends FontManager {
        
        private static final String DEFAULT_SWING_FONT = DEFAULT_FONT_FAMILY + "-Plain-" + DEFAULT_FONT_SIZE;
        
        /** Singleton instance. */
        private static SwingFontManager _instance = null;
        
        /** Singleton instantiator. */
        public static SwingFontManager getInstance()
        {
                if (_instance == null) _instance = new SwingFontManager();
                
                return _instance;
        }
        
        /** Mapping from handles to internal fonts. */
        private HashMap<Font, java.awt.Font> _fontMap;
        /** The font family names registered with the manager. */
        private HashSet<String> _fontNames;
        
        /** Private constructor for singleton instance. */
        private SwingFontManager()
        {
                // Initialise the font map
                _fontMap = new HashMap<Font, java.awt.Font>();
                
                // Initialise the set of family names
                _fontNames = new HashSet<String>();
                
                // Initialise default font to Swing default
                setDefaultFont(register(java.awt.Font.decode(DEFAULT_SWING_FONT)));
                
                // Add Swing standard fonts to registered fonts
                registerSwingStandardFonts();// TODO: Reinstate. cts16
        }

        @Override
        public Font registerFontFile(File fontFile)
        {
                if (fontFile == null) return null;
                
                java.awt.Font swingFont = null;
                boolean registerOkay = true;
                
                // Create the internal font from the given file
                try {
                        swingFont = java.awt.Font.createFont(java.awt.Font.TRUETYPE_FONT, fontFile);
                        if (swingFont == null) registerOkay = false;
                } catch (Exception e) {
                        registerOkay = false;
                }
                
                // Register the new font with the Swing system
                if (registerOkay) {
                        registerOkay = GraphicsEnvironment.getLocalGraphicsEnvironment().registerFont(swingFont);
                }
                
                // Register the new font with ourselves
                if (registerOkay) {
                        return register(swingFont).clone();
                }
                
                // If we made it here the registration failed
                return null;
        }

        @Override
        public String[] getRegisteredFontFamilies() {
                
                return _fontNames.toArray(new String[_fontNames.size()]);
        }

        @Override
        public boolean isFontFamilyRegistered(String fontFamily)
        {
                return _fontNames.contains(fontFamily);
        }

        @Override
        public Font getActualFont(Font font)
        {
                return extractFontForInternalFont(register(font));
        }
        
        /** Gets a string for the font style in the form expected by java.awt.Font.decode(String). */
        private String getStringForStyle(Font.Style style)
        {
                if (style == Font.Style.BOLD_ITALIC) return "BOLDITALIC";
                else if (style == Font.Style.BOLD) return "BOLD";
                else if (style == Font.Style.ITALIC) return "ITALIC";
                else return "PLAIN";
        }
        
        /** Registers the given handle with the manager and returns the internal font. */
        private java.awt.Font register(Font font)
        {
                if (register(null, font) == null) return null;
                
                return _fontMap.get(font);
        }

        /** Registers the given font with the manager and returns the generated handle. */
        private Font register(java.awt.Font swingFont)
        {
                return register(swingFont, null);
        }
        
        /** Registers a handle/font pair. */
        private Font register(java.awt.Font swingFont, Font font)
        {
                if (swingFont == null && font == null) return null;
                
                if (_fontMap.containsKey(font)) return font;
                
                if (font == null) {
                        font = extractFontForInternalFont(swingFont);
                } else if (swingFont == null) {
                        swingFont = java.awt.Font.decode(font.getFamilyName() + "-" + getStringForStyle(font.getStyle()) + "-" + font.getSize());
                }
                
                if (swingFont == null || font == null) return null;
                
                _fontMap.put(font, swingFont);
                _fontNames.add(swingFont.getFamily());
                
                return font;
        }
        
        /** Creates a handle to match the given Swing font. */
        private Font extractFontForInternalFont(java.awt.Font swingFont)
        {
                if (swingFont == null) return null;
                
                Font font = new Font(swingFont.getFamily());
                font.setStyle(Font.Style.PLAIN);
                if (swingFont.isBold()) font.toggleBold();
                if (swingFont.isItalic()) font.toggleItalic();
                font.setSize(swingFont.getSize());
                Number spacing = (Number) swingFont.getAttributes().get(java.awt.font.TextAttribute.TRACKING);
                if (spacing != null) font.setSpacing(spacing.floatValue());
                
                return font;
        }
        
        /** Gets the internal Swing font object for use by other Swing managers. */
        public java.awt.Font getInternalFont(Font font)
        {
                return register(font);
        }
        
        /** Registers any standard fonts available on the system with the manager. */
        private void registerSwingStandardFonts()
        {
                String[] standardFontNames = GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames();
                
                for (String name : standardFontNames) {
                        register(new Font(name));
                }
        }
}