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