void set_num_columns(int columns);

    int m_max_columns;

    m_dirty(false), m_font_buf(entry), m_tile_buf(NULL)

    m_max_columns(1), m_dirty(false), m_font_buf(entry), m_tile_buf(NULL)

void MenuRegion::set_num_columns(int columns)
{
    m_max_columns = std::max(1, columns);
}

    const int tile_ident = 20;

    const int tile_indent = 20;

    const unsigned int max_tile_height = 32;
    const int column_width = mx / 2;

    const int max_tile_height = 32;

    int prev_height = height;

    bool mouse_selected = false;

    int column = 0;
    const int max_columns = std::min(2, m_max_columns);
    const int column_width = mx / max_columns;

        m_entries[i].sy = height;

        int text_width = m_font_entry->string_width(m_entries[i].text);
        int text_height = m_font_entry->char_height();

        int text_start = 0;
        int text_height = height;

            mouse_selected = false;

            text_start = heading_indent;
            height += m_font_entry->char_height();
        }
        else if (m_entries[i].tile)
        {
            m_entries[i].sx = tile_ident;
            text_start = text_indent;
            int entry_height =
                std::max(max_tile_height, m_font_entry->char_height());
            height += entry_height;
            text_height += (entry_height - m_font_entry->char_height()) / 2;

            m_entries[i].ex = m_entries[i].sx + text_width;
            m_entries[i].sy = height;
            m_entries[i].ey = m_entries[i].sy + text_height;

            ASSERT(m_entries[i].texture == tex || tex == TEX_MAX);
            tex = m_entries[i].texture;
            m_tile_buf.set_tex(&m_image->m_textures[tex]);

            m_font_buf.add(m_entries[i].text, m_entries[i].sx, m_entries[i].sy);

            m_tile_buf.add(m_entries[i].tile, m_entries[i].sx, m_entries[i].sy);

            height += text_height;
            prev_height = height;
            column = 0;

            m_entries[i].sx = text_start + text_indent;
            height += m_font_entry->char_height();
        }

            int entry_start;
            if (column > 0)
            {
                entry_start = column * column_width;
                m_entries[i].sy = prev_height;
            }
            else
            {
                entry_start = 0;
                m_entries[i].sy = height;
            }

        std::string unfrm = m_entries[i].text.tostring();
        m_entries[i].ex = text_start + m_font_entry->string_width(unfrm.c_str());
        m_entries[i].ex = std::max(m_entries[i].ex, column_width);
        m_entries[i].ey = height;

            int text_sx = entry_start + text_indent;

        m_font_buf.add(m_entries[i].text, text_start, text_height);

            int entry_height;
            if (m_entries[i].tile)
            {
                m_entries[i].sx = entry_start + tile_indent;
                entry_height = std::max(max_tile_height, text_height);
                
                // Currently, menus only support one texture at a time.
                tex = m_entries[i].texture;
                ASSERT(m_entries[i].texture == tex || tex == TEX_MAX);
                m_tile_buf.set_tex(&m_image->m_textures[tex]);
                m_tile_buf.add(m_entries[i].tile, m_entries[i].sx,
                               m_entries[i].sy);
            }
            else
            {
                m_entries[i].sx = text_sx;
                entry_height = text_height;
            }

            int text_sy = m_entries[i].sy;
            text_sy += (entry_height - m_font_entry->char_height()) / 2;
            if (text_sx + text_width > entry_start + column_width)
            {
                // [enne] - Ugh, hack.  Maybe MenuEntry could specify the
                // presence and length of this substring?
                std::string unfm = m_entries[i].text.tostring();
                bool let = (unfm[1] >= 'a' && unfm[1] <= 'z'
                            || unfm[1] >= 'A' && unfm[1] <= 'Z');
                bool plus = (unfm[3] == '-' || unfm[3] == '+');
                formatted_string text;
                if (let && plus && unfm[0] == ' ' && unfm[2] == ' '
                    && unfm[4] == ' ')
                {
                    formatted_string header = m_entries[i].text.substr(0, 5);
                    m_font_buf.add(header, text_sx, text_sy);
                    text_sx += m_font_entry->string_width(header);
                    text = m_entries[i].text.substr(5);
                }
                else
                {
                    text += m_entries[i].text;
                }
                int w = entry_start + column_width - text_sx;
                int h = m_font_entry->char_height() * 2;
                formatted_string split = m_font_entry->split(text, w, h);
                int string_height = m_font_entry->string_height(split);
                if (string_height > entry_height)
                {
                    text_sy = m_entries[i].sy;
                }
                m_font_buf.add(split, text_sx, text_sy);
                m_entries[i].ex = entry_start + column_width;
                entry_height = std::max(entry_height, string_height);
            }
            else
            {
                m_entries[i].ex = entry_start + column_width;
                m_font_buf.add(m_entries[i].text, text_sx, text_sy);
            }
            m_entries[i].ey = m_entries[i].sy + entry_height;
            prev_height = m_entries[i].sy;
            height = std::max(height, m_entries[i].ey);
            column = (column + 1) % max_columns;
        }

    unsigned int string_width(const formatted_string &str);
    unsigned int string_height(const char *text);
    unsigned int string_height(const formatted_string &str);
    // Try to split this string to fit in w x h pixel area.
    formatted_string split(const formatted_string &str, unsigned int max_width,
                           unsigned int max_height);

    void store(FontBuffer &buf, float &x, float &y,
               const std::string &s, const VColour &c, float orig_x);
    void store(FontBuffer &buf, float &x, float &y, const formatted_string &fs,
               float orig_x);
    int find_index_before_width(const char *str, int max_width);

}
unsigned int FTFont::string_height(const formatted_string &str)
{
    std::string temp = str.tostring();
    return string_height(temp.c_str());
}
unsigned int FTFont::string_height(const char *text)
{
    int height = 1;
    for (const char *itr = text; (*itr); itr++)
    {
        if (*itr == '\n')
            height++;
    }
    return char_height() * height;
}

unsigned int FTFont::string_width(const formatted_string &str)
{
    std::string temp = str.tostring();
    return string_width(temp.c_str());

    unsigned int width = 0;

    unsigned int width = base_width;

}
int FTFont::find_index_before_width(const char *text, int max_width)
{
    int width = std::max(-m_min_offset, 0);
    for (int i = 0; text[i]; i++)
    {
        char c = text[i];
        width += m_glyphs[c].advance;
        int adjust = std::max(0, m_glyphs[c].width - m_glyphs[c].advance);
        if (width + adjust > max_width)
            return i;
    }
    return -1;
}
formatted_string FTFont::split(const formatted_string &str,
                               unsigned int max_width, unsigned int max_height)
{
    int max_lines = max_height / char_height();
    if (max_lines < 1)
        return formatted_string();
    formatted_string ret;
    ret += str;
    std::string base = str.tostring();
    int num_lines = 0;
    char *line = &base[0];
    while (true)
    {
        int line_end = find_index_before_width(line, max_width);
        if (line_end == -1)
            break;
        int space_idx = 0;
        for (char *search = &line[line_end]; search > line; search--)
        {
            if (*search == ' ')
            {
                space_idx = search - line;
                break;
            }
        }
        if (++num_lines >= max_lines || !space_idx)
        {
            int ellipses;
            if (space_idx && (space_idx - line_end > 2))
                ellipses = space_idx;
            else
                ellipses = line_end - 2;
            size_t idx = &line[ellipses] - &base[0];
            ret[idx] = '.';
            ret[idx+1] = '.';
            return ret.substr(0, idx + 2);
        }
        else
        {
            line[space_idx] = '\n';
            ret[&line[space_idx] - &base[0]] = '\n';
        }
        line = &line[space_idx+1];
    }
    return ret;

{
    store(buf, x, y, str, col, x);
}
void FTFont::store(FontBuffer &buf, float &x, float &y,
                   const std::string &str, const VColour &col, float orig_x)

            x = orig_x;

{
    store(buf, x, y, fs, x);
}
void FTFont::store(FontBuffer &buf, float &x, float &y,
                   const formatted_string &fs, float orig_x)

                store(buf, x, y, fs.ops[i].text, term_colours[colour]);

                store(buf, x, y, fs.ops[i].text, term_colours[colour], orig_x);

    virtual void set_num_columns(int columns) = 0; 

    virtual void set_num_columns(int columns) {}

    virtual void set_num_columns(int columns);

void MenuDisplayTile::set_num_columns(int columns)
{
    tiles.get_menu()->set_num_columns(columns);
}

    mdisplay->set_num_columns(1);

    mdisplay->set_num_columns(1);

    InvMenu(int mflags = MF_MULTISELECT)
        : Menu(mflags, "inventory"), type(MT_INVLIST), pre_select(NULL),
          title_annotate(NULL)
    {
    }

    InvMenu(int mflags = MF_MULTISELECT);

    virtual int max_columns() const { return 2; }

InvMenu::InvMenu(int mflags)
    : Menu(mflags, "inventory"), type(MT_INVLIST), pre_select(NULL),
      title_annotate(NULL)
{
    mdisplay->set_num_columns(2);
}

    formatted_string(const std::string &s, int init_colour = 0);

    explicit formatted_string(const std::string &s, int init_colour = 0);

    char &operator [] (size_t idx);

char &formatted_string::operator [] (size_t idx)
{
    size_t rel_idx = idx;
    int size = ops.size();
    for (int i = 0; i < size; ++i)
    {
        if (ops[i] != FSOP_TEXT)
            continue;
        size_t len = ops[i].text.length();
        if (rel_idx >= len)
            rel_idx -= len;
        else
            return ops[i].text[rel_idx];
    }
    ASSERT(!"Invalid index");
    char *invalid = NULL;
    return *invalid;
}