bool load_font(const char *font_file, int font_size);

    int load_font(const char *font_file, int font_size,
                  bool default_on_fail = true);

    FTFont *m_font;

    struct font_info
    {
        std::string name;
        int size;
        FTFont *font;
    };
    std::vector<font_info> m_fonts;
    int m_tip_font;

    m_font(NULL),

    for (unsigned int i = 0; i < m_fonts.size(); i++)
    {
        delete m_fonts[i].font;
        m_fonts[i].font = NULL;
    }

    // TODO enne - make this configurable (and fall back on default if fails)
    // TODO enne - use Crawl's dat file loading utilities
	const char *font_file = "dat/tiles/VeraMono.ttf";
    const int font_size = 14;
    if (!load_font(font_file, font_size))
        return false;
    ASSERT(m_font);

    // TODO enne - different font for tooltip and for dungeon tags
    m_region_tile = new DungeonRegion(&m_image, m_font, TILE_X, TILE_Y);

    int crt_font = load_font(Options.tile_font_crt_file.c_str(),
                             Options.tile_font_crt_size);
    int msg_font = load_font(Options.tile_font_msg_file.c_str(),
                             Options.tile_font_msg_size);
    int stat_font = load_font(Options.tile_font_stat_file.c_str(),
                              Options.tile_font_stat_size);
    m_tip_font = load_font(Options.tile_font_tip_file.c_str(),
                           Options.tile_font_tip_size);
    int lbl_font = load_font(Options.tile_font_lbl_file.c_str(),
                             Options.tile_font_lbl_size);
    if (crt_font == -1 || msg_font == -1 || stat_font == -1
        || m_tip_font == -1 || lbl_font == -1)
    {
        return false;
    }
    m_region_tile = new DungeonRegion(&m_image, m_fonts[lbl_font].font, 
                                      TILE_X, TILE_Y);

    m_region_msg = new MessageRegion(m_font);
    m_region_stat = new StatRegion(m_font);
    m_region_crt = new CRTRegion(m_font);

    m_region_msg = new MessageRegion(m_fonts[msg_font].font);
    m_region_stat = new StatRegion(m_fonts[stat_font].font);
    m_region_crt = new CRTRegion(m_fonts[crt_font].font);

bool TilesFramework::load_font(const char *font_file, int font_size)

int TilesFramework::load_font(const char *font_file, int font_size,
                              bool default_on_fail)

    m_font = new FTFont();

    FTFont *font = new FTFont();
    for (unsigned int i = 0; i < m_fonts.size(); i++)
    {
        font_info &finfo = m_fonts[i];
        if (finfo.name == font_file && finfo.size == font_size)
            return i;
    }

    if (!m_font->load_font(font_file, font_size))

    if (!font->load_font(font_file, font_size))

        delete m_font;
        m_font = NULL;
        printf("Failed to open font '%s'\n", font_file);
        return false;

        delete font;
        if (default_on_fail)
            return (load_font("VeraMono.ttf", 12, false));
        else
            return -1;

    return true;

    font_info finfo;
    finfo.name = font_file;
    finfo.size = font_size;
    finfo.font = font;
    m_fonts.push_back(finfo);
    return (m_fonts.size() - 1);

        m_font->render_string(m_mouse.x, m_mouse.y - 2, m_tooltip.c_str(),
                              min_pos, m_windowsz, WHITE, false, 150,
                              BLUE, 5);

        FTFont *font = m_fonts[m_tip_font].font;
        font->render_string(m_mouse.x, m_mouse.y - 2, m_tooltip.c_str(),
                            min_pos, m_windowsz, WHITE, false, 150,
                            BLUE, 5);

        int offset;

        char offset;

        int advance;

        char advance;
        // per-glyph width
        char width;

#include "AppHdr.h"

#include "files.h"

    // TODO enne - need to find a cross-platform way to also
    // attempt to locate system fonts by name...
    std::string font_path = datafile_path(font_name, false, true);
    if (font_path.c_str()[0] == 0)
    {
        fprintf(stderr, "Could not find font '%s'\n", font_name);
        return false;
    }

    error = FT_New_Face(library, font_name, 0, &face);

    error = FT_New_Face(library, font_path.c_str(), 0, &face);

        fprintf(stderr, "Unknown font format for file '%s'\n", font_name);

        fprintf(stderr, "Unknown font format for file '%s'\n",
                         font_path.c_str());

        fprintf(stderr, "Invalid font from file '%s'\n", font_name);

        fprintf(stderr, "Invalid font from file '%s'\n", font_path.c_str());

    int min_y = 100000; // TODO enne - fix me

    int min_y = 100000;

    int max_width = 0;

        max_width = std::max(max_width, bmp->width);

        m_glyphs[c].width = bmp->width;

        m_min_offset = std::min(m_min_offset, m_glyphs[c].offset);

        m_min_offset = std::min((char)m_min_offset, m_glyphs[c].offset);

    // TEMP enne - this seems to be broken on OSX - it returns 8, when it should be 2?
    m_max_advance.x = 10;

    int max_height = m_max_advance.y;

    while (charsz.x < m_max_advance.x)

    while (charsz.x < max_width)

    while (charsz.y < m_max_advance.y)

    while (charsz.y < max_height)

        ASSERT(bmp->width + face->glyph->bitmap_left <= m_max_advance.x);
        ASSERT(bmp->rows <= m_max_advance.y);
        ASSERT(vert_offset >= 0);
        ASSERT(vert_offset + bmp->rows <= m_max_advance.y);

            unsigned int this_adv = m_glyphs[c].advance + 1;

                int this_width = m_glyphs[c].width;

                float tex_x2 = tex_x + (float)this_adv / (float)m_tex.width();

                float tex_x2 = tex_x + (float)this_width / (float)m_tex.width();

                v.pos_x = adv.x + this_adv;

                v.pos_x = adv.x + this_width;

                v.pos_x = adv.x + this_adv;

                v.pos_x = adv.x + this_width;

            adv.x += this_adv - m_glyphs[c].offset - 1;

            adv.x += m_glyphs[c].advance - m_glyphs[c].offset;

    // font selection
    tile_font_crt_file = "VeraMono.ttf";
    tile_font_crt_size = 15;
    tile_font_stat_file = "VeraMono.ttf";
    tile_font_stat_size = 16;
    tile_font_msg_file = "VeraMono.ttf";
    tile_font_msg_size = 14;
    tile_font_tip_file = "VeraMono.ttf";
    tile_font_tip_size = 15;
    tile_font_lbl_file = "Vera.ttf";
    tile_font_lbl_size = 14;

    else if (key == "tile_font_crt_file")
    {
        tile_font_crt_file = field;
    }
    else INT_OPTION(tile_font_crt_size, 1, INT_MAX);
    else if (key == "tile_font_msg_file")
    {
        tile_font_msg_file = field;
    }
    else INT_OPTION(tile_font_msg_size, 1, INT_MAX);
    else if (key == "tile_font_stat_file")
    {
        tile_font_stat_file = field;
    }
    else INT_OPTION(tile_font_stat_size, 1, INT_MAX);
    else if (key == "tile_font_tip_file")
    {
        tile_font_tip_file = field;
    }
    else INT_OPTION(tile_font_tip_size, 1, INT_MAX);
    else if (key == "tile_font_lbl_file")
    {
        tile_font_lbl_file = field;
    }
    else INT_OPTION(tile_font_lbl_size, 1, INT_MAX);

#ifdef USE_TILE
        std::string("dat/tiles") + FILE_SEPARATOR,
#endif

#ifdef USE_TILE
        std::string("..") + FILE_SEPARATOR + "dat/tiles" + FILE_SEPARATOR,
#endif

    std::string tile_font_crt_file;
    int         tile_font_crt_size;
    std::string tile_font_msg_file;
    int         tile_font_msg_size;
    std::string tile_font_stat_file;
    int         tile_font_stat_size;
    std::string tile_font_lbl_file;
    int         tile_font_lbl_size;
    std::string tile_font_tip_file;
    int         tile_font_tip_size;

#  tile_player_col      = white

# tile_player_col      = white

# tile_window_col      = yellow
# tile_font_crt_file = VeraMono.ttf
# tile_font_crt_size = 15
# tile_font_stat_file = VeraMono.ttf
# tile_font_stat_size = 16
# tile_font_msg_file = VeraMono.ttf
# tile_font_msg_size = 14
# tile_font_tip_file = VeraMono.ttf
# tile_font_tip_size = 15
# tile_font_lbl_file = Vera.ttf
# tile_font_lbl_size = 14