source: trunk/src/org/expeditee/gio/javafx/JavaFXFontManager.java@ 1097

package org.expeditee.gio.javafx;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;

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

import javafx.scene.text.FontPosture;
import javafx.scene.text.FontWeight;

public class JavaFXFontManager extends FontManager {
        
        /** Singleton instance. */
        private static JavaFXFontManager _instance;
        
        /** Singleton instantiator. */
        public static JavaFXFontManager getInstance()
        {
                if (_instance == null) _instance = new JavaFXFontManager();
                
                return _instance;
        }
        
        /** Mapping from handles to internal fonts. */
        private HashMap<Font, JavaFXFont> _fontMap;
        /** The font family names registered with the manager. */
        private HashSet<String> _fontNames;
        
        /** Private constructor for singleton instance. */
        private JavaFXFontManager()
        {
                // Initialise the font map
                _fontMap = new HashMap<Font, JavaFXFont>();
                
                // Initialise the set of family names
                _fontNames = new HashSet<String>();
                
                // Initialise default font to JavaFX default
                setDefaultFont(register(JavaFXFont.getDefault()));
                
                // Add JavaFX standard fonts to registered fonts
                registerJavaFXStandardFonts();
        }

        @Override
        public Font registerFontFile(File fontFile)
        {
                if (fontFile == null) return null;
                
                JavaFXFont jfxFont = null;
                boolean registerOkay = true;
                
                // Create the internal font from the given file
                try {
                        jfxFont = JavaFXFont.loadFont(new FileInputStream(fontFile), 0); // Size of 0 forces default size
                        if (jfxFont == null) registerOkay = false;
                } catch (Exception e) {
                        registerOkay = false;
                }
                
                // Register the new font with ourselves
                if (registerOkay) {
                        return register(jfxFont).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));
        }
        
        /** Registers the given handle with the manager and returns the internal font. */
        private JavaFXFont 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(JavaFXFont jfxFont)
        {
                return register(jfxFont, null);
        }
        
        /** Registers a handle/font pair. */
        private Font register(JavaFXFont jfxFont, Font font)
        {
                if (jfxFont == null && font == null) return null;
                
                if (_fontMap.containsKey(font)) return font;
                
                if (font == null) {
                        font = extractFontForInternalFont(jfxFont);
                } else if (jfxFont == null) {
                        jfxFont = JavaFXFont.font(font.getFamilyName(), getJavaFXFontWeight(font), getJavaFXFontPosture(font), font.getSize());
                }
                
                if (jfxFont == null || font == null) return null;
                
                _fontMap.put(font, jfxFont);
                _fontNames.add(jfxFont.getFamily());
                
                return font;
        }
        
        /** Creates a handle to match the given JavaFX font. */
        private Font extractFontForInternalFont(JavaFXFont jfxFont)
        {
                if (jfxFont == null) return null;
                
                Font font = new Font(jfxFont.getFamily());
                font.setStyle(Font.Style.PLAIN);
                if (jfxFont.isBold()) font.toggleBold();
                if (jfxFont.isItalics()) font.toggleItalic();
                font.setSize((int) jfxFont.getSize());
                font.setSpacing(0); // Can't get tracking value for JavaFXFonts
                
                return font;
        }
        
        /** Gets the internal JavaFX font object for use by other Swing managers. */
        public javafx.scene.text.Font getInternalFont(Font font)
        {
                return register(font).getRealFont();
        }
        
        /** Registers any standard fonts available on the system with the manager. */
        private void registerJavaFXStandardFonts()
        {
                List<String> standardFontNames = javafx.scene.text.Font.getFamilies();
                
                for (String name : standardFontNames) {
                        register(new Font(name));
                }
        }
        
        /** Gets the JavaFX font weight for a given font. */
        private javafx.scene.text.FontWeight getJavaFXFontWeight(Font font)
        {
                if (font.isBold()) {
                        return javafx.scene.text.FontWeight.BOLD;
                } else {
                        return javafx.scene.text.FontWeight.NORMAL;
                }
        }
        
        /** Gets the JavaFX font posture for a given font. */
        private javafx.scene.text.FontPosture getJavaFXFontPosture(Font font)
        {
                if (font.isItalic()) {
                        return javafx.scene.text.FontPosture.ITALIC;
                } else {
                        return javafx.scene.text.FontPosture.REGULAR;
                }
        }
        
        /** Wrapper for JavaFX fonts as they do not retain knowledge of their bold/italics status. */
        private static class JavaFXFont {
                
                private javafx.scene.text.Font _font = null;
                
                private boolean _isBold;
                
                private boolean _isItalics;
                
                /** Default constructor for internal use only. */
                private JavaFXFont() {}
                
                public javafx.scene.text.Font getRealFont()
                {
                        return _font;
                }
                
                public String getFamily()
                {
                        return _font.getFamily();
                }
                
                public boolean isBold()
                {
                        return _isBold;
                }
                
                public boolean isItalics()
                {
                        return _isItalics;
                }
                
                public double getSize()
                {
                        return _font.getSize();
                }
                
                public static JavaFXFont getDefault()
                {
                        JavaFXFont font = new JavaFXFont();
                        font._font = javafx.scene.text.Font.getDefault();
                        if (font._font == null) return null;
                        font._isBold = false;
                        font._isItalics = false;
                        return font;
                }
                
                public static JavaFXFont loadFont(InputStream in, double size)
                {
                        JavaFXFont font = new JavaFXFont();
                        font._font = javafx.scene.text.Font.loadFont(in, size);
                        if (font._font == null) return null;
                        font._isBold = false;
                        font._isItalics = false;
                        return font;
                }
                
                public static JavaFXFont font(String family, FontWeight weight, FontPosture posture, double size)
                {
                        JavaFXFont font = new JavaFXFont();
                        font._font = javafx.scene.text.Font.font(family, weight, posture, size);
                        if (font._font == null) return null;
                        font._isBold = (weight == FontWeight.BOLD);
                        font._isItalics = (posture == FontPosture.ITALIC);
                        return font;
                }
        }
}