TEX_TITLE,

struct tile_def
{
    tile_def(int _tile, TextureID _tex) : tile(_tile), tex(_tex) {}
    int tile;
    TextureID tex;
};

        int tile;
        TextureID texture;

        std::vector<tile_def> tiles;

    TileBuffer m_tile_buf;

    FixedVector<TileBuffer, TEX_MAX> m_tile_buf;

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

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

    for (int i = 0; i < TEX_MAX; i++)
        m_tile_buf[i].set_tex(&m_image->m_textures[i]);

    m_tile_buf.clear();

    for (int t = 0; t < TEX_MAX; t++)
        m_tile_buf[t].clear();

    TextureID tex = TEX_MAX;

            if (m_entries[i].tile)

            if (m_entries[i].tiles.size() > 0)

                // 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);

                for (unsigned int t = 0; t < m_entries[i].tiles.size(); t++)
                {
                    // NOTE: This is not perfect. Tiles will be drawn
                    // sorted by texture first, e.g. you can never draw
                    // a dungeon tile over a monster tile.
                    int tile = m_entries[i].tiles[t].tile;
                    TextureID tex = m_entries[i].tiles[t].tex;
                    m_tile_buf[tex].add(tile, m_entries[i].sx, m_entries[i].sy);
                }

    m_tile_buf.draw();

    for (int i = 0; i < TEX_MAX; i++)
        m_tile_buf[i].draw();

    m_tile_buf.clear();

    for (int i = 0; i < TEX_MAX; i++)
        m_tile_buf[i].clear();

    if (!me->tile(e.tile, e.texture))
        e.tile = 0;

    e.tiles.clear();
    me->get_tiles(e.tiles);

    if (!m_textures[TEX_TITLE].load_texture("title.png", mip))
        return false;

    TileBuffer(const TilesTexture *tex);

    TileBuffer(const TilesTexture *tex = NULL);

    virtual bool tile(int &idx, TextureID &tex) const

    virtual bool get_tiles(std::vector<tile_def>& tileset) const

        return false;

        return (false);

    virtual bool tile(int &tile, TextureID &tex) const;

    virtual bool get_tiles(std::vector<tile_def>& tiles) const;

bool InvEntry::tile(int &idx, TextureID &tex) const

bool InvEntry::get_tiles(std::vector<tile_def>& tileset) const

    idx = tileidx_item(*item);
    tex = TEX_DEFAULT;

    int idx = tileidx_item(*item);
    if (!idx)
        return (false);

    return (idx != 0);

    tileset.push_back(tile_def(TILE_ITEM_SLOT, TEX_DUNGEON));
    tileset.push_back(tile_def(idx, TEX_DEFAULT));
    return (true);