int level = seekspell(which_spell)->level;

    const int level = spell_difficulty(which_spell);

    switch (level)
    {
    case  1: return   50;
    case  2: return   95;
    case  3: return  160;
    case  4: return  250;
    case  5: return  350;
    case  6: return  550;
    case  7: return  700;
    case  8: return  850;
    case  9: return 1000;
    case 10: return 1000;
    case 11: return 1100;
    case 12: return 1250;
    case 13: return 1380;
    case 14: return 1500;
    case 15: return 1600;
    default: return 1600 + (20 * level);
    }
}                               // end spell_hunger();

    const int basehunger[] = {
        50, 95, 160, 250, 350, 550, 700, 850, 1000
    };
    int hunger;
    if ( level < 10 && level > 0 )
        hunger = basehunger[level-1];
    else
        hunger = (basehunger[0] * level * level) / 4;
    hunger -= you.intel * you.skills[SK_SPELLCASTING];
    if ( hunger < 0 )
        hunger = 0;

    return hunger;
}

const char* spell_hunger_string( spell_type spell );

static std::string spell_full_description(spell_type spell)

static std::string spell_base_description(spell_type spell)

            desc << spelltype_short_name(1 << i);

            desc << spelltype_name(1 << i);

    if ( so_far < 46 )
        desc << std::string(46 - so_far, ' ');

    if ( so_far < 60 )
        desc << std::string(60 - so_far, ' ');
    // spell fail rate, level
    desc << std::setw(12) << failure_rate_to_string(spell_fail(spell))
         << spell_difficulty(spell);
    return desc.str();
}

    // spell power, fail rate, level
    desc << std::setw(14) << spell_power_string(spell)
         << std::setw(12) << failure_rate_to_string(spell_fail(spell))

static std::string spell_extra_description(spell_type spell)
{
    std::ostringstream desc;
    desc << std::left;
    // spell name
    desc << std::setw(30) << spell_title(spell);
    // spell power, hunger level, level
    desc << std::setw(30) << spell_power_string(spell)
         << std::setw(12) << spell_hunger_string(spell)

    Menu spell_menu(MF_SINGLESELECT | MF_ANYPRINTABLE);

    ToggleableMenu spell_menu(MF_SINGLESELECT | MF_ANYPRINTABLE |
        MF_ALWAYS_SHOW_MORE);

        new MenuEntry(

        new ToggleableMenuEntry(

            "Power         Success   Level",

            "              Success   Level",
            " Your Spells                      Power           "
            "              Hunger    Level",

    spell_menu.set_more(formatted_string("Press '!' to toggle spell view."));
    spell_menu.add_toggle_key('!');

            MenuEntry* me = new MenuEntry(spell_full_description(spell),
                                          MEL_ITEM, 1, letter);

            ToggleableMenuEntry* me =
                new ToggleableMenuEntry(spell_base_description(spell),
                                        spell_extra_description(spell),
                                        MEL_ITEM, 1, letter);

    char spc = 0;
    char spc2 = 0;
    int spellh = 0;
    unsigned char keyin = 0;
    char unthing = 0;

    // first query {dlb}:

    int keyin = 0;              // silence stupid compilers

        //jmf: FIXME: change to reflect range of known spells

            unthing = list_spells();

            keyin = list_spells();

            if (unthing == 2)
                return (false);

            if ( isalpha(unthing) )
            {
                keyin = unthing;

            if ( isalpha(keyin) )

            }

    spc = (int) keyin;

    if (!isalpha(spc))

    if (!isalpha(keyin))

    const spell_type spell = get_spell_by_letter( spc );

    spc2 = letter_to_index(spc);

    const spell_type spell = get_spell_by_letter( keyin );

        spellh = spell_hunger( spell );
        // I wonder if a better algorithm is called for? {dlb}
        spellh -= you.intel * you.skills[SK_SPELLCASTING];
        if (spellh < 1)
            spellh = 1;
        else

        const int spellh = spell_hunger( spell );
        if (spellh > 0)

const char* spell_hunger_string( spell_type spell )
{
    const int hunger = spell_hunger(spell);
    if ( hunger == 0 )
        return "None";
    else if ( hunger < 25 )
        return "Minor";
    else if ( hunger < 150 )
        return "Moderate";
    else if ( hunger < 500 )
        return "Major";
    else
        return "Extreme";
}

};
struct ToggleableMenuEntry : public MenuEntry
{
public:
    std::string alt_text;
    ToggleableMenuEntry( const std::string &txt = std::string(),
                         const std::string &alt_txt = std::string(),
                         MenuEntryLevel lev = MEL_ITEM,
                         int qty = 0, int hotk = 0 ) :
        MenuEntry(txt, lev, qty, hotk), alt_text(alt_txt) {}
    void toggle() { text.swap(alt_text); }

// Allows toggling by specific keys.
class ToggleableMenu : public Menu
{
public:
    ToggleableMenu( int _flags = MF_MULTISELECT ) : Menu(_flags) {}
    void add_toggle_key(int newkey) { toggle_keys.push_back(newkey); }
protected:
    virtual int pre_process(int key);
    std::vector<int> toggle_keys;
};

int ToggleableMenu::pre_process(int key)
{
    if ( std::find(toggle_keys.begin(), toggle_keys.end(), key) !=
         toggle_keys.end() )
    {
        // Toggle all menu entries
        for ( unsigned int i = 0; i < items.size(); ++i )
        {
            ToggleableMenuEntry* const p =
                dynamic_cast<ToggleableMenuEntry*>(items[i]);
            if ( p )
                p->toggle();
        }
        // Toggle title
        ToggleableMenuEntry* const pt =
            dynamic_cast<ToggleableMenuEntry*>(title);
        if ( pt )
            pt->toggle();
        // Redraw
        draw_menu();
        // Don't further process the key
        return 0;
    }
    return key;
}