root/trunk/src/cmd4.c

/*
 * File: cmd4.c
 * Purpose: Various kinds of browsing functions.
 *
 * Copyright (c) 1997-2007 Robert A. Koeneke, James E. Wilson, Ben Harrison,
 * Eytan Zweig, Andrew Doull, Pete Mack.
 *
 * This work is free software; you can redistribute it and/or modify it
 * under the terms of either:
 *
 * a) the GNU General Public License as published by the Free Software
 *    Foundation, version 2, or
 *
 * b) the "Angband licence":
 *    This software may be copied and distributed for educational, research,
 *    and not for profit purposes provided that this copyright and statement
 *    are included in all such copies.  Other copyrights may also apply.
 */
#include "angband.h"
#include "tvalsval.h"
#include "option.h"
#include "ui.h"
#include "externs.h"
#include "ui-menu.h"


static void do_cmd_pref_file_hack(long row);



/* Flag value for missing array entry */
#define MISSING -17

#define APP_MACRO       101
#define ASK_MACRO       103
#define DEL_MACRO       104
#define NEW_MACRO       105
#define APP_KEYMAP      106
#define ASK_KEYMAP      107
#define DEL_KEYMAP      108
#define NEW_KEYMAP      109
#define ENTER_ACT       110
#define LOAD_PREF       111
#define DUMP_MON        112
#define DUMP_OBJ        113
#define DUMP_FEAT       114
#define DUMP_FLAV       115
#define MOD_MON         116
#define MOD_OBJ         117
#define MOD_FEAT        118
#define MOD_FLAV        119
#define DUMP_COL        120
#define MOD_COL         121
#define RESET_VIS       122


#define INFO_SCREENS 2 /* Number of screens in character info mode */



typedef struct
{
        int maxnum;          /* Maximum possible item count for this class */
        bool easy_know;      /* Items don't need to be IDed to recognize membership */

        const char *(*name)(int gid);               /* Name of this group */

        /* Compare, in group and display order (optional if already sorted) */
        int (*gcomp)(const void *, const void *);   /* Compares gids of two oids */
        int (*group)(int oid);                      /* Returns gid for an oid */

        /* Summary function for the "object" information. */
        void (*summary)(int gid, const int *object_list, int n, int top, int row, int col);

} group_funcs;

typedef struct
{
        /* Displays an entry at specified location, including kill-count and graphics */
        void (*display_member)(int col, int row, bool cursor, int oid);

        void (*lore)(int oid);       /* Displays lore for an oid */


        /* Required only for objects with modifiable display attributes */
        /* Unknown 'flavors' return flavor attributes */
        char *(*xchar)(int oid);     /* Get character attr for OID (by address) */
        byte *(*xattr)(int oid);     /* Get color attr for OID (by address) */

        const char *(*xtra_prompt)(int oid);  /* Returns optional extra prompt */
        void (*xtra_act)(char ch, int oid);   /* Handles optional extra actions */

        bool is_visual;                       /* Does this kind have visual editing? */

} member_funcs;


/* Helper class for generating joins */
typedef struct join
{
                int oid;
                int gid;
} join_t;

/* A default group-by */
static join_t *default_join;
#if 0
static int default_join_cmp(const void *a, const void *b)
{
                join_t *ja = &default_join[*(int*)a];
                join_t *jb = &default_join[*(int*)b];
                int c = ja->gid - jb->gid;
                if (c) return c;
                return ja->oid - jb->oid;
}
#endif
static int default_group(int oid) { return default_join[oid].gid; }


static int *obj_group_order;

/*
 * Description of each monster group.
 */
static struct
{
        cptr chars;
        cptr name;
} monster_group[] =
{
        { (cptr)-1,     "Uniques" },
        { "A",          "Angels" },
        { "a",          "Ants" },
        { "b",          "Bats" },
        { "B",          "Birds" },
        { "C",          "Canines" },
        { "c",          "Centipedes" },
        { "uU",         "Demons" },
        { "dD",         "Dragons" },
        { "vE",         "Elementals/Vortices" },
        { "e",          "Eyes/Beholders" },
        { "f",          "Felines" },
        { "G",          "Ghosts" },
        { "OP",         "Giants/Ogres" },
        { "g",          "Golems" },
        { "H",          "Harpies/Hybrids" },
        { "h",          "Hominids (Elves, Dwarves)" },
        { "M",          "Hydras" },
        { "i",          "Icky Things" },
        { "lFI",        "Insects" },
        { "j",          "Jellies" },
        { "K",          "Killer Beetles" },
        { "k",          "Kobolds" },
        { "L",          "Lichs" },
        { "tp",         "Men" },
        { ".$?!_",      "Mimics" },
        { "m",          "Molds" },
        { ",",          "Mushroom Patches" },
        { "n",          "Nagas" },
        { "o",          "Orcs" },
        { "q",          "Quadrupeds" },
        { "Q",          "Quylthulgs" },
        { "R",          "Reptiles/Amphibians" },
        { "r",          "Rodents" },
        { "S",          "Scorpions/Spiders" },
        { "s",          "Skeletons/Drujs" },
        { "J",          "Snakes" },
        { "T",          "Trolls" },
        { "V",          "Vampires" },
        { "W",          "Wights/Wraiths" },
        { "w",          "Worms/Worm Masses" },
        { "X",          "Xorns/Xarens" },
        { "Y",          "Yeti" },
        { "Z",          "Zephyr Hounds" },
        { "z",          "Zombies" },
        { NULL,         NULL }
};

/*
 * Description of each feature group.
 */
const char *feature_group_text[] = 
{
        "Floors",
        "Traps",
        "Doors",
        "Stairs",
        "Walls",
        "Streamers",
        "Obstructions",
        "Stores",
        "Other",
        NULL
};



/* Useful method declarations */
static void display_visual_list(int col, int row, int height, int width,
                                byte attr_top, char char_left);

static bool visual_mode_command(ui_event_data ke, bool *visual_list_ptr, 
                                int height, int width, 
                                byte *attr_top_ptr, char *char_left_ptr, 
                                byte *cur_attr_ptr, char *cur_char_ptr,
                                int col, int row, int *delay);

static void place_visual_list_cursor(int col, int row, byte a,
                                byte c, byte attr_top, byte char_left);

static void dump_pref_file(void (*dump)(ang_file *), const char *title, int row);

/*
 * Clipboard variables for copy&paste in visual mode
 */
static byte attr_idx = 0;
static byte char_idx = 0;

/*
 * Return a specific ordering for the features
 */
int feat_order(int feat)
{
        feature_type *f_ptr = &f_info[feat];

        switch (f_ptr->d_char)
        {
                case '.':                               return 0;
                case '^':                               return 1;
                case '\'': case '+':    return 2;
                case '<': case '>':             return 3;
                case '#':                               return 4;
                case '*': case '%' :    return 5;
                case ';': case ':' :    return 6;

                default:
                {
                        return 8;
                }
        }
}


/* Emit a 'graphical' symbol and a padding character if appropriate */
static void big_pad(int col, int row, byte a, byte c)
{
        Term_putch(col, row, a, c);
        if (!use_bigtile) return;

        if (a & 0x80)
                Term_putch(col + 1, row, 255, -1);
        else
                Term_putch(col + 1, row, 1, ' ');
}

/* Return the actual width of a symbol */
static int actual_width(int width)
{
#ifdef UNANGBAND
        if (use_trptile) width *= 3;
        else if (use_dbltile) width *= 2;
#endif

        if (use_bigtile) width *= 2;

        return width;
}

/* Return the actual height of a symbol */
static int actual_height(int height)
{
#ifdef UNANGBAND
        if (use_trptile) height = height * 3 / 2;
        else if (use_dbltile) height *= 2;
#endif

        if (use_bigtile) height *= 2;

        return height;
}


/* From an actual width, return the logical width */
static int logical_width(int width)
{
        int div = 1;

#ifdef UNANGBAND
        if (use_trptile) div = 3;
        else if (use_dbltile) div = 2;
#endif

        if (use_bigtile) div *= 2;

        return width / div;
}

/* From an actual height, return the logical height */
static int logical_height(int height)
{
        int div = 1;

#ifdef UNANGBAND
        if (use_trptile)
        {
                height *= 2;
                div = 3;
        }
        else if (use_dbltile) div = 2;
#endif

        if (use_bigtile) div *= 2;

        return height / div;
}


static void display_group_member(menu_type *menu, int oid,
                                                bool cursor, int row, int col, int wid)
{
        const member_funcs *o_funcs = menu->menu_data;
        byte attr = curs_attrs[CURS_KNOWN][cursor == oid];

        (void)wid;

        /* Print the interesting part */
        o_funcs->display_member(col, row, cursor, oid);

#if 0 /* Debugging code */
        c_put_str(attr, format("%d", oid), row, 60);
#endif

        /* Do visual mode */
        if (o_funcs->is_visual && o_funcs->xattr)
        {
                char c = *o_funcs->xchar(oid);
                byte a = *o_funcs->xattr(oid);

                c_put_str(attr, format((c & 0x80) ? "%02x/%02x" : "%02x/%d", a, c), row, 60);
        }
}

static const char *recall_prompt(int oid)
{
        (void)oid;
        return ", 'r' to recall";
}

#define swap(a, b) (swapspace = (void*)(a)), ((a) = (b)), ((b) = swapspace)

/*
 * Interactive group by. 
 * Recognises inscriptions, graphical symbols, lore
 */
static void display_knowledge(const char *title, int *obj_list, int o_count,
                                group_funcs g_funcs, member_funcs o_funcs,
                                const char *otherfields)
{
        /* maximum number of groups to display */
        int max_group = g_funcs.maxnum < o_count ? g_funcs.maxnum : o_count ;

        /* This could (should?) be (void **) */
        int *g_list, *g_offset;

        const char **g_names;

        int g_name_len = 8;  /* group name length, minumum is 8 */

        int grp_cnt = 0; /* total number groups */

        int g_cur = 0, grp_old = -1; /* group list positions */
        int o_cur = 0;                                  /* object list positions */
        int g_o_count = 0;                               /* object count for group */
        int oid = -1;                           /* object identifiers */

        region title_area = { 0, 0, 0, 4 };
        region group_region = { 0, 6, MISSING, -2 };
        region object_region = { MISSING, 6, 0, -2 };

        /* display state variables */
        bool visual_list = FALSE;
        byte attr_top = 0;
        char char_left = 0;

        int delay = 0;

        menu_type group_menu;
        menu_type object_menu;
        menu_iter object_iter;

        /* Panel state */
        /* These are swapped in parallel whenever the actively browsing " */
        /* changes */
        int *active_cursor = &g_cur, *inactive_cursor = &o_cur;
        menu_type *active_menu = &group_menu, *inactive_menu = &object_menu;
        int panel = 0;

        void *swapspace;
        bool do_swap = FALSE;

        bool flag = FALSE;
        bool redraw = TRUE;

        int browser_rows;
        int wid, hgt;
        int i;
        int prev_g = -1;

        int omode = rogue_like_commands;


        /* Get size */
        Term_get_size(&wid, &hgt);
        browser_rows = hgt - 8;

        /* Disable the roguelike commands for the duration */
        rogue_like_commands = FALSE;



        /* Do the group by. ang_sort only works on (void **) */
        /* Maybe should make this a precondition? */
        if (g_funcs.gcomp)
                qsort(obj_list, o_count, sizeof(*obj_list), g_funcs.gcomp);


        /* Sort everything into group order */
        g_list = C_ZNEW(max_group + 1, int);
        g_offset = C_ZNEW(max_group + 1, int);

        for (i = 0; i < o_count; i++)
        {
                if (prev_g != g_funcs.group(obj_list[i]))
                {
                        prev_g = g_funcs.group(obj_list[i]);
                        g_offset[grp_cnt] = i;
                        g_list[grp_cnt++] = prev_g;
                }
        }

        g_offset[grp_cnt] = o_count;
        g_list[grp_cnt] = -1;


        /* The compact set of group names, in display order */
        g_names = C_ZNEW(grp_cnt, const char **);

        for (i = 0; i < grp_cnt; i++)
        {
                int len;
                g_names[i] = g_funcs.name(g_list[i]);
                len = strlen(g_names[i]);
                if (len > g_name_len) g_name_len = len;
        }

        /* Reasonable max group name len */
        if (g_name_len >= 20) g_name_len = 20;

        object_region.col = g_name_len + 3;
        group_region.width = g_name_len;


        /* Leave room for the group summary information */
        if (g_funcs.summary) object_region.page_rows = -3;


        /* Set up the two menus */
        WIPE(&group_menu, menu_type);
        group_menu.count = grp_cnt;
        group_menu.cmd_keys = "\n\r6\x8C";  /* Ignore these as menu commands */
        group_menu.menu_data = g_names;

        WIPE(&object_menu, menu_type);
        object_menu.menu_data = &o_funcs;
        WIPE(&object_iter, object_iter);
        object_iter.display_row = display_group_member;

        o_funcs.is_visual = FALSE;

        menu_init(&group_menu, MN_SKIN_SCROLL, find_menu_iter(MN_ITER_STRINGS), &group_region);
        menu_init(&object_menu, MN_SKIN_SCROLL, &object_iter, &object_region);


        /* This is the event loop for a multi-region panel */
        /* Panels are -- text panels, two menus, and visual browser */
        /* with "pop-up menu" for lore */
        while ((!flag) && (grp_cnt))
        {
                ui_event_data ke, ke0;

                if (redraw)
                {
                        /* Print the title bits */
                        region_erase(&title_area);
                        prt(format("Knowledge - %s", title), 2, 0);
                        prt("Group", 4, 0);
                        prt("Name", 4, g_name_len + 3);

                        if (otherfields)
                                prt(otherfields, 4, 55);


                        /* Print dividers: horizontal and vertical */
                        for (i = 0; i < 79; i++)
                                Term_putch(i, 5, TERM_WHITE, '=');

                        for (i = 0; i < browser_rows; i++)
                                Term_putch(g_name_len + 1, 6 + i, TERM_WHITE, '|');


                        /* Reset redraw flag */
                        redraw = FALSE;
                }

                if (g_cur != grp_old)
                {
                        grp_old = g_cur;
                        o_cur = 0;
                        g_o_count = g_offset[g_cur+1] - g_offset[g_cur];
                        menu_set_filter(&object_menu, obj_list + g_offset[g_cur], g_o_count);
                        group_menu.cursor = g_cur;
                        object_menu.cursor = 0;
                }

                /* HACK ... */
                if (!visual_list)
                {
                        /* ... The object menu may be browsing the entire group... */
                        o_funcs.is_visual = FALSE;
                        menu_set_filter(&object_menu, obj_list + g_offset[g_cur], g_o_count);
                        object_menu.cursor = o_cur;
                }
                else
                {
                        /* ... or just a single element in the group. */
                        o_funcs.is_visual = TRUE;
                        menu_set_filter(&object_menu, obj_list + o_cur + g_offset[g_cur], 1);
                        object_menu.cursor = 0;
                }

                oid = obj_list[g_offset[g_cur]+o_cur];

                /* Print prompt */
                {
                        const char *pedit = (!o_funcs.xattr) ? "" :
                                        (!(attr_idx|char_idx) ? ", 'c' to copy" : ", 'c', 'p' to paste");
                        const char *xtra = o_funcs.xtra_prompt ? o_funcs.xtra_prompt(oid) : "";
                        const char *pvs = "";

                        if (visual_list) pvs = ", ENTER to accept";
                        else if (o_funcs.xattr) pvs = ", 'v' for visuals";



                        prt(format("<dir>%s%s%s, ESC", pvs, pedit, xtra), hgt - 1, 0);
                }

                if (do_swap)
                {
                        do_swap = FALSE;
                        swap(active_menu, inactive_menu);
                        swap(active_cursor, inactive_cursor);
                        panel = 1 - panel;
                }

                if (g_funcs.summary && !visual_list)
                {
                        g_funcs.summary(g_cur, obj_list, g_o_count, g_offset[g_cur],
                                        object_menu.boundary.row + object_menu.boundary.page_rows,
                                        object_region.col);
                }

                menu_refresh(inactive_menu);
                menu_refresh(active_menu);

                handle_stuff();

                if (visual_list)
                {
                        display_visual_list(g_name_len + 3, 7, browser_rows-1,
                                                     wid - (g_name_len + 3), attr_top, char_left);
                        place_visual_list_cursor(g_name_len + 3, 7, *o_funcs.xattr(oid), 
                                                                                *o_funcs.xchar(oid), attr_top, char_left);
                }

                if (delay)
                {
                        /* Force screen update */
                        Term_fresh();

                        /* Delay */
                        Term_xtra(TERM_XTRA_DELAY, delay);

                        delay = 0;
                }

                ke = inkey_ex();

                /* Do visual mode command if needed */
                if (o_funcs.xattr && o_funcs.xchar &&
                                        visual_mode_command(ke, &visual_list,
                                        browser_rows-1, wid - (g_name_len + 3),
                                        &attr_top, &char_left,
                                        o_funcs.xattr(oid), o_funcs.xchar(oid),
                                        g_name_len + 3, 7, &delay))
                {
                        continue;
                }

                if (ke.type == EVT_MOUSE)
                {
                        /* Change active panels */
                        if (region_inside(&inactive_menu->boundary, &ke))
                        {
                                swap(active_menu, inactive_menu);
                                swap(active_cursor, inactive_cursor);
                                panel = 1-panel;
                        }
                }

                ke0 = run_event_loop(&active_menu->target, &ke);
                if (ke0.type != EVT_AGAIN) ke = ke0;

                switch (ke.type)
                {
                        case EVT_KBRD:
                        {
                                break;
                        }

                        case ESCAPE:
                        {
                                flag = TRUE;
                                continue;
                        }

                        case EVT_SELECT:
                        {
                                if (panel == 1 && oid >= 0 && o_cur == active_menu->cursor)
                                {
                                        o_funcs.lore(oid);
                                        redraw = TRUE;
                                }
                        }

                        case EVT_MOVE:
                        {
                                *active_cursor = active_menu->cursor;
                                continue;
                        }

                        case EVT_BACK:
                        {
                                if (panel == 1)
                                        do_swap = TRUE;
                        }

                        /* XXX Handle EVT_RESIZE */

                        default:
                        {
                                continue;
                        }
                }

                switch (ke.key)
                {
                        case ESCAPE:
                        {
                                flag = TRUE;
                                break;
                        }

                        case 'R':
                        case 'r':
                        {
                                /* Recall on screen */
                                if (oid >= 0)
                                        o_funcs.lore(oid);

                                redraw = TRUE;
                                break;
                        }

                        /* Jump down a page */
                        case '3':
                        {
                                *active_cursor += browser_rows;

                                if (g_cur >= grp_cnt) g_cur = grp_cnt - 1;
                                else if (o_cur >= g_o_count) o_cur = g_o_count - 1;

                                break;
                        }

                        /* Jump up a page */
                        case '9':
                        {
                                *active_cursor -= browser_rows;

                                if (*active_cursor < 0) *active_cursor = 0;

                                break;
                        }

                        default:
                        {
                                int d = target_dir(ke.key);

                                /* Handle key-driven motion between panels */
                                if (ddx[d] && ((ddx[d] < 0) == (panel == 1)))
                                {
                                        /* Silly hack -- diagonal arithmetic */
                                        *inactive_cursor += ddy[d];
                                        if (*inactive_cursor < 0) *inactive_cursor = 0;
                                        else if (g_cur >= grp_cnt) g_cur = grp_cnt - 1;
                                        else if (o_cur >= g_o_count) o_cur = g_o_count - 1;
                                        do_swap = TRUE;
                                }
                                else if (o_funcs.xtra_act)
                                {
                                        o_funcs.xtra_act(ke.key, oid);
                                }

                                break;
                        }
                }
        }

        /* Restore roguelike option */
        rogue_like_commands = omode;

        /* Prompt */
        if (!grp_cnt)
                prt(format("No %s known.", title), 15, 0);

        FREE(g_names);
        FREE(g_offset);
        FREE(g_list);
}

/*
 * Display visuals.
 */
static void display_visual_list(int col, int row, int height, int width, byte attr_top, char char_left)
{
        int i, j;

        /* Clear the display lines */
        for (i = 0; i < height; i++)
                        Term_erase(col, row + i, width);

        width = logical_width(width);

        /* Display lines until done */
        for (i = 0; i < height; i++)
        {
                /* Display columns until done */
                for (j = 0; j < width; j++)
                {
                        byte a;
                        char c;
                        int x = col + actual_width(j);
                        int y = row + actual_width(i);
                        int ia, ic;

                        ia = attr_top + i;
                        ic = char_left + j;

                        a = (byte)ia;
                        c = (char)ic;

                        /* Display symbol */
                        big_pad(x, y, a, c);
                }
        }
}


/*
 * Place the cursor at the collect position for visual mode
 */
static void place_visual_list_cursor(int col, int row, byte a, byte c, byte attr_top, byte char_left)
{
        int i = a - attr_top;
        int j = c - char_left;

        int x = col + actual_width(j);
        int y = row + actual_height(i);

        /* Place the cursor */
        Term_gotoxy(x, y);
}


/*
 *  Do visual mode command -- Change symbols
 */
static bool visual_mode_command(ui_event_data ke, bool *visual_list_ptr, 
                                int height, int width, 
                                byte *attr_top_ptr, char *char_left_ptr, 
                                byte *cur_attr_ptr, char *cur_char_ptr,
                                int col, int row, int *delay)
{
        static byte attr_old = 0;
        static char char_old = 0;

        int frame_left = logical_width(10);
        int frame_right = logical_width(10);
        int frame_top = logical_height(4);
        int frame_bottom = logical_height(4);

        switch (ke.key)
        {
                case ESCAPE:
                {
                        if (*visual_list_ptr)
                        {
                                /* Cancel change */