public BaseFont awtToPdf(Font font) 
{
                  			     	              
        try {
            BaseFontParameters p = getBaseFontParameters(font.getFontName());
            if (p != null)
                return BaseFont.createFont(p.fontName, p.encoding, p.embedded, p.cached, p.ttfAfm, p.pfb);
            String fontKey = null;
            String logicalName = font.getName();
            if (logicalName.equalsIgnoreCase("DialogInput") || logicalName.equalsIgnoreCase("Monospaced") || logicalName.equalsIgnoreCase("Courier")) {
                if (font.isItalic()) {
                    if (font.isBold()) {
                        fontKey = BaseFont.COURIER_BOLDOBLIQUE;
                    } else {
                        fontKey = BaseFont.COURIER_OBLIQUE;
                    }
                } else {
                    if (font.isBold()) {
                        fontKey = BaseFont.COURIER_BOLD;
                    } else {
                        fontKey = BaseFont.COURIER;
                    }
                }
            } else if (logicalName.equalsIgnoreCase("Serif") || logicalName.equalsIgnoreCase("TimesRoman")) {
                if (font.isItalic()) {
                    if (font.isBold()) {
                        fontKey = BaseFont.TIMES_BOLDITALIC;
                    } else {
                        fontKey = BaseFont.TIMES_ITALIC;
                    }
                } else {
                    if (font.isBold()) {
                        fontKey = BaseFont.TIMES_BOLD;
                    } else {
                        fontKey = BaseFont.TIMES_ROMAN;
                    }
                }
            } else {  // default, this catches Dialog and SansSerif
                if (font.isItalic()) {
                    if (font.isBold()) {
                        fontKey = BaseFont.HELVETICA_BOLDOBLIQUE;
                    } else {
                        fontKey = BaseFont.HELVETICA_OBLIQUE;
                    }
                } else {
                    if (font.isBold()) {
                        fontKey = BaseFont.HELVETICA_BOLD;
                    } else {
                        fontKey = BaseFont.HELVETICA;
                    }
                }
            }
            return BaseFont.createFont(fontKey, BaseFont.CP1252, false);
        }
        catch (Exception e) {
            throw new ExceptionConverter(e);
        }
}

Returns a BaseFont which can be used to represent the given AWT Font

 public HashMap getAliases() 
{
        return aliases;
}

 public DefaultFontMapper.BaseFontParameters getBaseFontParameters(String name) 
{
        String alias = (String)aliases.get(name);
        if (alias == null)
            return (BaseFontParameters)mapper.get(name);
        BaseFontParameters p = (BaseFontParameters)mapper.get(alias);
        if (p == null)
            return (BaseFontParameters)mapper.get(name);
        else
            return p;
}

Looks for a BaseFont parameter associated with a name.

 public HashMap getMapper() 
{
        return mapper;
}

 public int insertDirectory(String dir) 
{
        File file = new File(dir);
        if (!file.exists() || !file.isDirectory())
            return 0;
        File files[] = file.listFiles();
        if (files == null)
        	return 0;
        int count = 0;
        for (int k = 0; k <  files.length; ++k) {
            file = files[k];
            String name = file.getPath().toLowerCase();
            try {
                if (name.endsWith(".ttf") || name.endsWith(".otf") || name.endsWith(".afm")) {
                    Object allNames[] = BaseFont.getAllFontNames(file.getPath(), BaseFont.CP1252, null);
                    insertNames(allNames, file.getPath());
                    ++count;
                }
                else if (name.endsWith(".ttc")) {
                    String ttcs[] = BaseFont.enumerateTTCNames(file.getPath());
                    for (int j = 0; j <  ttcs.length; ++j) {
                        String nt = file.getPath() + "," + j;
                        Object allNames[] = BaseFont.getAllFontNames(nt, BaseFont.CP1252, null);
                        insertNames(allNames, nt);
                    }
                    ++count;
                }
            }
            catch (Exception e) {
            }
        }
        return count;
}

Inserts all the fonts recognized by iText in the directory into the map. The encoding will be BaseFont.CP1252 but can be changed later.

 public  void insertNames(Object[] allNames,
    String path) 
{
        String names[][] = (String[][])allNames[2];
        String main = null;
        for (int k = 0; k <  names.length; ++k) {
            String name[] = names[k];
            if (name[2].equals("1033")) {
                main = name[3];
                break;
            }
        }
        if (main == null)
            main = names[0][3];
        BaseFontParameters p = new BaseFontParameters(path);
        mapper.put(main, p);
        for (int k = 0; k <  names.length; ++k) {
            aliases.put(names[k][3], main);
        }
        aliases.put(allNames[0], main);
}

Inserts the names in this map.

 public Font pdfToAwt(BaseFont font,
    int size) 
{
        String names[][] = font.getFullFontName();
        if (names.length == 1)
            return new Font(names[0][3], 0, size);
        String name10 = null;
        String name3x = null;
        for (int k = 0; k <  names.length; ++k) {
            String name[] = names[k];
            if (name[0].equals("1") && name[1].equals("0"))
                name10 = name[3];
            else if (name[2].equals("1033")) {
                name3x = name[3];
                break;
            }
        }
        String finalName = name3x;
        if (finalName == null)
            finalName = name10;
        if (finalName == null)
            finalName = names[0][3];
        return new Font(finalName, 0, size);
}

Returns an AWT Font which can be used to represent the given BaseFont

 public  void putAlias(String alias,
    String awtName) 
{
        aliases.put(alias, awtName);
}

Maps an alias to a name.

 public  void putName(String awtName,
    DefaultFontMapper.BaseFontParameters parameters) 
{
        mapper.put(awtName, parameters);
}

Maps a name to a BaseFont parameter.