test/demo_menus.c

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