/**
 * Returns all fonts available in this environment.
 */
public Font[] getAllFonts() {
    FontManagerForSGE fm = getFontManagerForSGE();
    Font[] installedFonts = fm.getAllInstalledFonts();
    Font[] created = fm.getCreatedFonts();
    if (created == null || created.length == 0) {
        return installedFonts;
    } else {
        int newlen = installedFonts.length + created.length;
        Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
        System.arraycopy(created, 0, fonts,
                         installedFonts.length, created.length);
        return fonts;
    }
}
 

public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
    FontManagerForSGE fm = getFontManagerForSGE();
    String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
    /* Use a new TreeMap as used in getInstalledFontFamilyNames
     * and insert all the keys in lower case, so that the sort order
     * is the same as the installed families. This preserves historical
     * behaviour and inserts new families in the right place.
     * It would have been marginally more efficient to directly obtain
     * the tree map and just insert new entries, but not so much as
     * to justify the extra internal interface.
     */
    TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
    if (map == null || map.size() == 0) {
        return installed;
    } else {
        for (int i=0; i<installed.length; i++) {
            map.put(installed[i].toLowerCase(requestedLocale),
                    installed[i]);
        }
        String[] retval =  new String[map.size()];
        Object [] keyNames = map.keySet().toArray();
        for (int i=0; i < keyNames.length; i++) {
            retval[i] = (String)map.get(keyNames[i]);
        }
        return retval;
    }
}
 

/**
 * Returns all fonts available in this environment.
 */
public Font[] getAllFonts() {
    FontManagerForSGE fm = getFontManagerForSGE();
    Font[] installedFonts = fm.getAllInstalledFonts();
    Font[] created = fm.getCreatedFonts();
    if (created == null || created.length == 0) {
        return installedFonts;
    } else {
        int newlen = installedFonts.length + created.length;
        Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
        System.arraycopy(created, 0, fonts,
                         installedFonts.length, created.length);
        return fonts;
    }
}
 

public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
    FontManagerForSGE fm = getFontManagerForSGE();
    String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
    /* Use a new TreeMap as used in getInstalledFontFamilyNames
     * and insert all the keys in lower case, so that the sort order
     * is the same as the installed families. This preserves historical
     * behaviour and inserts new families in the right place.
     * It would have been marginally more efficient to directly obtain
     * the tree map and just insert new entries, but not so much as
     * to justify the extra internal interface.
     */
    TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
    if (map == null || map.size() == 0) {
        return installed;
    } else {
        for (int i=0; i<installed.length; i++) {
            map.put(installed[i].toLowerCase(requestedLocale),
                    installed[i]);
        }
        String[] retval =  new String[map.size()];
        Object [] keyNames = map.keySet().toArray();
        for (int i=0; i < keyNames.length; i++) {
            retval[i] = (String)map.get(keyNames[i]);
        }
        return retval;
    }
}
 

/**
 * Returns all fonts available in this environment.
 */
public Font[] getAllFonts() {
    FontManagerForSGE fm = getFontManagerForSGE();
    Font[] installedFonts = fm.getAllInstalledFonts();
    Font[] created = fm.getCreatedFonts();
    if (created == null || created.length == 0) {
        return installedFonts;
    } else {
        int newlen = installedFonts.length + created.length;
        Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
        System.arraycopy(created, 0, fonts,
                         installedFonts.length, created.length);
        return fonts;
    }
}
 

public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
    FontManagerForSGE fm = getFontManagerForSGE();
    String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
    /* Use a new TreeMap as used in getInstalledFontFamilyNames
     * and insert all the keys in lower case, so that the sort order
     * is the same as the installed families. This preserves historical
     * behaviour and inserts new families in the right place.
     * It would have been marginally more efficient to directly obtain
     * the tree map and just insert new entries, but not so much as
     * to justify the extra internal interface.
     */
    TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
    if (map == null || map.size() == 0) {
        return installed;
    } else {
        for (int i=0; i<installed.length; i++) {
            map.put(installed[i].toLowerCase(requestedLocale),
                    installed[i]);
        }
        String[] retval =  new String[map.size()];
        Object [] keyNames = map.keySet().toArray();
        for (int i=0; i < keyNames.length; i++) {
            retval[i] = (String)map.get(keyNames[i]);
        }
        return retval;
    }
}
 

/**
 * Returns all fonts available in this environment.
 */
public Font[] getAllFonts() {
    FontManagerForSGE fm = getFontManagerForSGE();
    Font[] installedFonts = fm.getAllInstalledFonts();
    Font[] created = fm.getCreatedFonts();
    if (created == null || created.length == 0) {
        return installedFonts;
    } else {
        int newlen = installedFonts.length + created.length;
        Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
        System.arraycopy(created, 0, fonts,
                         installedFonts.length, created.length);
        return fonts;
    }
}
 

public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
    FontManagerForSGE fm = getFontManagerForSGE();
    String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
    /* Use a new TreeMap as used in getInstalledFontFamilyNames
     * and insert all the keys in lower case, so that the sort order
     * is the same as the installed families. This preserves historical
     * behaviour and inserts new families in the right place.
     * It would have been marginally more efficient to directly obtain
     * the tree map and just insert new entries, but not so much as
     * to justify the extra internal interface.
     */
    TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
    if (map == null || map.size() == 0) {
        return installed;
    } else {
        for (int i=0; i<installed.length; i++) {
            map.put(installed[i].toLowerCase(requestedLocale),
                    installed[i]);
        }
        String[] retval =  new String[map.size()];
        Object [] keyNames = map.keySet().toArray();
        for (int i=0; i < keyNames.length; i++) {
            retval[i] = (String)map.get(keyNames[i]);
        }
        return retval;
    }
}
 

/**
 * Returns all fonts available in this environment.
 */
public Font[] getAllFonts() {
    FontManagerForSGE fm = getFontManagerForSGE();
    Font[] installedFonts = fm.getAllInstalledFonts();
    Font[] created = fm.getCreatedFonts();
    if (created == null || created.length == 0) {
        return installedFonts;
    } else {
        int newlen = installedFonts.length + created.length;
        Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
        System.arraycopy(created, 0, fonts,
                         installedFonts.length, created.length);
        return fonts;
    }
}
 

public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
    FontManagerForSGE fm = getFontManagerForSGE();
    String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
    /* Use a new TreeMap as used in getInstalledFontFamilyNames
     * and insert all the keys in lower case, so that the sort order
     * is the same as the installed families. This preserves historical
     * behaviour and inserts new families in the right place.
     * It would have been marginally more efficient to directly obtain
     * the tree map and just insert new entries, but not so much as
     * to justify the extra internal interface.
     */
    TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
    if (map == null || map.size() == 0) {
        return installed;
    } else {
        for (int i=0; i<installed.length; i++) {
            map.put(installed[i].toLowerCase(requestedLocale),
                    installed[i]);
        }
        String[] retval =  new String[map.size()];
        Object [] keyNames = map.keySet().toArray();
        for (int i=0; i < keyNames.length; i++) {
            retval[i] = (String)map.get(keyNames[i]);
        }
        return retval;
    }
}
 

/**
 * Returns all fonts available in this environment.
 */
public Font[] getAllFonts() {
    FontManagerForSGE fm = getFontManagerForSGE();
    Font[] installedFonts = fm.getAllInstalledFonts();
    Font[] created = fm.getCreatedFonts();
    if (created == null || created.length == 0) {
        return installedFonts;
    } else {
        int newlen = installedFonts.length + created.length;
        Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
        System.arraycopy(created, 0, fonts,
                         installedFonts.length, created.length);
        return fonts;
    }
}
 

public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
    FontManagerForSGE fm = getFontManagerForSGE();
    String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
    /* Use a new TreeMap as used in getInstalledFontFamilyNames
     * and insert all the keys in lower case, so that the sort order
     * is the same as the installed families. This preserves historical
     * behaviour and inserts new families in the right place.
     * It would have been marginally more efficient to directly obtain
     * the tree map and just insert new entries, but not so much as
     * to justify the extra internal interface.
     */
    TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
    if (map == null || map.size() == 0) {
        return installed;
    } else {
        for (int i=0; i<installed.length; i++) {
            map.put(installed[i].toLowerCase(requestedLocale),
                    installed[i]);
        }
        String[] retval =  new String[map.size()];
        Object [] keyNames = map.keySet().toArray();
        for (int i=0; i < keyNames.length; i++) {
            retval[i] = map.get(keyNames[i]);
        }
        return retval;
    }
}
 

/**
 * Returns all fonts available in this environment.
 */
public Font[] getAllFonts() {
    FontManagerForSGE fm = getFontManagerForSGE();
    Font[] installedFonts = fm.getAllInstalledFonts();
    Font[] created = fm.getCreatedFonts();
    if (created == null || created.length == 0) {
        return installedFonts;
    } else {
        int newlen = installedFonts.length + created.length;
        Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
        System.arraycopy(created, 0, fonts,
                         installedFonts.length, created.length);
        return fonts;
    }
}
 

public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
    FontManagerForSGE fm = getFontManagerForSGE();
    String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
    /* Use a new TreeMap as used in getInstalledFontFamilyNames
     * and insert all the keys in lower case, so that the sort order
     * is the same as the installed families. This preserves historical
     * behaviour and inserts new families in the right place.
     * It would have been marginally more efficient to directly obtain
     * the tree map and just insert new entries, but not so much as
     * to justify the extra internal interface.
     */
    TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
    if (map == null || map.size() == 0) {
        return installed;
    } else {
        for (int i=0; i<installed.length; i++) {
            map.put(installed[i].toLowerCase(requestedLocale),
                    installed[i]);
        }
        String[] retval =  new String[map.size()];
        Object [] keyNames = map.keySet().toArray();
        for (int i=0; i < keyNames.length; i++) {
            retval[i] = map.get(keyNames[i]);
        }
        return retval;
    }
}
 

/**
 * Returns all fonts available in this environment.
 */
public Font[] getAllFonts() {
    FontManagerForSGE fm = getFontManagerForSGE();
    Font[] installedFonts = fm.getAllInstalledFonts();
    Font[] created = fm.getCreatedFonts();
    if (created == null || created.length == 0) {
        return installedFonts;
    } else {
        int newlen = installedFonts.length + created.length;
        Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
        System.arraycopy(created, 0, fonts,
                         installedFonts.length, created.length);
        return fonts;
    }
}
 

public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
    FontManagerForSGE fm = getFontManagerForSGE();
    String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
    /* Use a new TreeMap as used in getInstalledFontFamilyNames
     * and insert all the keys in lower case, so that the sort order
     * is the same as the installed families. This preserves historical
     * behaviour and inserts new families in the right place.
     * It would have been marginally more efficient to directly obtain
     * the tree map and just insert new entries, but not so much as
     * to justify the extra internal interface.
     */
    TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
    if (map == null || map.size() == 0) {
        return installed;
    } else {
        for (int i=0; i<installed.length; i++) {
            map.put(installed[i].toLowerCase(requestedLocale),
                    installed[i]);
        }
        String[] retval =  new String[map.size()];
        Object [] keyNames = map.keySet().toArray();
        for (int i=0; i < keyNames.length; i++) {
            retval[i] = (String)map.get(keyNames[i]);
        }
        return retval;
    }
}
 

/**
 * Returns all fonts available in this environment.
 */
public Font[] getAllFonts() {
    FontManagerForSGE fm = getFontManagerForSGE();
    Font[] installedFonts = fm.getAllInstalledFonts();
    Font[] created = fm.getCreatedFonts();
    if (created == null || created.length == 0) {
        return installedFonts;
    } else {
        int newlen = installedFonts.length + created.length;
        Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
        System.arraycopy(created, 0, fonts,
                         installedFonts.length, created.length);
        return fonts;
    }
}
 

public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
    FontManagerForSGE fm = getFontManagerForSGE();
    String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
    /* Use a new TreeMap as used in getInstalledFontFamilyNames
     * and insert all the keys in lower case, so that the sort order
     * is the same as the installed families. This preserves historical
     * behaviour and inserts new families in the right place.
     * It would have been marginally more efficient to directly obtain
     * the tree map and just insert new entries, but not so much as
     * to justify the extra internal interface.
     */
    TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
    if (map == null || map.size() == 0) {
        return installed;
    } else {
        for (int i=0; i<installed.length; i++) {
            map.put(installed[i].toLowerCase(requestedLocale),
                    installed[i]);
        }
        String[] retval =  new String[map.size()];
        Object [] keyNames = map.keySet().toArray();
        for (int i=0; i < keyNames.length; i++) {
            retval[i] = (String)map.get(keyNames[i]);
        }
        return retval;
    }
}
 

/**
 * Returns all fonts available in this environment.
 */
public Font[] getAllFonts() {
    FontManagerForSGE fm = getFontManagerForSGE();
    Font[] installedFonts = fm.getAllInstalledFonts();
    Font[] created = fm.getCreatedFonts();
    if (created == null || created.length == 0) {
        return installedFonts;
    } else {
        int newlen = installedFonts.length + created.length;
        Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
        System.arraycopy(created, 0, fonts,
                         installedFonts.length, created.length);
        return fonts;
    }
}
 

public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
    FontManagerForSGE fm = getFontManagerForSGE();
    String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
    /* Use a new TreeMap as used in getInstalledFontFamilyNames
     * and insert all the keys in lower case, so that the sort order
     * is the same as the installed families. This preserves historical
     * behaviour and inserts new families in the right place.
     * It would have been marginally more efficient to directly obtain
     * the tree map and just insert new entries, but not so much as
     * to justify the extra internal interface.
     */
    TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
    if (map == null || map.size() == 0) {
        return installed;
    } else {
        for (int i=0; i<installed.length; i++) {
            map.put(installed[i].toLowerCase(requestedLocale),
                    installed[i]);
        }
        String[] retval =  new String[map.size()];
        Object [] keyNames = map.keySet().toArray();
        for (int i=0; i < keyNames.length; i++) {
            retval[i] = (String)map.get(keyNames[i]);
        }
        return retval;
    }
}
 

/**
 * Returns all fonts available in this environment.
 */
public Font[] getAllFonts() {
    FontManagerForSGE fm = getFontManagerForSGE();
    Font[] installedFonts = fm.getAllInstalledFonts();
    Font[] created = fm.getCreatedFonts();
    if (created == null || created.length == 0) {
        return installedFonts;
    } else {
        int newlen = installedFonts.length + created.length;
        Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
        System.arraycopy(created, 0, fonts,
                         installedFonts.length, created.length);
        return fonts;
    }
}
 

public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
    FontManagerForSGE fm = getFontManagerForSGE();
    String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
    /* Use a new TreeMap as used in getInstalledFontFamilyNames
     * and insert all the keys in lower case, so that the sort order
     * is the same as the installed families. This preserves historical
     * behaviour and inserts new families in the right place.
     * It would have been marginally more efficient to directly obtain
     * the tree map and just insert new entries, but not so much as
     * to justify the extra internal interface.
     */
    TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
    if (map == null || map.size() == 0) {
        return installed;
    } else {
        for (int i=0; i<installed.length; i++) {
            map.put(installed[i].toLowerCase(requestedLocale),
                    installed[i]);
        }
        String[] retval =  new String[map.size()];
        Object [] keyNames = map.keySet().toArray();
        for (int i=0; i < keyNames.length; i++) {
            retval[i] = (String)map.get(keyNames[i]);
        }
        return retval;
    }
}
 

/**
 * Returns all fonts available in this environment.
 */
public Font[] getAllFonts() {
    FontManagerForSGE fm = getFontManagerForSGE();
    Font[] installedFonts = fm.getAllInstalledFonts();
    Font[] created = fm.getCreatedFonts();
    if (created == null || created.length == 0) {
        return installedFonts;
    } else {
        int newlen = installedFonts.length + created.length;
        Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
        System.arraycopy(created, 0, fonts,
                         installedFonts.length, created.length);
        return fonts;
    }
}
 

public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
    FontManagerForSGE fm = getFontManagerForSGE();
    String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
    /* Use a new TreeMap as used in getInstalledFontFamilyNames
     * and insert all the keys in lower case, so that the sort order
     * is the same as the installed families. This preserves historical
     * behaviour and inserts new families in the right place.
     * It would have been marginally more efficient to directly obtain
     * the tree map and just insert new entries, but not so much as
     * to justify the extra internal interface.
     */
    TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
    if (map == null || map.size() == 0) {
        return installed;
    } else {
        for (int i=0; i<installed.length; i++) {
            map.put(installed[i].toLowerCase(requestedLocale),
                    installed[i]);
        }
        String[] retval =  new String[map.size()];
        Object [] keyNames = map.keySet().toArray();
        for (int i=0; i < keyNames.length; i++) {
            retval[i] = (String)map.get(keyNames[i]);
        }
        return retval;
    }
}
 

/**
 * Returns all fonts available in this environment.
 */
public Font[] getAllFonts() {
    FontManagerForSGE fm = getFontManagerForSGE();
    Font[] installedFonts = fm.getAllInstalledFonts();
    Font[] created = fm.getCreatedFonts();
    if (created == null || created.length == 0) {
        return installedFonts;
    } else {
        int newlen = installedFonts.length + created.length;
        Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
        System.arraycopy(created, 0, fonts,
                         installedFonts.length, created.length);
        return fonts;
    }
}
 

public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
    FontManagerForSGE fm = getFontManagerForSGE();
    String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
    /* Use a new TreeMap as used in getInstalledFontFamilyNames
     * and insert all the keys in lower case, so that the sort order
     * is the same as the installed families. This preserves historical
     * behaviour and inserts new families in the right place.
     * It would have been marginally more efficient to directly obtain
     * the tree map and just insert new entries, but not so much as
     * to justify the extra internal interface.
     */
    TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
    if (map == null || map.size() == 0) {
        return installed;
    } else {
        for (int i=0; i<installed.length; i++) {
            map.put(installed[i].toLowerCase(requestedLocale),
                    installed[i]);
        }
        String[] retval =  new String[map.size()];
        Object [] keyNames = map.keySet().toArray();
        for (int i=0; i < keyNames.length; i++) {
            retval[i] = (String)map.get(keyNames[i]);
        }
        return retval;
    }
}
 

public static FontManagerForSGE getFontManagerForSGE() {
    FontManager fm = FontManagerFactory.getInstance();
    return (FontManagerForSGE) fm;
}
 

public static FontManagerForSGE getFontManagerForSGE() {
    FontManager fm = FontManagerFactory.getInstance();
    return (FontManagerForSGE) fm;
}
 

public static FontManagerForSGE getFontManagerForSGE() {
    FontManager fm = FontManagerFactory.getInstance();
    return (FontManagerForSGE) fm;
}
 

public static FontManagerForSGE getFontManagerForSGE() {
    FontManager fm = FontManagerFactory.getInstance();
    return (FontManagerForSGE) fm;
}