Return to selbox.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / bin / vsh / winlib

Annotation of coherent/g/usr/bin/vsh/winlib/selbox.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *      Output a select box and select one option
                      3:  *
                      4:  *      Copyright (c) 1990-93 by Udo Munk
                      5:  */
                      6: 
                      7: #ifdef AIX
                      8: #define NLS
                      9: #endif
                     10: 
                     11: #include <curses.h>
                     12: #include <string.h>
                     13: #include "winfun.h"
                     14: 
                     15: extern WINDOW *open_window();
                     16: extern int close_window();
                     17: 
                     18: select_box(b, opt, attr)
                     19: char *b[];
                     20: int opt;
                     21: chtype attr;
                     22: {
                     23:        register int i, j;
                     24:        int bw, bh, nt, ni, ai, itoff, ilen, eoj;
                     25:        WINDOW *w;
                     26: 
                     27:        i = bw = bh = 0;
                     28:        ai = opt;
                     29:        while (b[i] != NULL)
                     30:                if ((j = strlen(b[i++]) + 2) > bw)
                     31:                        bw = j; /* width of the box */
                     32:        bh = i + 4;             /* high of the box */
                     33:        nt = i;                 /* number of options */
                     34:        itoff = ++i;
                     35:        ilen = 0;
                     36:        while (b[i] != NULL) {
                     37:                ilen += strlen(b[i]) + 3;
                     38:                i++;
                     39:        }
                     40:        ilen--;
                     41:        ni = i - itoff;
                     42:        if (ilen > (bw - 2))
                     43:                bw = ilen + 2;
                     44:        if ((w = open_window(bh, bw, (LINES-bh)/2, (COLS-bw)/2)) == (WINDOW *) 0)
                     45:                nomem();
                     46:        cursoroff();
                     47:        leaveok(w, TRUE);
                     48:        wattron(w, A_REVERSE);
                     49:        for (i = 0; i < bh; i++)/* output the inverted box */
                     50:                for (j = 0; j < bw; j++)
                     51:                        mvwaddch(w, i, j, ' ');
                     52:        for (i = 0; i < nt; i++)
                     53:                mvwaddstr(w, i+1, 1, b[i]);
                     54:        wattroff(w, A_REVERSE);
                     55:        dialog_options(w, nt+2, (bw-ilen)/2, b, itoff, ai, attr);
                     56:        eoj = 1;
                     57:        while (eoj) {
                     58:                switch (wgetch(w)) {
                     59:                case ' ':
                     60:                case W_KEY_TAB:
                     61:                case KEY_RIGHT:
                     62:                        ai++;
                     63:                        if (ai > ni)
                     64:                                ai = 1;
                     65:                        dialog_options(w, nt+2, (bw-ilen)/2, b, itoff, ai, attr);
                     66:                        break;
                     67:                case W_KEY_BTAB:
                     68:                case KEY_LEFT:
                     69:                        ai--;
                     70:                        if (ai < 1)
                     71:                                ai = ni;
                     72:                        dialog_options(w, nt+2, (bw-ilen)/2, b, itoff, ai, attr);
                     73:                        break;
                     74:                case '\r':
                     75:                case KEY_ENTER:
                     76:                        eoj = 0;
                     77:                        break;
                     78:                case W_KEY_REFR:
                     79: #ifdef KEY_REFR
                     80:                case KEY_REFR:
                     81: #endif
                     82:                        wrefresh(curscr);
                     83:                        break;
                     84:                default:
                     85:                        break;
                     86:                }
                     87:        }
                     88:        close_window(w);
                     89:        return(ai);
                     90: }
                     91: 
                     92: /*
                     93:  *      output options in to the box
                     94:  */
                     95: static dialog_options(w, y, x, s, o, a, attr)
                     96: WINDOW *w;
                     97: char *s[];
                     98: int y, x, o, a;
                     99: chtype attr;
                    100: {
                    101:        register int j;
                    102: 
                    103:        j = 1;
                    104:        wmove(w, y, x);
                    105:        while (s[o] != NULL) {
                    106:                waddch(w, ' ');
                    107:                if (j == a) {
                    108:                        wattron(w, attr);
                    109:                        waddstr(w, s[o++]);
                    110:                        wattroff(w, attr);
                    111:                } else
                    112:                        waddstr(w, s[o++]);
                    113:                waddch(w, ' ');
                    114:                wattron(w, A_REVERSE);
                    115:                waddch(w, ' ');
                    116:                wattroff(w, A_REVERSE);
                    117:                j++;
                    118:        }
                    119:        wrefresh(w);
                    120: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.