test/demo_menus.c

   1 /****************************************************************************
   2  * Copyright (c) 2005-2017,2019 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.69 2019/08/24 21:41:50 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_visible                    -
  42 menu_back                       -
  43 menu_fore                       -
  44 menu_format                     -
  45 menu_grey                       -
  46 menu_init                       -
  47 menu_opts                       -
  48 menu_pad                        -
  49 menu_request_by_name            -
  50 menu_request_name               -
  51 menu_term                       -
  52 menu_userptr                    -
  53 set_current_item                -
  54 set_item_opts                   -
  55 set_menu_grey                   -
  56 set_menu_items                  -
  57 set_menu_opts                   -
  58 set_menu_pad                    -
  59 set_menu_pattern                -
  60 set_menu_spacing                -
  61 set_menu_userptr                -
  62 set_top_row                     -
  63 top_row                         -
  64 */
  65
  66 #include <test.priv.h>
  67
  68 #if USE_LIBMENU
  69
  70 #include <menu.h>
  71
  72 #include <sys/types.h>
  73 #include <sys/stat.h>
  74
  75 #ifdef NCURSES_VERSION
  76 #ifdef TRACE
  77 static unsigned save_trace = TRACE_ORDINARY | TRACE_CALLS;
  78 static MENU *mpTrace;
  79 #endif
  80 #endif
  81
  82 typedef enum {
  83     eBanner = -1
  84     ,eFile
  85     ,eSelect
  86 #ifdef TRACE
  87     ,eTrace
  88 #endif
  89     ,eMAX
  90 } MenuNo;
  91
  92 #define okMenuNo(n) (((n) > eBanner) && ((n) < eMAX))
  93
  94 #define MENU_Y  1
  95
  96 typedef struct {
  97     NCURSES_CONST char *name;
  98     void (*func) (int);
  99     unsigned mask;
 100 } MENU_DATA;
 101
 102 static void call_files(int);
 103
 104 static MENU *mpBanner;
 105 static MENU *mpFile;
 106 static MENU *mpSelect;
 107
 108 static WINDOW *status;
 109
 110 static bool loaded_file = FALSE;
 111
 112 static char empty[1];
 113
 114 #ifdef TRACE
 115 static void failed(const char *s) GCC_NORETURN;
 116
 117 static void
 118 failed(const char *s)
 119 {
 120     perror(s);
 121     endwin();
 122     ExitProgram(EXIT_FAILURE);
 123 }
 124 #endif
 125
 126 /* Common function to allow ^T to toggle trace-mode in the middle of a test
 127  * so that trace-files can be made smaller.
 128  */
 129 static int
 130 wGetchar(WINDOW *win)
 131 {
 132     int c;
 133 #ifdef TRACE
 134     while ((c = wgetch(win)) == CTRL('T')) {
 135         if (_nc_tracing) {
 136             save_trace = _nc_tracing;
 137             Trace(("TOGGLE-TRACING OFF"));
 138             _nc_tracing = 0;
 139         } else {
 140             _nc_tracing = save_trace;
 141         }
 142         trace(_nc_tracing);
 143         if (_nc_tracing)
 144             Trace(("TOGGLE-TRACING ON"));
 145     }
 146 #else
 147     c = wgetch(win);
 148 #endif
 149     return c;
 150 }
 151 #define Getchar() wGetchar(stdscr)
 152
 153 static int
 154 menu_virtualize(int c)
 155 {
 156     int result;
 157
 158     if (c == '\n' || c == KEY_EXIT)
 159         result = (MAX_COMMAND + 1);
 160     else if (c == 'u')
 161         result = (REQ_SCR_ULINE);
 162     else if (c == 'd')
 163         result = (REQ_SCR_DLINE);
 164     else if (c == 'b' || c == KEY_NPAGE)
 165         result = (REQ_SCR_UPAGE);
 166     else if (c == 'f' || c == KEY_PPAGE)
 167         result = (REQ_SCR_DPAGE);
 168     else if (c == 'l' || c == KEY_LEFT || c == KEY_BTAB)
 169         result = (REQ_LEFT_ITEM);
 170     else if (c == 'n' || c == KEY_DOWN)
 171         result = (REQ_NEXT_ITEM);
 172     else if (c == 'p' || c == KEY_UP)
 173         result = (REQ_PREV_ITEM);
 174     else if (c == 'r' || c == KEY_RIGHT || c == '\t')
 175         result = (REQ_RIGHT_ITEM);
 176     else if (c == ' ')
 177         result = (REQ_TOGGLE_ITEM);
 178     else {
 179         if (c != KEY_MOUSE)
 180             beep();
 181         result = (c);
 182     }
 183     return result;
 184 }
 185
 186 static int
 187 menu_getc(MENU * m)
 188 {
 189     return wGetchar(menu_win(m));
 190 }
 191
 192 static int
 193 menu_offset(MenuNo number)
 194 {
 195     int result = 0;
 196
 197     if (okMenuNo(number)) {
 198         int spc_rows;
 199 #ifdef NCURSES_VERSION
 200         int spc_desc, spc_cols;
 201         menu_spacing(mpBanner, &spc_desc, &spc_rows, &spc_cols);
 202 #else
 203         spc_rows = 0;
 204 #endif
 205
 206         /* FIXME: MENU.itemlen seems the only way to get actual width of items */
 207         result = (number - (eBanner + 1)) * (menu_itemwidth(mpBanner) + spc_rows);
 208     }
 209     return result;
 210 }
 211
 212 static void
 213 my_menu_init(MENU * menu)
 214 {
 215     Trace(("called MenuHook my_menu_init"));
 216     mvwprintw(status, 2, 0, "menu_init %p", (void *) menu);
 217     wclrtoeol(status);
 218     wrefresh(status);
 219 }
 220
 221 static void
 222 my_menu_term(MENU * menu)
 223 {
 224     Trace(("called MenuHook my_menu_term"));
 225     mvwprintw(status, 2, 0, "menu_term %p", (void *) menu);
 226     wclrtoeol(status);
 227     wrefresh(status);
 228 }
 229
 230 static void
 231 my_item_init(MENU * menu)
 232 {
 233     ITEM *item = current_item(menu);
 234     const char *name = item_name(item);
 235
 236     Trace(("called MenuHook my_item_init (%s)", name));
 237     mvwprintw(status, 2, 0, "item_init %s", name);
 238     wclrtoeol(status);
 239     wrefresh(status);
 240 }
 241
 242 static void
 243 my_item_term(MENU * menu)
 244 {
 245     ITEM *item = current_item(menu);
 246     const char *name = item_name(item);
 247
 248     Trace(("called MenuHook my_item_term (%s)", name));
 249     mvwprintw(status, 2, 0, "item_term %s", name);
 250     wclrtoeol(status);
 251     wrefresh(status);
 252 }
 253
 254 static MENU *
 255 menu_create(ITEM ** items, int count, int ncols, MenuNo number)
 256 {
 257     MENU *result;
 258     WINDOW *menuwin;
 259     int mrows, mcols;
 260     int y = okMenuNo(number) ? MENU_Y : 0;
 261     int x = menu_offset(number);
 262     int margin = (y == MENU_Y) ? 1 : 0;
 263     int maxcol = (ncols + x) < COLS ? ncols : (COLS - x - 1);
 264     int maxrow = (count + 1) / ncols;
 265
 266     if ((maxrow + y) >= (LINES - 4))
 267         maxrow = LINES - 4 - y;
 268
 269     result = new_menu(items);
 270
 271     if (has_colors()) {
 272         set_menu_fore(result, (chtype) COLOR_PAIR(1));
 273         set_menu_back(result, (chtype) COLOR_PAIR(2));
 274     }
 275
 276     set_menu_format(result, maxrow, maxcol);
 277     scale_menu(result, &mrows, &mcols);
 278
 279     if (mcols + (2 * margin + x) >= COLS)
 280         mcols = COLS - (2 * margin + x);
 281
 282     menuwin = newwin(mrows + (2 * margin), mcols + (2 * margin), y, x);
 283     set_menu_win(result, menuwin);
 284     keypad(menuwin, TRUE);
 285     if (margin)
 286         box(menuwin, 0, 0);
 287
 288     set_menu_sub(result, derwin(menuwin, mrows, mcols, margin, margin));
 289
 290 #ifdef TRACE
 291     if (number == eTrace)
 292         menu_opts_off(result, O_ONEVALUE);
 293     else
 294         menu_opts_on(result, O_ONEVALUE);
 295 #endif
 296 #if defined(NCURSES_MOUSE_VERSION) && defined(O_MOUSE_MENU)
 297     menu_opts_on(result, O_MOUSE_MENU);
 298 #endif
 299
 300     post_menu(result);
 301
 302     set_menu_init(result, my_menu_init);
 303     set_menu_term(result, my_menu_term);
 304     set_item_init(result, my_item_init);
 305     set_item_term(result, my_item_term);
 306     return result;
 307 }
 308
 309 static void
 310 menu_destroy(MENU * m)
 311 {
 312     Trace(("menu_destroy %p", (void *) m));
 313     if (m != 0) {
 314         ITEM **items = menu_items(m);
 315         const char *blob = 0;
 316         int count;
 317
 318         count = item_count(m);
 319         Trace(("menu_destroy %p count %d", (void *) m, count));
 320         if ((count > 0) && (m == mpSelect)) {
 321             blob = item_name(*items);
 322         }
 323
 324         unpost_menu(m);
 325         free_menu(m);
 326
 327         /* free the extra data allocated in build_select_menu() */
 328         if ((count > 0) && (m == mpSelect)) {
 329             if (blob && loaded_file) {
 330                 Trace(("freeing blob %p", blob));
 331                 free((void *) blob);
 332             }
 333             free(items);
 334             items = 0;
 335         }
 336 #ifdef TRACE
 337         if ((count > 0) && (m == mpTrace)) {
 338             ITEM **ip = items;
 339             if (ip != 0) {
 340                 while (*ip)
 341                     free(*ip++);
 342             }
 343         }
 344 #endif
 345     }
 346 }
 347
 348 /* force the given menu to appear */
 349 static void
 350 menu_display(MENU * m)
 351 {
 352     touchwin(menu_win(m));
 353     wrefresh(menu_win(m));
 354 }
 355
 356 /*****************************************************************************/
 357
 358 static void
 359 build_file_menu(MenuNo number)
 360 {
 361     static MENU_DATA table[] =
 362     {
 363         {"Exit", call_files, 0},
 364         {(char *) 0, 0, 0}
 365     };
 366     static ITEM *items[SIZEOF(table)];
 367
 368     ITEM **ip = items;
 369     int n;
 370
 371     for (n = 0; table[n].name != 0; ++n) {
 372         *ip = new_item(table[n].name, empty);
 373         set_item_userptr(*ip, (void *) &table[n]);
 374         ++ip;
 375     }
 376     *ip = (ITEM *) 0;
 377
 378     mpFile = menu_create(items, SIZEOF(table) - 1, 1, number);
 379 }
 380
 381 static int
 382 perform_file_menu(int cmd)
 383 {
 384     return menu_driver(mpFile, cmd);
 385 }
 386
 387 /*****************************************************************************/
 388
 389 static void
 390 call_select(int code)
 391 {
 392     (void) code;
 393     Trace(("Selected item %d", code));
 394 }
 395
 396 static void
 397 build_select_menu(MenuNo number, char *filename)
 398 {
 399 #define MY_DATA(name) { name, call_select, 0 }
 400     static MENU_DATA table[] =
 401     {
 402         MY_DATA("Lions"),
 403         MY_DATA("Tigers"),
 404         MY_DATA("Bears"),
 405         MY_DATA("(Oh my!)"),
 406         MY_DATA("Newts"),
 407         MY_DATA("Platypi"),
 408         MY_DATA("Lemurs"),
 409         MY_DATA("(Oh really?!)"),
 410         MY_DATA("Leopards"),
 411         MY_DATA("Panthers"),
 412         MY_DATA("Pumas"),
 413         MY_DATA("Lions, Tigers, Bears, (Oh my!), Newts, Platypi, Lemurs"),
 414         MY_DATA("Lions, Tigers, Bears, (Oh my!), Newts, Platypi, Lemurs, Lions, Tigers, Bears, (Oh my!), Newts, Platypi, Lemurs"),
 415         {(char *) 0, 0, 0}
 416     };
 417     static ITEM **items;
 418
 419     ITEM **ip;
 420     MENU_DATA *ap = 0;
 421     MENU_DATA *myList = 0;
 422     int i;
 423     size_t count = 0;
 424
 425     if (filename != 0) {
 426         struct stat sb;
 427         if (stat(filename, &sb) == 0
 428             && (sb.st_mode & S_IFMT) == S_IFREG
 429             && sb.st_size != 0) {
 430             size_t size = (size_t) sb.st_size;
 431             char *blob = typeMalloc(char, size + 1);
 432             MENU_DATA *list = typeCalloc(MENU_DATA, size + 1);
 433
 434             items = typeCalloc(ITEM *, size + 1);
 435             Trace(("build_select_menu blob=%p, items=%p",
 436                    (void *) blob,
 437                    (void *) items));
 438             if (blob != 0 && list != 0) {
 439                 FILE *fp = fopen(filename, "r");
 440                 if (fp != 0) {
 441                     if (fread(blob, sizeof(char), size, fp) == size) {
 442                         bool mark = TRUE;
 443                         unsigned j, k;
 444                         for (j = k = 0; j < size; ++j) {
 445                             if (mark) {
 446                                 list[k++].name = blob + j;
 447                                 mark = FALSE;
 448                             }
 449                             if (blob[j] == '\n') {
 450                                 blob[j] = '\0';
 451                                 if (k > 0 && *list[k - 1].name == '\0')
 452                                     --k;
 453                                 mark = TRUE;
 454                             } else if (blob[j] == '\t') {
 455                                 blob[j] = ' ';  /* menu items are printable */
 456                             }
 457                         }
 458                         list[k].name = 0;
 459                         count = k;
 460                         ap = myList = list;
 461                     }
 462                     fclose(fp);
 463                 }
 464                 loaded_file = TRUE;
 465             }
 466             if (ap == 0)
 467                 free(items);
 468         }
 469     }
 470     if (ap == 0) {
 471         count = SIZEOF(table) - 1;
 472         items = typeCalloc(ITEM *, count + 1);
 473         ap = table;
 474     }
 475
 476     ip = items;
 477     for (i = 0; ap[i].name != 0; ++i) {
 478         ap[i].func = call_select;
 479         ap[i].mask = (unsigned) i;
 480         *ip = new_item(ap[i].name, empty);
 481         set_item_userptr(*ip, (void *) &table[i]);
 482         ++ip;
 483     }
 484     *ip = 0;
 485
 486     mpSelect = menu_create(items, (int) count, 1, number);
 487     if (myList != 0)
 488         free(myList);
 489 }
 490
 491 static int
 492 perform_select_menu(int cmd)
 493 {
 494     return menu_driver(mpSelect, cmd);
 495 }
 496
 497 /*****************************************************************************/
 498
 499 #ifdef TRACE
 500
 501 static void
 502 call_trace(int code)
 503 {
 504     (void) code;
 505     Trace(("Updating trace mask %d", code));
 506 }
 507
 508 #define T_TBL(name) { #name, call_trace, name }
 509 static MENU_DATA t_tbl[] =
 510 {
 511
 512     T_TBL(TRACE_DISABLE),
 513     T_TBL(TRACE_TIMES),
 514     T_TBL(TRACE_TPUTS),
 515     T_TBL(TRACE_UPDATE),
 516     T_TBL(TRACE_MOVE),
 517     T_TBL(TRACE_CHARPUT),
 518     T_TBL(TRACE_ORDINARY),
 519     T_TBL(TRACE_CALLS),
 520     T_TBL(TRACE_VIRTPUT),
 521     T_TBL(TRACE_IEVENT),
 522     T_TBL(TRACE_BITS),
 523     T_TBL(TRACE_ICALLS),
 524     T_TBL(TRACE_CCALLS),
 525     T_TBL(TRACE_DATABASE),
 526     T_TBL(TRACE_ATTRS),
 527     T_TBL(TRACE_MAXIMUM),
 528     {
 529         (char *) 0, 0, 0
 530     }
 531 };
 532
 533 static void
 534 build_trace_menu(MenuNo number)
 535 {
 536     static ITEM *items[SIZEOF(t_tbl)];
 537
 538     ITEM **ip = items;
 539     int n;
 540
 541     for (n = 0; t_tbl[n].name != 0; n++) {
 542         *ip = new_item(t_tbl[n].name, empty);
 543         set_item_userptr(*ip, (void *) &t_tbl[n]);
 544         ++ip;
 545     }
 546     *ip = (ITEM *) 0;
 547
 548     mpTrace = menu_create(items, SIZEOF(t_tbl) - 1, 2, number);
 549 }
 550
 551 static char *
 552 tracetrace(unsigned tlevel)
 553 {
 554     static char *buf;
 555     static size_t need = 12;
 556     int n;
 557
 558     if (buf == 0) {
 559         for (n = 0; t_tbl[n].name != 0; n++)
 560             need += strlen(t_tbl[n].name) + 2;
 561         buf = typeMalloc(char, need);
 562         if (!buf)
 563             failed("tracetrace");
 564     }
 565     _nc_SPRINTF(buf, _nc_SLIMIT(need) "0x%02x = {", tlevel);
 566     if (tlevel == 0) {
 567         _nc_STRCAT(buf, t_tbl[0].name, need);
 568         _nc_STRCAT(buf, ", ", need);
 569     } else {
 570         for (n = 1; t_tbl[n].name != 0; n++)
 571             if ((tlevel & t_tbl[n].mask) == t_tbl[n].mask) {
 572                 _nc_STRCAT(buf, t_tbl[n].name, need);
 573                 _nc_STRCAT(buf, ", ", need);
 574             }
 575     }
 576     if (buf[strlen(buf) - 2] == ',')
 577         buf[strlen(buf) - 2] = '\0';
 578     _nc_STRCAT(buf, "}", need);
 579     return buf;
 580 }
 581
 582 /* fake a dynamically reconfigurable menu using the 0th entry to deselect
 583  * the others
 584  */
 585 static bool
 586 update_trace_menu(MENU * m)
 587 {
 588     ITEM **items;
 589     ITEM *i;
 590     bool changed = FALSE;
 591
 592     items = menu_items(m);
 593     i = current_item(m);
 594     if (i == items[0]) {
 595         if (item_value(i)) {
 596             ITEM **p;
 597             for (p = items + 1; *p != 0; p++)
 598                 if (item_value(*p)) {
 599                     set_item_value(*p, FALSE);
 600                     changed = TRUE;
 601                 }
 602         }
 603     }
 604     return changed;
 605 }
 606
 607 static int
 608 perform_trace_menu(int cmd)
 609 /* interactively set the trace level */
 610 {
 611     ITEM **ip;
 612     int result;
 613
 614     for (ip = menu_items(mpTrace); *ip; ip++) {
 615         MENU_DATA *td = (MENU_DATA *) item_userptr(*ip);
 616         unsigned mask = td->mask;
 617         if (mask == 0)
 618             set_item_value(*ip, _nc_tracing == 0);
 619         else if ((mask & _nc_tracing) == mask)
 620             set_item_value(*ip, TRUE);
 621     }
 622
 623     result = menu_driver(mpTrace, cmd);
 624
 625     if (result == E_OK) {
 626         if (update_trace_menu(mpTrace) || cmd == REQ_TOGGLE_ITEM) {
 627             unsigned newtrace = 0;
 628             for (ip = menu_items(mpTrace); *ip; ip++) {
 629                 if (item_value(*ip)) {
 630                     MENU_DATA *td = (MENU_DATA *) item_userptr(*ip);
 631                     newtrace |= td->mask;
 632                 }
 633             }
 634             trace(newtrace);
 635             Trace(("trace level interactively set to %s", tracetrace(_nc_tracing)));
 636
 637             MvWPrintw(status, 1, 0,
 638                       "Trace level is %s\n", tracetrace(_nc_tracing));
 639             wrefresh(status);
 640         }
 641     }
 642     return result;
 643 }
 644 #endif /* TRACE */
 645
 646 /*****************************************************************************/
 647
 648 static int
 649 menu_number(void)
 650 {
 651     return item_index(current_item(mpBanner)) - (eBanner + 1);
 652 }
 653
 654 static MENU *
 655 current_menu(void)
 656 {
 657     MENU *result;
 658
 659     switch (menu_number()) {
 660     case eFile:
 661         result = mpFile;
 662         break;
 663     case eSelect:
 664         result = mpSelect;
 665         break;
 666 #ifdef TRACE
 667     case eTrace:
 668         result = mpTrace;
 669         break;
 670 #endif
 671     default:
 672         result = 0;
 673         break;
 674     }
 675     return result;
 676 }
 677
 678 static void
 679 call_menus(int code)
 680 {
 681     (void) code;
 682     Trace(("Activated menu %d\n", code));
 683 }
 684
 685 static void
 686 build_menus(char *filename)
 687 {
 688     static MENU_DATA table[] =
 689     {
 690         {"File", call_menus, 0},
 691         {"Select", call_menus, 1},
 692 #ifdef TRACE
 693         {"Trace", call_menus, 2},
 694 #endif
 695         {(char *) 0, 0, 0}
 696     };
 697     static ITEM *items[SIZEOF(table)];
 698
 699     ITEM **ip = items;
 700     int n;
 701
 702     for (n = 0; table[n].name != 0; ++n) {
 703         *ip = new_item(table[n].name, empty);
 704         set_item_userptr(*ip, (void *) &table[n]);
 705         ++ip;
 706     }
 707     *ip = (ITEM *) 0;
 708
 709     mpBanner = menu_create(items, SIZEOF(table) - 1, SIZEOF(table) - 1, eBanner);
 710     set_menu_mark(mpBanner, ">");
 711
 712     build_file_menu(eFile);
 713     build_select_menu(eSelect, filename);
 714 #ifdef TRACE
 715     build_trace_menu(eTrace);
 716 #endif
 717 }
 718
 719 static int
 720 move_menu(MENU * menu, MENU * current, int by_y, int by_x)
 721 {
 722     WINDOW *top_win = menu_win(menu);
 723     WINDOW *sub_win = menu_sub(menu);
 724     int y0, x0;
 725     int y1, x1;
 726     int result;
 727
 728     getbegyx(top_win, y0, x0);
 729     y0 += by_y;
 730     x0 += by_x;
 731
 732     getbegyx(sub_win, y1, x1);
 733     y1 += by_y;
 734     x1 += by_x;
 735
 736     if ((result = mvwin(top_win, y0, x0)) != ERR) {
 737 #if defined(NCURSES_VERSION_PATCH) && (NCURSES_VERSION_PATCH < 20060218)
 738         sub_win->_begy = y1;
 739         sub_win->_begx = x1;
 740 #else
 741         mvwin(sub_win, y1, x1);
 742 #endif
 743         if (menu == current) {
 744             touchwin(top_win);
 745             wnoutrefresh(top_win);
 746         }
 747     }
 748     return result;
 749 }
 750
 751 /*
 752  * Move the menus around on the screen, to test mvwin().
 753  */
 754 static void
 755 move_menus(MENU * current, int by_y, int by_x)
 756 {
 757     if (move_menu(mpBanner, current, by_y, by_x) != ERR) {
 758         erase();
 759         wnoutrefresh(stdscr);
 760         move_menu(mpFile, current, by_y, by_x);
 761         move_menu(mpSelect, current, by_y, by_x);
 762 #ifdef TRACE
 763         move_menu(mpTrace, current, by_y, by_x);
 764 #endif
 765         doupdate();
 766     }
 767 }
 768
 769 #if defined(KEY_RESIZE) && NCURSES_EXT_FUNCS
 770 static void
 771 resize_menu(MENU ** menu)
 772 {
 773 #if 0
 774     WINDOW *win = menu_win(*menu);
 775     WINDOW *sub = menu_sub(*menu);
 776 #endif
 777     (void) menu;
 778 }
 779
 780 static void
 781 resize_menus(MENU * current)
 782 {
 783     (void) current;
 784
 785     werase(status);
 786     wnoutrefresh(status);
 787     wresize(status, 1, COLS);
 788     mvwin(status, LINES - 1, 0);
 789
 790     resize_menu(&mpBanner);
 791     resize_menu(&mpFile);
 792     resize_menu(&mpSelect);
 793 #ifdef TRACE
 794     resize_menu(&mpTrace);
 795 #endif
 796 }
 797 #endif /* defined(KEY_RESIZE) && NCURSES_EXT_FUNCS */
 798
 799 static void
 800 show_status(int ch, MENU * menu)
 801 {
 802     wmove(status, 0, 0);
 803     wprintw(status, "key %s, menu %d, mark %s, match %s",
 804             keyname(ch),
 805             menu_number(),
 806             menu_mark(menu),
 807             menu_pattern(menu));
 808     wclrtoeol(status);
 809     wrefresh(status);
 810 }
 811
 812 static void
 813 perform_menus(void)
 814 {
 815     MENU *this_menu;
 816     MENU *last_menu = mpFile;
 817     int code = E_UNKNOWN_COMMAND;
 818     int cmd;
 819     int ch = ERR;
 820
 821 #ifdef NCURSES_MOUSE_VERSION
 822     mousemask(BUTTON1_CLICKED, (mmask_t *) 0);
 823 #endif
 824
 825     menu_display(last_menu);
 826
 827     for (;;) {
 828
 829         if (ch != ERR)
 830             show_status(ch, last_menu);
 831
 832         ch = menu_getc(mpBanner);
 833
 834         /*
 835          * Provide for moving the menu around in the screen using shifted
 836          * cursor keys.
 837          */
 838         switch (ch) {
 839         case KEY_SF:
 840             move_menus(last_menu, 1, 0);
 841             continue;
 842         case KEY_SR:
 843             move_menus(last_menu, -1, 0);
 844             continue;
 845         case KEY_SLEFT:
 846             move_menus(last_menu, 0, -1);
 847             continue;
 848         case KEY_SRIGHT:
 849             move_menus(last_menu, 0, 1);
 850             continue;
 851 #if defined(KEY_RESIZE) && NCURSES_EXT_FUNCS
 852         case KEY_RESIZE:
 853             resize_menus(last_menu);
 854             continue;
 855 #endif
 856         }
 857         cmd = menu_virtualize(ch);
 858
 859         switch (cmd) {
 860             /*
 861              * The banner menu acts solely to select one of the other menus.
 862              * Move between its items, wrapping at the left/right limits.
 863              */
 864         case REQ_LEFT_ITEM:
 865         case REQ_RIGHT_ITEM:
 866             code = menu_driver(mpBanner, cmd);
 867             if (code == E_REQUEST_DENIED) {
 868                 if (menu_number() > 0)
 869                     code = menu_driver(mpBanner, REQ_FIRST_ITEM);
 870                 else
 871                     code = menu_driver(mpBanner, REQ_LAST_ITEM);
 872             }
 873             break;
 874         default:
 875             switch (menu_number()) {
 876             case eFile:
 877                 code = perform_file_menu(cmd);
 878                 break;
 879             case eSelect:
 880                 code = perform_select_menu(cmd);
 881                 break;
 882 #ifdef TRACE
 883             case eTrace:
 884                 code = perform_trace_menu(cmd);
 885                 break;
 886 #endif
 887             }
 888
 889 #if defined(NCURSES_MOUSE_VERSION) && defined(O_MOUSE_MENU)
 890             if ((code == E_REQUEST_DENIED) && (cmd == KEY_MOUSE)) {
 891                 (void) menu_getc(mpBanner);
 892                 code = menu_driver(mpBanner, cmd);
 893                 if (code == E_REQUEST_DENIED) {
 894                     MEVENT event;
 895                     if (menu_getc(mpBanner) == KEY_MOUSE)
 896                         getmouse(&event);       /* give up */
 897                 }
 898             }
 899 #endif
 900
 901             break;
 902         }
 903
 904         if (code == E_OK) {
 905             this_menu = current_menu();
 906             if (this_menu != last_menu) {
 907                 move(1, 0);
 908                 clrtobot();
 909                 box(menu_win(this_menu), 0, 0);
 910                 refresh();
 911
 912                 /* force the current menu to appear */
 913                 menu_display(this_menu);
 914
 915                 last_menu = this_menu;
 916             }
 917         }
 918         wrefresh(menu_win(last_menu));
 919         if (code == E_UNKNOWN_COMMAND
 920             || code == E_NOT_POSTED) {
 921             ITEM *item = current_item(last_menu);
 922             MENU_DATA *td = (MENU_DATA *) item_userptr(item);
 923             td->func((int) td->mask);
 924         }
 925         if (code == E_REQUEST_DENIED)
 926             beep();
 927         continue;
 928     }
 929 }
 930
 931 static void
 932 destroy_menus(void)
 933 {
 934     menu_destroy(mpFile);
 935     menu_destroy(mpSelect);
 936 #ifdef TRACE
 937     menu_destroy(mpTrace);
 938 #endif
 939     menu_destroy(mpBanner);
 940 }
 941
 942 #if HAVE_RIPOFFLINE
 943 static int
 944 rip_footer(WINDOW *win, int cols)
 945 {
 946     wbkgd(win, A_REVERSE);
 947     werase(win);
 948     wmove(win, 0, 0);
 949     wprintw(win, "footer: %d columns", cols);
 950     wnoutrefresh(win);
 951     return OK;
 952 }
 953
 954 static int
 955 rip_header(WINDOW *win, int cols)
 956 {
 957     wbkgd(win, A_REVERSE);
 958     werase(win);
 959     wmove(win, 0, 0);
 960     wprintw(win, "header: %d columns", cols);
 961     wnoutrefresh(win);
 962     return OK;
 963 }
 964 #endif /* HAVE_RIPOFFLINE */
 965
 966 static void
 967 call_files(int code)
 968 {
 969     switch (code) {
 970     case 0:
 971         destroy_menus();
 972         endwin();
 973         printf("DONE!\n");
 974         ExitProgram(EXIT_SUCCESS);
 975     }
 976 }
 977
 978 static void
 979 usage(void)
 980 {
 981     static const char *const tbl[] =
 982     {
 983         "Usage: demo_menus [options] [menu-file]"
 984         ,""
 985         ,"Options:"
 986 #if HAVE_RIPOFFLINE
 987         ,"  -f       rip-off footer line (can repeat)"
 988         ,"  -h       rip-off header line (can repeat)"
 989 #endif
 990 #ifdef TRACE
 991         ,"  -t mask  specify default trace-level (may toggle with ^T)"
 992 #endif
 993     };
 994     size_t n;
 995     for (n = 0; n < SIZEOF(tbl); n++)
 996         fprintf(stderr, "%s\n", tbl[n]);
 997     ExitProgram(EXIT_FAILURE);
 998 }
 999
1000 int
1001 main(int argc, char *argv[])
1002 {
1003     int c;
1004
1005     setlocale(LC_ALL, "");
1006
1007     while ((c = getopt(argc, argv, "fht:")) != -1) {
1008         switch (c) {
1009 #if HAVE_RIPOFFLINE
1010         case 'f':
1011             ripoffline(-1, rip_footer);
1012             break;
1013         case 'h':
1014             ripoffline(1, rip_header);
1015             break;
1016 #endif /* HAVE_RIPOFFLINE */
1017 #ifdef TRACE
1018         case 't':
1019             trace((unsigned) strtoul(optarg, 0, 0));
1020             break;
1021 #endif
1022         default:
1023             usage();
1024         }
1025     }
1026
1027     initscr();
1028     noraw();
1029     cbreak();
1030     noecho();
1031
1032     if (has_colors()) {
1033         start_color();
1034         init_pair(1, COLOR_RED, COLOR_BLACK);
1035         init_pair(2, COLOR_BLUE, COLOR_WHITE);
1036     }
1037     status = newwin(3, COLS, LINES - 3, 0);
1038     build_menus(argc > 1 ? argv[1] : 0);
1039     perform_menus();
1040     destroy_menus();
1041
1042     endwin();
1043     ExitProgram(EXIT_SUCCESS);
1044 }
1045 #else
1046 int
1047 main(void)
1048 {
1049     printf("This program requires the curses menu library\n");
1050     ExitProgram(EXIT_FAILURE);
1051 }
1052 #endif