void calculate_default_options();

    InventoryRegion *m_region_self_inv;

    InventoryRegion *m_region_inv;

    bool layout_statcol(bool message_overlay, bool show_gold_turns);

    delete m_region_self_inv;

    delete m_region_inv;

    m_region_self_inv = NULL;

    m_region_inv = NULL;

void TilesFramework::calculate_default_options()
{
    // Find which set of _screen_sizes to use.
    int auto_size = 0;
    int num_screen_sizes = sizeof(_screen_sizes) / sizeof(_screen_sizes[0]);
    do
    {
        if (m_windowsz.x >= _screen_sizes[auto_size][0]
            && m_windowsz.y >= _screen_sizes[auto_size][1])
        {
            break;
        }
    } while (++auto_size < num_screen_sizes - 1);
    // Auto pick map and font sizes if option is zero.
#define AUTO(x,y) (x = (x) ? (x) : _screen_sizes[auto_size][(y)])
    AUTO(Options.tile_map_pixels, 2);
    AUTO(Options.tile_font_crt_size, 3);
    AUTO(Options.tile_font_stat_size, 4);
    AUTO(Options.tile_font_msg_size, 5);
    AUTO(Options.tile_font_tip_size, 6);
    AUTO(Options.tile_font_lbl_size, 7);
#undef AUTO
}

    // Find which set of _screen_sizes to use.
    int auto_size = 0;
    int num_screen_sizes = sizeof(_screen_sizes) / sizeof(_screen_sizes[0]);
    do
    {
        if (m_windowsz.x >= _screen_sizes[auto_size][0]
            && m_windowsz.y >= _screen_sizes[auto_size][1])
        {
            break;
        }
    } while (++auto_size < num_screen_sizes - 1);
    // Auto pick map and font sizes if option is zero.
#define AUTO(x,y) (x = (x) ? (x) : _screen_sizes[auto_size][(y)])
    AUTO(Options.tile_map_pixels, 2);
    AUTO(Options.tile_font_crt_size, 3);
    AUTO(Options.tile_font_stat_size, 4);
    AUTO(Options.tile_font_msg_size, 5);
    AUTO(Options.tile_font_tip_size, 6);
    AUTO(Options.tile_font_lbl_size, 7);
#undef AUTO

    calculate_default_options();

    m_region_self_inv = new InventoryRegion(&m_image, m_fonts[lbl_font].font,

    m_region_inv = new InventoryRegion(&m_image, m_fonts[lbl_font].font,

    m_layers[LAYER_NORMAL].m_regions.push_back(m_region_self_inv);

    m_layers[LAYER_NORMAL].m_regions.push_back(m_region_inv);

    calculate_default_options();

static const int map_margin = 2;
static const int map_stat_buffer = 4;
static const int crt_width = 80;
static const int crt_height = 30;
static const int margin = 4;

    const int map_stat_buffer = 4;
    const int crt_width = 80;
    const int crt_height = 30;
    const int map_margin = 2;

    const int margin = 4;

    int hud_width = std::min(50, (int)m_region_stat->mx);

    // Determine the maximum width.
    m_region_stat->resize_to_fit(m_windowsz.x - m_region_stat->sx,
                                 m_region_stat->wy);
    // Grow HUD horizontally if there's room.
    const int max_hud_width = 50;
    int hud_width = std::min(m_region_stat->mx, max_hud_width);

    // If show_gold_turns isn't turned on, try turning it on if there's room.
    if (!Options.show_gold_turns) 
    {
        if (layout_statcol(message_overlay, true))
            Options.show_gold_turns = true;
        else
            layout_statcol(message_overlay, false);
    }
    else
    {
        layout_statcol(message_overlay, true);
    }
    // Place regions for crt layer
    m_region_crt->place(0, 0, margin);
    m_region_crt->resize_to_fit(m_windowsz.x, m_windowsz.y);
    m_region_menu->place(0, 0, margin);
    m_region_menu->resize_to_fit(m_windowsz.x, m_windowsz.y);
    crawl_view.init_view();
}
bool TilesFramework::layout_statcol(bool message_overlay, bool show_gold_turns)
{
    // Assumes that the region_stat has already been placed.
    int hud_height = 12 + (show_gold_turns ? 1 : 0);
    m_region_stat->resize(m_region_stat->mx, hud_height);
    crawl_view.hudsz.y = hud_height;
    m_region_map->place(m_region_stat->sx, m_region_stat->ey, map_margin);

        inv_col = stat_col;

        inv_col = m_region_stat->sx;

    m_region_self_inv->place(inv_col, m_region_map->ey, 0);
    m_region_self_inv->resize_to_fit(m_windowsz.x -
                                     m_region_self_inv->sx,

    m_region_inv->place(inv_col, m_region_map->ey, 0);
    m_region_inv->resize_to_fit(m_windowsz.x -
                                     m_region_inv->sx,

                                     m_region_self_inv->sy);
    m_region_self_inv->resize(std::min(13, (int)m_region_self_inv->mx),
                              std::min(6, (int)m_region_self_inv->my));

                                     m_region_inv->sy);
    m_region_inv->resize(std::min(13, (int)m_region_inv->mx),
                              std::min(6, (int)m_region_inv->my));

    int self_inv_y = m_windowsz.y - m_region_self_inv->wy - margin;
    m_region_self_inv->place(inv_col, self_inv_y, 0);

    int self_inv_y = m_windowsz.y - m_region_inv->wy - margin;
    m_region_inv->place(inv_col, self_inv_y, 0);

    int map_cen_x = m_region_self_inv->sx + (m_region_self_inv->wx) / 2;
    map_cen_x = std::min(map_cen_x, (int)(m_windowsz.x - m_region_map->wx));
    m_region_map->place(map_cen_x - m_region_map->wy / 2, m_region_map->sy,

    int map_cen_x = (m_region_inv->sx + m_region_inv->ex) / 2;
    map_cen_x = std::min(map_cen_x, (int)(m_windowsz.x - m_region_map->wx/2));
    m_region_map->place(map_cen_x - m_region_map->wx/2, m_region_map->sy,

    // Place regions for crt layer
    m_region_crt->place(0, 0, margin);
    m_region_crt->resize_to_fit(m_windowsz.x, m_windowsz.y);
    m_region_menu->place(0, 0, margin);
    m_region_menu->resize_to_fit(m_windowsz.x, m_windowsz.y);

    crawl_view.init_view();

    int num_items = m_region_inv->mx * (m_region_inv->my - 1);
    return (num_items >= ENDOFPACK);

    const int mx = m_region_self_inv->mx;
    const int my = m_region_self_inv->my;

    const int mx = m_region_inv->mx;
    const int my = m_region_inv->my;

    m_region_self_inv->update(inv.size(), &inv[0]);

    m_region_inv->update(inv.size(), &inv[0]);

#ifdef USE_TILE

#endif

        cprintf("Exp Pool: ");
        textcolor(HUD_VALUE_COLOUR);

        cprintf("XP: ");
        textcolor(HUD_VALUE_COLOUR);

        cprintf("Exp Pool: ");
        textcolor(HUD_VALUE_COLOUR);

#endif
#ifdef USE_TILE
    tiles.resize();