test/demo_menus.c

   1 /****************************************************************************
   2  * Copyright (c) 2005-2007,2008 Free Software Foundation, Inc.              *
   3  *                                                                          *
   4  * Permission is hereby granted, free of charge, to any person obtaining a  *
   5  * copy of this software and associated documentation files (the            *
   6  * "Software"), to deal in the Software without restriction, including      *
   7  * without limitation the rights to use, copy, modify, merge, publish,      *
   8  * distribute, distribute with modifications, sublicense, and/or sell       *
   9  * copies of the Software, and to permit persons to whom the Software is    *
  10  * furnished to do so, subject to the following conditions:                 *
  11  *                                                                          *
  12  * The above copyright notice and this permission notice shall be included  *
  13  * in all copies or substantial portions of the Software.                   *
  14  *                                                                          *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  22  *                                                                          *
  23  * Except as contained in this notice, the name(s) of the above copyright   *
  24  * holders shall not be used in advertising or otherwise to promote the     *
  25  * sale, use or other dealings in this Software without prior written       *
  26  * authorization.                                                           *
  27  ****************************************************************************/
  28 /*
  29  * $Id: demo_menus.c,v 1.27 2008/08/04 15:37:52 tom Exp $
  30  *
  31  * Demonstrate a variety of functions from the menu library.
  32  * Thomas Dickey - 2005/4/9
  33  */
  34 /*
  35 item_description                -
  36 item_init                       -
  37 item_opts                       -
  38 item_opts_off                   -
  39 item_opts_on                    -
  40 item_term                       -
  41 item_userptr                    -
  42 item_visible                    -
  43 menu_back                       -
  44 menu_fore                       -
  45 menu_format                     -
  46 menu_grey                       -
  47 menu_init                       -
  48 menu_opts                       -
  49 menu_pad                        -
  50 menu_request_by_name            -
  51 menu_request_name               -
  52 menu_sub                        -
  53 menu_term                       -
  54 menu_userptr                    -
  55 set_current_item                -
  56 set_item_init                   -
  57 set_item_opts                   -
  58 set_item_term                   -
  59 set_item_userptr                -
  60 set_menu_grey                   -
  61 set_menu_init                   -
  62 set_menu_items                  -
  63 set_menu_opts                   -
  64 set_menu_pad                    -
  65 set_menu_pattern                -
  66 set_menu_spacing                -
  67 set_menu_term                   -
  68 set_menu_userptr                -
  69 set_top_row                     -
  70 top_row                         -
  71 */
  72
  73 #include <test.priv.h>
  74
  75 #if USE_LIBMENU
  76
  77 #include <menu.h>
  78
  79 #include <sys/types.h>
  80 #include <sys/stat.h>
  81
  82 #ifdef NCURSES_VERSION
  83 #ifdef TRACE
  84 static unsigned save_trace = TRACE_ORDINARY | TRACE_CALLS;
  85 extern unsigned _nc_tracing;
  86 static MENU *mpTrace;
  87 #endif
  88 #else
  89 #undef TRACE
  90 #endif
  91
  92 typedef enum {
  93     eBanner = -1
  94     ,eFile
  95     ,eSelect
  96 #ifdef TRACE
  97     ,eTrace
  98 #endif
  99     ,eMAX
 100 } MenuNo;
 101
 102 #define okMenuNo(n) (((n) > eBanner) && ((n) < eMAX))
 103
 104 #define MENU_Y  1
 105
 106 static MENU *mpBanner;
 107 static MENU *mpFile;
 108 static MENU *mpSelect;
 109
 110 #if !HAVE_STRDUP
 111 #define strdup my_strdup
 112 static char *
 113 strdup(char *s)
 114 {
 115     char *p = typeMalloc(char, strlen(s) + 1);
 116     if (p)
 117         strcpy(p, s);
 118     return (p);
 119 }
 120 #endif /* not HAVE_STRDUP */
 121
 122 /* Common function to allow ^T to toggle trace-mode in the middle of a test
 123  * so that trace-files can be made smaller.
 124  */
 125 static int
 126 wGetchar(WINDOW *win)
 127 {
 128     int c;
 129 #ifdef TRACE
 130     while ((c = wgetch(win)) == CTRL('T')) {
 131         if (_nc_tracing) {
 132             save_trace = _nc_tracing;
 133             Trace(("TOGGLE-TRACING OFF"));
 134             _nc_tracing = 0;
 135         } else {
 136             _nc_tracing = save_trace;
 137         }
 138         trace(_nc_tracing);
 139         if (_nc_tracing)
 140             Trace(("TOGGLE-TRACING ON"));
 141     }
 142 #else
 143     c = wgetch(win);
 144 #endif
 145     return c;
 146 }
 147 #define Getchar() wGetchar(stdscr)
 148
 149 static int
 150 menu_virtualize(int c)
 151 {
 152     int result;
 153
 154     if (c == '\n' || c == KEY_EXIT)
 155         result = (MAX_COMMAND + 1);
 156     else if (c == 'u')
 157         result = (REQ_SCR_ULINE);
 158     else if (c == 'd')
 159         result = (REQ_SCR_DLINE);
 160     else if (c == 'b' || c == KEY_NPAGE)
 161         result = (REQ_SCR_UPAGE);
 162     else if (c == 'f' || c == KEY_PPAGE)
 163         result = (REQ_SCR_DPAGE);
 164     else if (c == 'l' || c == KEY_LEFT || c == KEY_BTAB)
 165         result = (REQ_LEFT_ITEM);
 166     else if (c == 'n' || c == KEY_DOWN)
 167         result = (REQ_NEXT_ITEM);
 168     else if (c == 'p' || c == KEY_UP)
 169         result = (REQ_PREV_ITEM);
 170     else if (c == 'r' || c == KEY_RIGHT || c == '\t')
 171         result = (REQ_RIGHT_ITEM);
 172     else if (c == ' ')
 173         result = (REQ_TOGGLE_ITEM);
 174     else {
 175         if (c != KEY_MOUSE)
 176             beep();
 177         result = (c);
 178     }
 179     return result;
 180 }
 181
 182 static int
 183 menu_getc(MENU * m)
 184 {
 185     return wGetchar(menu_win(m));
 186 }
 187
 188 static int
 189 menu_offset(MenuNo number)
 190 {
 191     int result = 0;
 192
 193     if (okMenuNo(number)) {
 194         int spc_desc, spc_rows, spc_cols;
 195
 196 #ifdef NCURSES_VERSION
 197         menu_spacing(mpBanner, &spc_desc, &spc_rows, &spc_cols);
 198 #else
 199         spc_rows = 0;
 200 #endif
 201
 202         /* FIXME: MENU.itemlen seems the only way to get actual width of items */
 203         result = (number - (eBanner + 1)) * (mpBanner->itemlen + spc_rows);
 204     }
 205     return result;
 206 }
 207
 208 static MENU *
 209 menu_create(ITEM ** items, int count, int ncols, MenuNo number)
 210 {
 211     MENU *result;
 212     WINDOW *menuwin;
 213     int mrows, mcols;
 214     int y = okMenuNo(number) ? MENU_Y : 0;
 215     int x = menu_offset(number);
 216     int margin = (y == MENU_Y) ? 1 : 0;
 217     int maxcol = (ncols + x) < COLS ? ncols : (COLS - x - 1);
 218     int maxrow = (count + 1) / ncols;
 219
 220     if ((maxrow + y) >= (LINES - 4))
 221         maxrow = LINES - 4 - y;
 222
 223     result = new_menu(items);
 224
 225     if (has_colors()) {
 226         set_menu_fore(result, COLOR_PAIR(1));
 227         set_menu_back(result, COLOR_PAIR(2));
 228     }
 229
 230     set_menu_format(result, maxrow, maxcol);
 231     scale_menu(result, &mrows, &mcols);
 232
 233     if (mcols + (2 * margin + x) >= COLS)
 234         mcols = COLS - (2 * margin + x);
 235
 236 #ifdef TRACE
 237     if (number == eTrace)
 238         menu_opts_off(result, O_ONEVALUE);
 239     else
 240         menu_opts_on(result, O_ONEVALUE);
 241 #endif
 242
 243     menuwin = newwin(mrows + (2 * margin), mcols + (2 * margin), y, x);
 244     set_menu_win(result, menuwin);
 245     keypad(menuwin, TRUE);
 246     if (margin)
 247         box(menuwin, 0, 0);
 248
 249     set_menu_sub(result, derwin(menuwin, mrows, mcols, margin, margin));
 250
 251     post_menu(result);
 252
 253     return result;
 254 }
 255
 256 static void
 257 menu_destroy(MENU * m)
 258 {
 259     int count;
 260
 261     Trace(("menu_destroy %p", m));
 262     if (m != 0) {
 263         ITEM **items = menu_items(m);
 264         const char *blob = 0;
 265
 266         count = item_count(m);
 267         Trace(("menu_destroy %p count %d", m, count));
 268         if ((count > 0) && (m == mpSelect)) {
 269             blob = item_name(*items);
 270         }
 271
 272         unpost_menu(m);
 273         free_menu(m);
 274
 275         /* free the extra data allocated in build_select_menu() */
 276         if ((count > 0) && (m == mpSelect)) {
 277             if (blob) {
 278                 Trace(("freeing blob %p", blob));
 279                 free((char *) blob);
 280             }
 281             free(items);
 282         }
 283 #ifdef TRACE
 284         if ((count > 0) && (m == mpTrace)) {
 285             ITEM **ip = items;
 286             while (*ip)
 287                 free(*ip++);
 288         }
 289 #endif
 290     }
 291 }
 292
 293 /* force the given menu to appear */
 294 static void
 295 menu_display(MENU * m)
 296 {
 297     touchwin(menu_win(m));
 298     wrefresh(menu_win(m));
 299 }
 300
 301 /*****************************************************************************/
 302
 303 static void
 304 build_file_menu(MenuNo number)
 305 {
 306     static CONST_MENUS char *labels[] =
 307     {
 308         "Exit",
 309         (char *) 0
 310     };
 311     static ITEM *items[SIZEOF(labels)];
 312
 313     ITEM **ip = items;
 314     CONST_MENUS char **ap;
 315
 316     for (ap = labels; *ap; ap++)
 317         *ip++ = new_item(*ap, "");
 318     *ip = (ITEM *) 0;
 319
 320     mpFile = menu_create(items, SIZEOF(labels) - 1, 1, number);
 321 }
 322
 323 static int
 324 perform_file_menu(int cmd)
 325 {
 326     return menu_driver(mpFile, cmd);
 327 }
 328
 329 /*****************************************************************************/
 330
 331 static void
 332 build_select_menu(MenuNo number, char *filename)
 333 {
 334     static CONST_MENUS char *labels[] =
 335     {
 336         "Lions",
 337         "Tigers",
 338         "Bears",
 339         "(Oh my!)",
 340         "Newts",
 341         "Platypi",
 342         "Lemurs",
 343         "(Oh really?!)",
 344         "Leopards",
 345         "Panthers",
 346         "Pumas",
 347         "Lions, Tigers, Bears, (Oh my!), Newts, Platypi, Lemurs",
 348         "Lions, Tigers, Bears, (Oh my!), Newts, Platypi, Lemurs, Lions, Tigers, Bears, (Oh my!), Newts, Platypi, Lemurs",
 349         (char *) 0
 350     };
 351     static ITEM **items;
 352
 353     ITEM **ip;
 354     CONST_MENUS char **ap = 0;
 355     CONST_MENUS char **myList = 0;
 356     unsigned count = 0;
 357
 358     if (filename != 0) {
 359         struct stat sb;
 360         if (stat(filename, &sb) == 0
 361             && (sb.st_mode & S_IFMT) == S_IFREG
 362             && sb.st_size != 0) {
 363             size_t size = (size_t) sb.st_size;
 364             unsigned j, k;
 365             char *blob = typeMalloc(char, size + 1);
 366             CONST_MENUS char **list = typeCalloc(CONST_MENUS char *, size + 1);
 367
 368             items = typeCalloc(ITEM *, size + 1);
 369             Trace(("build_select_menu blob=%p, items=%p", blob, items));
 370             if (blob != 0 && list != 0) {
 371                 FILE *fp = fopen(filename, "r");
 372                 if (fp != 0) {
 373                     if (fread(blob, sizeof(char), size, fp) == size) {
 374                         bool mark = TRUE;
 375                         for (j = k = 0; j < size; ++j) {
 376                             if (mark) {
 377                                 list[k++] = blob + j;
 378                                 mark = FALSE;
 379                             }
 380                             if (blob[j] == '\n') {
 381                                 blob[j] = '\0';
 382                                 if (k > 0 && *list[k - 1] == '\0')
 383                                     --k;
 384                                 mark = TRUE;
 385                             } else if (blob[j] == '\t') {
 386                                 blob[j] = ' ';  /* menu items are printable */
 387                             }
 388                         }
 389                         list[k] = 0;
 390                         count = k;
 391                         ap = myList = list;
 392                     }
 393                     fclose(fp);
 394                 }
 395             }
 396         }
 397     }
 398     if (ap == 0) {
 399         count = SIZEOF(labels) - 1;
 400         items = typeCalloc(ITEM *, count + 1);
 401         ap = labels;
 402     }
 403
 404     ip = items;
 405     while (*ap != 0)
 406         *ip++ = new_item(*ap++, "");
 407     *ip = 0;
 408
 409     mpSelect = menu_create(items, (int) count, 1, number);
 410     if (myList != 0)
 411         free(myList);
 412 }
 413
 414 static int
 415 perform_select_menu(int cmd)
 416 {
 417     return menu_driver(mpSelect, cmd);
 418 }
 419
 420 /*****************************************************************************/
 421
 422 #ifdef TRACE
 423 #define T_TBL(name) { #name, name }
 424 static struct {
 425     const char *name;
 426     unsigned mask;
 427 } t_tbl[] = {
 428
 429     T_TBL(TRACE_DISABLE),
 430         T_TBL(TRACE_TIMES),
 431         T_TBL(TRACE_TPUTS),
 432         T_TBL(TRACE_UPDATE),
 433         T_TBL(TRACE_MOVE),
 434         T_TBL(TRACE_CHARPUT),
 435         T_TBL(TRACE_ORDINARY),
 436         T_TBL(TRACE_CALLS),
 437         T_TBL(TRACE_VIRTPUT),
 438         T_TBL(TRACE_IEVENT),
 439         T_TBL(TRACE_BITS),
 440         T_TBL(TRACE_ICALLS),
 441         T_TBL(TRACE_CCALLS),
 442         T_TBL(TRACE_DATABASE),
 443         T_TBL(TRACE_ATTRS),
 444         T_TBL(TRACE_MAXIMUM),
 445     {
 446         (char *) 0, 0
 447     }
 448 };
 449
 450 static void
 451 build_trace_menu(MenuNo number)
 452 {
 453     static ITEM *items[SIZEOF(t_tbl)];
 454
 455     ITEM **ip = items;
 456     int n;
 457
 458     for (n = 0; t_tbl[n].name != 0; n++)
 459         *ip++ = new_item(t_tbl[n].name, "");
 460     *ip = (ITEM *) 0;
 461
 462     mpTrace = menu_create(items, SIZEOF(t_tbl) - 1, 2, number);
 463 }
 464
 465 static char *
 466 tracetrace(unsigned tlevel)
 467 {
 468     static char *buf;
 469     int n;
 470
 471     if (buf == 0) {
 472         size_t need = 12;
 473         for (n = 0; t_tbl[n].name != 0; n++)
 474             need += strlen(t_tbl[n].name) + 2;
 475         buf = typeMalloc(char, need);
 476     }
 477     sprintf(buf, "0x%02x = {", tlevel);
 478     if (tlevel == 0) {
 479         sprintf(buf + strlen(buf), "%s, ", t_tbl[0].name);
 480     } else {
 481         for (n = 1; t_tbl[n].name != 0; n++)
 482             if ((tlevel & t_tbl[n].mask) == t_tbl[n].mask) {
 483                 strcat(buf, t_tbl[n].name);
 484                 strcat(buf, ", ");
 485             }
 486     }
 487     if (buf[strlen(buf) - 2] == ',')
 488         buf[strlen(buf) - 2] = '\0';
 489     return (strcat(buf, "}"));
 490 }
 491
 492 /* fake a dynamically reconfigurable menu using the 0th entry to deselect
 493  * the others
 494  */
 495 static bool
 496 update_trace_menu(MENU * m)
 497 {
 498     ITEM **items;
 499     ITEM *i, **p;
 500     bool changed = FALSE;
 501
 502     items = menu_items(m);
 503     i = current_item(m);
 504     if (i == items[0]) {
 505         if (item_value(i)) {
 506             for (p = items + 1; *p != 0; p++)
 507                 if (item_value(*p)) {
 508                     set_item_value(*p, FALSE);
 509                     changed = TRUE;
 510                 }
 511         }
 512     }
 513     return changed;
 514 }
 515
 516 static int
 517 perform_trace_menu(int cmd)
 518 /* interactively set the trace level */
 519 {
 520     ITEM **ip;
 521     unsigned newtrace;
 522     int result;
 523
 524     for (ip = menu_items(mpTrace); *ip; ip++) {
 525         unsigned mask = t_tbl[item_index(*ip)].mask;
 526         if (mask == 0)
 527             set_item_value(*ip, _nc_tracing == 0);
 528         else if ((mask & _nc_tracing) == mask)
 529             set_item_value(*ip, TRUE);
 530     }
 531
 532     result = menu_driver(mpTrace, cmd);
 533
 534     if (result == E_OK) {
 535         if (update_trace_menu(mpTrace) || cmd == REQ_TOGGLE_ITEM) {
 536             newtrace = 0;
 537             for (ip = menu_items(mpTrace); *ip; ip++) {
 538                 if (item_value(*ip))
 539                     newtrace |= t_tbl[item_index(*ip)].mask;
 540             }
 541             trace(newtrace);
 542             Trace(("trace level interactively set to %s", tracetrace(_nc_tracing)));
 543
 544             (void) mvprintw(LINES - 2, 0,
 545                             "Trace level is %s\n", tracetrace(_nc_tracing));
 546             refresh();
 547         }
 548     }
 549     return result;
 550 }
 551 #endif /* TRACE */
 552
 553 /*****************************************************************************/
 554
 555 static int
 556 menu_number(void)
 557 {
 558     return item_index(current_item(mpBanner)) - (eBanner + 1);
 559 }
 560
 561 static MENU *
 562 current_menu(void)
 563 {
 564     MENU *result;
 565
 566     switch (menu_number()) {
 567     case eFile:
 568         result = mpFile;
 569         break;
 570     case eSelect:
 571         result = mpSelect;
 572         break;
 573 #ifdef TRACE
 574     case eTrace:
 575         result = mpTrace;
 576         break;
 577 #endif
 578     default:
 579         result = 0;
 580         break;
 581     }
 582     return result;
 583 }
 584
 585 static void
 586 build_menus(char *filename)
 587 {
 588     static CONST_MENUS char *labels[] =
 589     {
 590         "File",
 591         "Select",
 592 #ifdef TRACE
 593         "Trace",
 594 #endif
 595         (char *) 0
 596     };
 597     static ITEM *items[SIZEOF(labels)];
 598
 599     ITEM **ip = items;
 600     CONST_MENUS char **ap;
 601
 602     for (ap = labels; *ap; ap++)
 603         *ip++ = new_item(*ap, "");
 604     *ip = (ITEM *) 0;
 605
 606     mpBanner = menu_create(items, SIZEOF(labels) - 1, SIZEOF(labels) - 1, eBanner);
 607     set_menu_mark(mpBanner, ">");
 608
 609     build_file_menu(eFile);
 610     build_select_menu(eSelect, filename);
 611 #ifdef TRACE
 612     build_trace_menu(eTrace);
 613 #endif
 614 }
 615
 616 static int
 617 move_menu(MENU * menu, MENU * current, int by_y, int by_x)
 618 {
 619     WINDOW *top_win = menu_win(menu);
 620     WINDOW *sub_win = menu_sub(menu);
 621     int y0, x0;
 622     int y1, x1;
 623     int result;
 624
 625     getbegyx(top_win, y0, x0);
 626     y0 += by_y;
 627     x0 += by_x;
 628
 629     getbegyx(sub_win, y1, x1);
 630     y1 += by_y;
 631     x1 += by_x;
 632
 633     if ((result = mvwin(top_win, y0, x0)) != ERR) {
 634 #if defined(NCURSES_VERSION_PATCH) && (NCURSES_VERSION_PATCH < 20060218)
 635         sub_win->_begy = y1;
 636         sub_win->_begx = x1;
 637 #else
 638         mvwin(sub_win, y1, x1);
 639 #endif
 640         if (menu == current) {
 641             touchwin(top_win);
 642             wnoutrefresh(top_win);
 643         }
 644     }
 645     return result;
 646 }
 647
 648 /*
 649  * Move the menus around on the screen, to test mvwin().
 650  */
 651 static void
 652 move_menus(MENU * current, int by_y, int by_x)
 653 {
 654     if (move_menu(mpBanner, current, by_y, by_x) != ERR) {
 655         erase();
 656         wnoutrefresh(stdscr);
 657         move_menu(mpFile, current, by_y, by_x);
 658         move_menu(mpSelect, current, by_y, by_x);
 659 #ifdef TRACE
 660         move_menu(mpTrace, current, by_y, by_x);
 661 #endif
 662         doupdate();
 663     }
 664 }
 665
 666 static void
 667 show_status(int ch, MENU * menu)
 668 {
 669     move(LINES - 1, 0);
 670     printw("key %s, menu %d, mark %s, match %s",
 671            keyname(ch),
 672            menu_number(),
 673            menu_mark(menu),
 674            menu_pattern(menu));
 675     clrtoeol();
 676     refresh();
 677 }
 678
 679 static void
 680 perform_menus(void)
 681 {
 682     MENU *this_menu;
 683     MENU *last_menu = mpFile;
 684     int code = E_UNKNOWN_COMMAND;
 685     int cmd;
 686     int ch = ERR;
 687
 688 #ifdef NCURSES_MOUSE_VERSION
 689     mousemask(ALL_MOUSE_EVENTS, (mmask_t *) 0);
 690 #endif
 691
 692     menu_display(last_menu);
 693
 694     for (;;) {
 695
 696         if (ch != ERR)
 697             show_status(ch, last_menu);
 698
 699         ch = menu_getc(mpBanner);
 700
 701         /*
 702          * Provide for moving the menu around in the screen using shifted
 703          * cursor keys.
 704          */
 705         switch (ch) {
 706         case KEY_SF:
 707             move_menus(last_menu, 1, 0);
 708             continue;
 709         case KEY_SR:
 710             move_menus(last_menu, -1, 0);
 711             continue;
 712         case KEY_SLEFT:
 713             move_menus(last_menu, 0, -1);
 714             continue;
 715         case KEY_SRIGHT:
 716             move_menus(last_menu, 0, 1);
 717             continue;
 718         }
 719         cmd = menu_virtualize(ch);
 720
 721         switch (cmd) {
 722             /*
 723              * The banner menu acts solely to select one of the other menus.
 724              * Move between its items, wrapping at the left/right limits.
 725              */
 726         case REQ_LEFT_ITEM:
 727         case REQ_RIGHT_ITEM:
 728             code = menu_driver(mpBanner, cmd);
 729             if (code == E_REQUEST_DENIED) {
 730                 if (menu_number() > 0)
 731                     code = menu_driver(mpBanner, REQ_FIRST_ITEM);
 732                 else
 733                     code = menu_driver(mpBanner, REQ_LAST_ITEM);
 734             }
 735             break;
 736         default:
 737             switch (menu_number()) {
 738             case eFile:
 739                 code = perform_file_menu(cmd);
 740                 break;
 741             case eSelect:
 742                 code = perform_select_menu(cmd);
 743                 break;
 744 #ifdef TRACE
 745             case eTrace:
 746                 code = perform_trace_menu(cmd);
 747                 break;
 748 #endif
 749             }
 750
 751             if ((code == E_REQUEST_DENIED) && (cmd == KEY_MOUSE)) {
 752                 code = menu_driver(mpBanner, cmd);
 753             }
 754
 755             break;
 756         }
 757
 758         if (code == E_OK) {
 759             this_menu = current_menu();
 760             if (this_menu != last_menu) {
 761                 move(1, 0);
 762                 clrtobot();
 763                 box(menu_win(this_menu), 0, 0);
 764                 refresh();
 765
 766                 /* force the current menu to appear */
 767                 menu_display(this_menu);
 768
 769                 last_menu = this_menu;
 770             }
 771         }
 772         wrefresh(menu_win(last_menu));
 773         if (code == E_UNKNOWN_COMMAND
 774             || code == E_NOT_POSTED) {
 775             if (menu_number() == eFile)
 776                 break;
 777             beep();
 778         }
 779         if (code == E_REQUEST_DENIED)
 780             beep();
 781         continue;
 782     }
 783
 784 #ifdef NCURSES_MOUSE_VERSION
 785     mousemask(0, (mmask_t *) 0);
 786 #endif
 787 }
 788
 789 static void
 790 destroy_menus(void)
 791 {
 792     menu_destroy(mpFile);
 793     menu_destroy(mpSelect);
 794 #ifdef TRACE
 795     menu_destroy(mpTrace);
 796 #endif
 797     menu_destroy(mpBanner);
 798 }
 799
 800 #if HAVE_RIPOFFLINE
 801 static int
 802 rip_footer(WINDOW *win, int cols)
 803 {
 804     wbkgd(win, A_REVERSE);
 805     werase(win);
 806     wmove(win, 0, 0);
 807     wprintw(win, "footer: %d columns", cols);
 808     wnoutrefresh(win);
 809     return OK;
 810 }
 811
 812 static int
 813 rip_header(WINDOW *win, int cols)
 814 {
 815     wbkgd(win, A_REVERSE);
 816     werase(win);
 817     wmove(win, 0, 0);
 818     wprintw(win, "header: %d columns", cols);
 819     wnoutrefresh(win);
 820     return OK;
 821 }
 822 #endif /* HAVE_RIPOFFLINE */
 823
 824 static void
 825 usage(void)
 826 {
 827     static const char *const tbl[] =
 828     {
 829         "Usage: demo_menus [options]"
 830         ,""
 831         ,"Options:"
 832 #if HAVE_RIPOFFLINE
 833         ,"  -f       rip-off footer line (can repeat)"
 834         ,"  -h       rip-off header line (can repeat)"
 835 #endif
 836 #ifdef TRACE
 837         ,"  -t mask  specify default trace-level (may toggle with ^T)"
 838 #endif
 839     };
 840     size_t n;
 841     for (n = 0; n < SIZEOF(tbl); n++)
 842         fprintf(stderr, "%s\n", tbl[n]);
 843     ExitProgram(EXIT_FAILURE);
 844 }
 845
 846 int
 847 main(int argc, char *argv[])
 848 {
 849     int c;
 850
 851     setlocale(LC_ALL, "");
 852
 853     while ((c = getopt(argc, argv, "a:de:fhmp:s:t:")) != -1) {
 854         switch (c) {
 855 #if HAVE_RIPOFFLINE
 856         case 'f':
 857             ripoffline(-1, rip_footer);
 858             break;
 859         case 'h':
 860             ripoffline(1, rip_header);
 861             break;
 862 #endif /* HAVE_RIPOFFLINE */
 863 #ifdef TRACE
 864         case 't':
 865             trace(strtoul(optarg, 0, 0));
 866             break;
 867 #endif
 868         default:
 869             usage();
 870         }
 871     }
 872
 873     initscr();
 874     noraw();
 875     cbreak();
 876     noecho();
 877
 878     if (has_colors()) {
 879         start_color();
 880         init_pair(1, COLOR_RED, COLOR_BLACK);
 881         init_pair(2, COLOR_BLUE, COLOR_WHITE);
 882     }
 883     build_menus(argc > 1 ? argv[1] : 0);
 884     perform_menus();
 885     destroy_menus();
 886
 887     endwin();
 888     ExitProgram(EXIT_SUCCESS);
 889 }
 890 #else
 891 int
 892 main(void)
 893 {
 894     printf("This program requires the curses menu library\n");
 895     ExitProgram(EXIT_FAILURE);
 896 }
 897 #endif