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

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;

        private static HashMap<String,String> _font_name_lookup = null;
    
            
        /** Singleton instantiator. */
        public static SwingFontManager getInstance()
        {
                if (_instance == null) _instance = new SwingFontManager();

                if (_font_name_lookup == null) {
                    _font_name_lookup = new HashMap<String,String>();
                    
                    java.awt.Font [] fonts = GraphicsEnvironment.getLocalGraphicsEnvironment().getAllFonts();
                    
                    for (int i=0; i<fonts.length; i++) {
                        java.awt.Font font = fonts[i];
                        String font_name = font.getFontName();
                        String font_family = font.getFamily();

                        // Instead of String->Integer hashmap, let's choose to store the
                        // font family name, in case this is useful at a later point elsewhere
                        _font_name_lookup.put(font_name,font_family); 
                    }
                }
                
                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) {
                        System.err.println("Warning: createFont() failed for:\n  " + fontFile.toString());
                        e.printStackTrace();
                        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();
                }
                else {
                    // One reason for failing to register is that it already exists

                    if (swingFont != null) {
                        String font_name = swingFont.getFontName();
                    
                        Boolean font_already_registered = (_font_name_lookup.get(font_name) != null);

                        // Loading font was OK after all, just that the JDK already has it
                        if (font_already_registered) {
                            return register(swingFont).clone();
                        }
                        else {
                            System.err.println("Error: failed to register font '" + font_name + "'");
                        }
                    }
                }
                

                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));
                }
        }
}