ncurses 5.7 - patch 20100403
[ncurses.git] / test / demo_panels.c
1 /****************************************************************************
2  * Copyright (c) 2007-2008,2010 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_panels.c,v 1.34 2010/03/06 18:14:04 tom Exp $
30  *
31  * Demonstrate a variety of functions from the panel library.
32  */
33
34 #include <test.priv.h>
35
36 #if USE_LIBPANEL
37
38 #include <panel.h>
39
40 #define LAST_POS '@'
41 #define TEMP_POS '>'
42
43 typedef void (*InitPanel) (void);
44 typedef void (*FillPanel) (PANEL *);
45
46 static bool use_colors = FALSE;
47 static bool unboxed = FALSE;
48 static FILE *log_in;
49 static FILE *log_out;
50
51 static void
52 close_input(void)
53 {
54     if (log_in != 0) {
55         fclose(log_in);
56         log_in = 0;
57     }
58 }
59
60 static void
61 close_output(void)
62 {
63     if (log_out != 0) {
64         fclose(log_out);
65         log_out = 0;
66     }
67 }
68
69 static WINDOW *
70 statusline(void)
71 {
72     WINDOW *result = stdscr;
73
74     wmove(result, LINES - 1, 0);
75     wclrtoeol(result);
76     return result;
77 }
78
79 static void
80 pflush(void)
81 {
82     update_panels();
83     doupdate();
84 }
85
86 static void
87 saywhat(NCURSES_CONST char *text)
88 {
89     WINDOW *win = statusline();
90     if (text != 0 && *text != '\0') {
91         waddstr(win, text);
92         waddstr(win, "; ");
93     }
94     waddstr(win, "press any key to continue");
95 }
96
97 static void
98 show_position(NCURSES_CONST char *text,
99               NCURSES_CONST char *also,
100               int which,
101               int ypos,
102               int xpos)
103 {
104     WINDOW *win = statusline();
105
106     wprintw(win, "%s for panel %d now %d,%d%s", text, which, ypos, xpos, also);
107     wmove(stdscr, ypos, xpos);
108 }
109
110 static int
111 get_position(NCURSES_CONST char *text,
112              NCURSES_CONST char *also,
113              int which,
114              int *xpos,
115              int *ypos)
116 {
117     int result = 0;
118     int x1, y1;
119     char cmd;
120     WINDOW *win;
121
122     getyx(stdscr, y1, x1);
123     win = statusline();
124
125     show_position(text, also, which, y1, x1);
126
127     if (log_in != 0) {
128         if (fscanf(log_in, "%c%d,%d\n", &cmd, &y1, &x1) == 3) {
129             switch (cmd) {
130             case LAST_POS:
131                 result = 1;
132                 (void) wgetch(stdscr);
133                 break;
134             case TEMP_POS:
135                 result = 0;
136                 wrefresh(stdscr);
137                 napms(100);
138                 break;
139             default:
140                 result = -1;
141                 break;
142             }
143         } else {
144             result = -1;
145         }
146     } else {
147
148         switch (wgetch(stdscr)) {
149         case QUIT:
150         case ESCAPE:
151         case ERR:
152             result = -1;
153             break;
154         case ' ':
155             result = 1;
156             break;
157         case KEY_UP:
158             if (y1 > 0) {
159                 --y1;
160             } else {
161                 beep();
162             }
163             break;
164         case KEY_DOWN:
165             if (y1 < getmaxy(stdscr)) {
166                 ++y1;
167             } else {
168                 beep();
169             }
170             break;
171         case KEY_LEFT:
172             if (x1 > 0) {
173                 --x1;
174             } else {
175                 beep();
176             }
177             break;
178         case KEY_RIGHT:
179             if (x1 < getmaxx(stdscr)) {
180                 ++x1;
181             } else {
182                 beep();
183             }
184             break;
185         }
186     }
187
188     wmove(stdscr, y1, x1);
189     *ypos = y1;
190     *xpos = x1;
191
192     if (result >= 0) {
193         if (log_out)
194             fprintf(log_out, "%c%d,%d\n",
195                     ((result > 0)
196                      ? LAST_POS
197                      : TEMP_POS),
198                     y1, x1);
199     }
200     return result;
201 }
202
203 static PANEL *
204 mkpanel(short color, int rows, int cols, int tly, int tlx)
205 {
206     WINDOW *win;
207     PANEL *pan = 0;
208     char *userdata = typeMalloc(char, 3);
209
210     if ((win = newwin(rows, cols, tly, tlx)) != 0) {
211         keypad(win, TRUE);
212         if ((pan = new_panel(win)) == 0) {
213             delwin(win);
214         } else if (use_colors) {
215             short fg = (short) ((color == COLOR_BLUE)
216                                 ? COLOR_WHITE
217                                 : COLOR_BLACK);
218             short bg = color;
219
220             init_pair(color, fg, bg);
221             wbkgdset(win, (chtype) (COLOR_PAIR(color) | ' '));
222         } else if (!unboxed) {
223             wbkgdset(win, A_BOLD | ' ');
224         }
225     }
226     sprintf(userdata, "p%d", color % 8);
227     set_panel_userptr(pan, (NCURSES_CONST void *) userdata);
228     return pan;
229 }
230
231 static void
232 my_remove_panel(PANEL ** pans, int which)
233 {
234     if (pans[which] != 0) {
235         PANEL *pan = pans[which];
236         WINDOW *win = panel_window(pan);
237         char *user = (char *) panel_userptr(pan);
238
239         free(user);
240         del_panel(pan);
241         delwin(win);
242
243         pans[which] = 0;
244     }
245 }
246
247 #undef MIN
248 #define MIN(a,b) ((a) < (b) ? (a) : (b))
249 #define ABS(a)   ((a) < 0 ? -(a) : (a))
250
251 static void
252 my_create_panel(PANEL ** pans, int which, FillPanel myFill)
253 {
254     PANEL *pan = 0;
255     int code;
256     short pair = (short) which;
257     short fg = (short) ((pair == COLOR_BLUE) ? COLOR_WHITE : COLOR_BLACK);
258     short bg = pair;
259     int x0, y0, x1, y1;
260
261     init_pair(pair, fg, bg);
262
263     /* remove the old panel, if any */
264     my_remove_panel(pans, which);
265
266     /* get the position of one corner */
267     wmove(stdscr, getmaxy(stdscr) / 2, getmaxx(stdscr) / 2);
268     getyx(stdscr, y0, x0);
269     while ((code = get_position("First corner", "", which, &x0, &y0)) == 0) {
270         ;
271     }
272
273     if (code > 0) {
274         char also[80];
275         sprintf(also, " (first %d,%d)", y0, x0);
276         /* get the position of the opposite corner */
277         while ((code = get_position("Opposite corner",
278                                     also, which, &x1, &y1)) == 0) {
279             ;
280         }
281
282         if (code > 0) {
283             int tly = MIN(y0, y1);
284             int tlx = MIN(x0, x1);
285             pan = mkpanel(pair, ABS(y1 - y0) + 1, ABS(x1 - x0) + 1, tly, tlx);
286             /* finish */
287             myFill(pan);
288             pans[which] = pan;
289             pflush();
290             wmove(stdscr, y1, x1);
291         }
292     }
293 }
294
295 static void
296 my_move_panel(PANEL ** pans, int which, bool continuous)
297 {
298     if (pans[which] != 0) {
299         int code;
300         int y0, x0;
301         int y1, x1;
302         WINDOW *win = panel_window(pans[which]);
303         char also[80];
304
305         getbegyx(win, y0, x0);
306         sprintf(also, " (start %d,%d)", y0, x0);
307         wmove(stdscr, y0, x0);
308         while ((code = get_position("Move panel", also, which, &x1, &y1)) == 0) {
309             if (continuous) {
310                 move_panel(pans[which], y1, x1);
311                 pflush();
312             }
313         }
314         if (code > 0) {
315             move_panel(pans[which], y1, x1);
316         }
317     }
318 }
319
320 static void
321 my_resize_panel(PANEL ** pans, int which, FillPanel myFill)
322 {
323     if (pans[which] != 0) {
324         int code;
325         int y0, x0;
326         int y1, x1;
327         WINDOW *win = panel_window(pans[which]);
328         char also[80];
329
330         getbegyx(win, y0, x0);
331         sprintf(also, " (start %d,%d)", y0, x0);
332         wmove(stdscr, y0, x0);
333         while ((code = get_position("Resize panel",
334                                     also, which, &x1, &y1)) == 0) {
335             ;
336         }
337         if (code > 0) {
338             WINDOW *next = newwin(ABS(y1 - y0) + 1,
339                                   ABS(x1 - x0) + 1,
340                                   MIN(y0, y1),
341                                   MIN(x0, x1));
342             if (next != 0) {
343                 keypad(next, TRUE);
344                 if (use_colors) {
345                     wbkgdset(next, (chtype) (COLOR_PAIR(which) | ' '));
346                 } else if (!unboxed) {
347                     wbkgdset(next, A_BOLD | ' ');
348                 }
349                 replace_panel(pans[which], next);
350                 myFill(pans[which]);
351                 delwin(win);
352             }
353         }
354     }
355 }
356
357 static void
358 init_panel(void)
359 {
360     register int y, x;
361
362     for (y = 0; y < LINES - 1; y++) {
363         for (x = 0; x < COLS; x++)
364             wprintw(stdscr, "%d", (y + x) % 10);
365     }
366 }
367
368 static void
369 fill_panel(PANEL * pan)
370 {
371     WINDOW *win = panel_window(pan);
372     const char *userptr = (const char *) panel_userptr(pan);
373     int num = (userptr && *userptr) ? userptr[1] : '?';
374     int y, x;
375
376     wmove(win, 1, 1);
377     wprintw(win, "-pan%c-", num);
378     wclrtoeol(win);
379     box(win, 0, 0);
380     for (y = 2; y < getmaxy(win) - 1; y++) {
381         for (x = 1; x < getmaxx(win) - 1; x++) {
382             wmove(win, y, x);
383             waddch(win, UChar(num));
384         }
385     }
386 }
387
388 static void
389 fill_unboxed(PANEL * pan)
390 {
391     WINDOW *win = panel_window(pan);
392     const char *userptr = (const char *) panel_userptr(pan);
393     int num = (userptr && *userptr) ? userptr[1] : '?';
394     int y, x;
395
396     for (y = 0; y < getmaxy(win); y++) {
397         for (x = 0; x < getmaxx(win); x++) {
398             wmove(win, y, x);
399             waddch(win, UChar(num));
400         }
401     }
402 }
403
404 #if USE_WIDEC_SUPPORT
405 static void
406 make_fullwidth_digit(cchar_t *target, int digit)
407 {
408     wchar_t source[2];
409
410     source[0] = digit + 0xff10;
411     source[1] = 0;
412     setcchar(target, source, A_NORMAL, 0, 0);
413 }
414
415 static void
416 init_wide_panel(void)
417 {
418     int digit;
419     cchar_t temp[10];
420
421     for (digit = 0; digit < 10; ++digit)
422         make_fullwidth_digit(&temp[digit], digit);
423
424     do {
425         int y, x;
426         getyx(stdscr, y, x);
427         digit = (y + x / 2) % 10;
428     } while (add_wch(&temp[digit]) != ERR);
429 }
430
431 static void
432 fill_wide_panel(PANEL * pan)
433 {
434     WINDOW *win = panel_window(pan);
435     int num = ((const char *) panel_userptr(pan))[1];
436     int y, x;
437
438     wmove(win, 1, 1);
439     wprintw(win, "-pan%c-", num);
440     wclrtoeol(win);
441     box(win, 0, 0);
442     for (y = 2; y < getmaxy(win) - 1; y++) {
443         for (x = 1; x < getmaxx(win) - 1; x++) {
444             wmove(win, y, x);
445             waddch(win, UChar(num));
446         }
447     }
448 }
449 #endif
450
451 #define MAX_PANELS 5
452
453 static int
454 which_panel(PANEL * px[MAX_PANELS + 1], PANEL * pan)
455 {
456     int result = 0;
457     int j;
458
459     for (j = 1; j <= MAX_PANELS; ++j) {
460         if (px[j] == pan) {
461             result = j;
462             break;
463         }
464     }
465     return result;
466 }
467
468 static void
469 show_panels(PANEL * px[MAX_PANELS + 1])
470 {
471     static const char *help[] =
472     {
473         "",
474         "Commands are letter/digit pairs.  Digits are the panel number.",
475         "",
476         "  b - put the panel on the bottom of the stack",
477         "  c - create the panel",
478         "  d - delete the panel",
479         "  h - hide the panel",
480         "  m - move the panel (M for continuous move)",
481         "  r - resize the panel",
482         "  s - show the panel",
483         "  b - put the panel on the top of the stack"
484     };
485
486     struct {
487         bool valid;
488         bool hidden;
489         PANEL *above;
490         PANEL *below;
491     } table[MAX_PANELS + 1];
492
493     WINDOW *win;
494     PANEL *pan;
495     int j;
496
497     memset(table, 0, sizeof(table));
498     for (j = 1; j <= MAX_PANELS; ++j) {
499         table[j].valid = (px[j] != 0);
500         if (table[j].valid) {
501             table[j].hidden = panel_hidden(px[j]);
502             table[j].above = panel_above(px[j]);
503             table[j].below = panel_below(px[j]);
504         }
505     }
506
507     if ((win = newwin(LINES - 1, COLS, 0, 0)) != 0) {
508         keypad(win, TRUE);
509         if ((pan = new_panel(win)) != 0) {
510             werase(win);
511             mvwprintw(win, 0, 0, "Panels:\n");
512             for (j = 1; j <= MAX_PANELS; ++j) {
513                 if (table[j].valid) {
514                     wprintw(win, " %d:", j);
515                     if (table[j].hidden) {
516                         waddstr(win, " hidden");
517                     } else {
518                         if (table[j].above) {
519                             wprintw(win, " above %d",
520                                     which_panel(px, table[j].above));
521                         }
522                         if (table[j].below) {
523                             wprintw(win, "%s below %d",
524                                     table[j].above ? "," : "",
525                                     which_panel(px, table[j].below));
526                         }
527                     }
528                     waddch(win, '\n');
529                 }
530             }
531             for (j = 0; j < (int) SIZEOF(help); ++j) {
532                 if (wprintw(win, "%s\n", help[j]) == ERR)
533                     break;
534             }
535             wgetch(win);
536             del_panel(pan);
537             pflush();
538         }
539         delwin(win);
540     }
541 }
542
543 #define wrapper(func) \
544 static int my_##func(PANEL *pan) \
545 { \
546     int code = ERR; \
547     if (pan != 0) { \
548         code = func(pan); \
549     } \
550     return code; \
551 }
552 /* *INDENT-OFF* */
553 wrapper(bottom_panel)
554 wrapper(hide_panel)
555 wrapper(show_panel)
556 wrapper(top_panel)
557 /* *INDENT-ON* */
558
559 static void
560 do_panel(PANEL * px[MAX_PANELS + 1],
561          NCURSES_CONST char *cmd,
562          FillPanel myFill)
563 {
564     int which = cmd[1] - '0';
565
566     if (which < 1 || which > MAX_PANELS) {
567         beep();
568         return;
569     }
570
571     if (log_in != 0) {
572         pflush();
573     }
574
575     saywhat(cmd);
576     switch (*cmd) {
577     case 'b':
578         my_bottom_panel(px[which]);
579         break;
580     case 'c':
581         my_create_panel(px, which, myFill);
582         break;
583     case 'd':
584         my_remove_panel(px, which);
585         break;
586     case 'h':
587         my_hide_panel(px[which]);
588         break;
589     case 'm':
590         my_move_panel(px, which, FALSE);
591         break;
592     case 'M':
593         my_move_panel(px, which, TRUE);
594         break;
595     case 'r':
596         my_resize_panel(px, which, myFill);
597         break;
598     case 's':
599         my_show_panel(px[which]);
600         break;
601     case 't':
602         my_top_panel(px[which]);
603         break;
604     }
605 }
606
607 static bool
608 ok_letter(int ch)
609 {
610     return isalpha(UChar(ch)) && strchr("bcdhmMrst", ch) != 0;
611 }
612
613 static bool
614 ok_digit(int ch)
615 {
616     return isdigit(UChar(ch)) && (ch >= '1') && (ch - '0' <= MAX_PANELS);
617 }
618
619 /*
620  * A command consists of one or more letter/digit pairs separated by a space.
621  * Digits are limited to 1..MAX_PANELS.
622  *
623  * End the command with a newline.  Reject other characters.
624  */
625 static bool
626 get_command(PANEL * px[MAX_PANELS + 1], char *buffer, int limit)
627 {
628     int length = 0;
629     int y0, x0;
630     int c0, ch;
631     WINDOW *win;
632
633     getyx(stdscr, y0, x0);
634     win = statusline();
635     waddstr(win, "Command:");
636     buffer[length = 0] = '\0';
637
638     if (log_in != 0) {
639         if (fgets(buffer, limit - 3, log_in) != 0) {
640             length = (int) strlen(buffer);
641             while (length > 0 && isspace(UChar(buffer[length - 1])))
642                 buffer[--length] = '\0';
643             waddstr(win, buffer);
644         } else {
645             close_input();
646         }
647         (void) wgetch(win);
648     } else {
649         c0 = 0;
650         for (;;) {
651             ch = wgetch(win);
652             if (ch == ERR || ch == QUIT || ch == ESCAPE) {
653                 buffer[0] = '\0';
654                 break;
655             } else if (ch == CTRL('L')) {
656                 wrefresh(curscr);
657             } else if (ch == '\n' || ch == KEY_ENTER) {
658                 break;
659             } else if (ch == '?') {
660                 show_panels(px);
661             } else if (length + 3 < limit) {
662                 if (ch >= KEY_MIN) {
663                     beep();
664                 } else if (ok_letter(UChar(ch))) {
665                     if (isalpha(UChar(c0))) {
666                         beep();
667                     } else if (isdigit(UChar(c0))) {
668                         wprintw(win, " %c", ch);
669                         buffer[length++] = ' ';
670                         buffer[length++] = (char) (c0 = ch);
671                     } else {
672                         wprintw(win, "%c", ch);
673                         buffer[length++] = (char) (c0 = ch);
674                     }
675                 } else if (ok_digit(ch)) {
676                     if (isalpha(UChar(c0))) {
677                         wprintw(win, "%c", ch);
678                         buffer[length++] = (char) (c0 = ch);
679                     } else {
680                         beep();
681                     }
682                 } else if (ch == ' ') {
683                     if (isdigit(UChar(c0))) {
684                         wprintw(win, "%c", ch);
685                         buffer[length++] = (char) (c0 = ch);
686                     } else {
687                         beep();
688                     }
689                 } else {
690                     beep();
691                 }
692             } else {
693                 beep();
694             }
695         }
696     }
697
698     wmove(stdscr, y0, x0);
699
700     buffer[length] = '\0';
701     if (log_out && length) {
702         fprintf(log_out, "%s\n", buffer);
703     }
704     return (length != 0);
705 }
706
707 static void
708 demo_panels(InitPanel myInit, FillPanel myFill)
709 {
710     int itmp;
711     PANEL *px[MAX_PANELS + 1];
712     char buffer[BUFSIZ];
713
714     scrollok(stdscr, FALSE);    /* we don't want stdscr to scroll! */
715     refresh();
716
717     myInit();
718     memset(px, 0, sizeof(px));
719
720     while (get_command(px, buffer, sizeof(buffer))) {
721         int limit = (int) strlen(buffer);
722         for (itmp = 0; itmp < limit; itmp += 3) {
723             do_panel(px, buffer + itmp, myFill);
724         }
725         pflush();
726     }
727 #if NO_LEAKS
728     for (itmp = 1; itmp <= MAX_PANELS; ++itmp) {
729         my_remove_panel(px, itmp);
730     }
731 #endif
732 }
733
734 static void
735 usage(void)
736 {
737     static const char *const tbl[] =
738     {
739         "Usage: demo_panels [options]"
740         ,""
741         ,"Options:"
742         ,"  -i file  read commands from file"
743         ,"  -o file  record commands in file"
744         ,"  -m       do not use colors"
745 #if USE_WIDEC_SUPPORT
746         ,"  -w       use wide-characters in panels and background"
747 #endif
748         ,"  -x       do not enclose panels in boxes"
749     };
750     size_t n;
751     for (n = 0; n < SIZEOF(tbl); n++)
752         fprintf(stderr, "%s\n", tbl[n]);
753     ExitProgram(EXIT_FAILURE);
754 }
755
756 int
757 main(int argc, char *argv[])
758 {
759     int c;
760     bool monochrome = FALSE;
761     InitPanel myInit = init_panel;
762     FillPanel myFill = fill_panel;
763
764     setlocale(LC_ALL, "");
765
766     while ((c = getopt(argc, argv, "i:o:mwx")) != -1) {
767         switch (c) {
768         case 'i':
769             log_in = fopen(optarg, "r");
770             break;
771         case 'o':
772             log_out = fopen(optarg, "w");
773             break;
774         case 'm':
775             monochrome = TRUE;
776             break;
777 #if USE_WIDEC_SUPPORT
778         case 'w':
779             myInit = init_wide_panel;
780             myFill = fill_wide_panel;
781             break;
782 #endif
783         case 'x':
784             unboxed = TRUE;
785             break;
786         default:
787             usage();
788         }
789     }
790     if (unboxed)
791         myFill = fill_unboxed;
792
793     initscr();
794     cbreak();
795     noecho();
796     keypad(stdscr, TRUE);
797
798     use_colors = monochrome ? FALSE : has_colors();
799     if (use_colors)
800         start_color();
801
802     demo_panels(myInit, myFill);
803     endwin();
804
805     close_input();
806     close_output();
807
808     ExitProgram(EXIT_SUCCESS);
809 }
810 #else
811 int
812 main(void)
813 {
814     printf("This program requires the curses panel library\n");
815     ExitProgram(EXIT_FAILURE);
816 }
817 #endif