?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vendor/NCURSES: Remove version tag.
[dragonfly.git] / contrib / ncurses / test / ncurses.c
blob791c3a4157c9eeafec9c2d041a335247e13e1a8f
1 /****************************************************************************
2 * Copyright (c) 1998-2003,2004 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
30 NAME
31 ncurses.c --- ncurses library exerciser
32
33 SYNOPSIS
34 ncurses
35
36 DESCRIPTION
37 An interactive test module for the ncurses library.
38
39 AUTHOR
40 Author: Eric S. Raymond <esr@snark.thyrsus.com> 1993
41 Thomas E. Dickey (beginning revision 1.27 in 1996).
42
43 $Id: ncurses.c,v 1.202 2004/02/07 20:24:08 tom Exp $
44
45 ***************************************************************************/
46
47 #include <test.priv.h>
48
49 #if HAVE_GETTIMEOFDAY
50 #if HAVE_SYS_TIME_H && HAVE_SYS_TIME_SELECT
51 #include <sys/time.h>
52 #endif
53 #if HAVE_SYS_SELECT_H
54 #include <sys/select.h>
55 #endif
56 #endif
57
58 #if USE_LIBPANEL
59 #include <panel.h>
60 #endif
61
62 #if USE_LIBMENU
63 #include <menu.h>
64 #endif
65
66 #if USE_LIBFORM
67 #include <form.h>
68 #endif
69
70 #ifdef NCURSES_VERSION
71
72 #ifdef TRACE
73 static int save_trace = TRACE_ORDINARY | TRACE_CALLS;
74 extern int _nc_tracing;
75 #endif
76
77 #else
78
79 #define mmask_t chtype /* not specified in XSI */
80
81 #ifdef CURSES_ACS_ARRAY
82 #define ACS_S3 (CURSES_ACS_ARRAY['p']) /* scan line 3 */
83 #define ACS_S7 (CURSES_ACS_ARRAY['r']) /* scan line 7 */
84 #define ACS_LEQUAL (CURSES_ACS_ARRAY['y']) /* less/equal */
85 #define ACS_GEQUAL (CURSES_ACS_ARRAY['z']) /* greater/equal */
86 #define ACS_PI (CURSES_ACS_ARRAY['{']) /* Pi */
87 #define ACS_NEQUAL (CURSES_ACS_ARRAY['|']) /* not equal */
88 #define ACS_STERLING (CURSES_ACS_ARRAY['}']) /* UK pound sign */
89 #else
90 #define ACS_S3 (A_ALTCHARSET + 'p') /* scan line 3 */
91 #define ACS_S7 (A_ALTCHARSET + 'r') /* scan line 7 */
92 #define ACS_LEQUAL (A_ALTCHARSET + 'y') /* less/equal */
93 #define ACS_GEQUAL (A_ALTCHARSET + 'z') /* greater/equal */
94 #define ACS_PI (A_ALTCHARSET + '{') /* Pi */
95 #define ACS_NEQUAL (A_ALTCHARSET + '|') /* not equal */
96 #define ACS_STERLING (A_ALTCHARSET + '}') /* UK pound sign */
97 #endif
98
99 #ifdef CURSES_WACS_ARRAY
100 #define WACS_S3 (&(CURSES_WACS_ARRAY['p'])) /* scan line 3 */
101 #define WACS_S7 (&(CURSES_WACS_ARRAY['r'])) /* scan line 7 */
102 #define WACS_LEQUAL (&(CURSES_WACS_ARRAY['y'])) /* less/equal */
103 #define WACS_GEQUAL (&(CURSES_WACS_ARRAY['z'])) /* greater/equal */
104 #define WACS_PI (&(CURSES_WACS_ARRAY['{'])) /* Pi */
105 #define WACS_NEQUAL (&(CURSES_WACS_ARRAY['|'])) /* not equal */
106 #define WACS_STERLING (&(CURSES_WACS_ARRAY['}'])) /* UK pound sign */
107 #endif
108
109 #endif
110
111 #define P(string) printw("%s\n", string)
112
113 #define BLANK ' ' /* this is the background character */
114
115 #undef max_colors
116 static int max_colors; /* the actual number of colors we'll use */
117
118 #undef max_pairs
119 static int max_pairs; /* ...and the number of color pairs */
120
121 /* The behavior of mvhline, mvvline for negative/zero length is unspecified,
122 * though we can rely on negative x/y values to stop the macro.
123 */
124 static void
125 do_h_line(int y, int x, chtype c, int to)
126 {
127 if ((to) > (x))
128 mvhline(y, x, c, (to) - (x));
129 }
130
131 static void
132 do_v_line(int y, int x, chtype c, int to)
133 {
134 if ((to) > (y))
135 mvvline(y, x, c, (to) - (y));
136 }
137
138 /* Common function to allow ^T to toggle trace-mode in the middle of a test
139 * so that trace-files can be made smaller.
140 */
141 static int
142 wGetchar(WINDOW *win)
143 {
144 int c;
145 #ifdef TRACE
146 while ((c = wgetch(win)) == CTRL('T')) {
147 if (_nc_tracing) {
148 save_trace = _nc_tracing;
149 _tracef("TOGGLE-TRACING OFF");
150 _nc_tracing = 0;
151 } else {
152 _nc_tracing = save_trace;
153 }
154 trace(_nc_tracing);
155 if (_nc_tracing)
156 _tracef("TOGGLE-TRACING ON");
157 }
158 #else
159 c = wgetch(win);
160 #endif
161 return c;
162 }
163 #define Getchar() wGetchar(stdscr)
164
165 /* replaces wgetnstr(), since we want to be able to edit values */
166 static void
167 wGetstring(WINDOW *win, char *buffer, int limit)
168 {
169 int y0, x0, x, ch;
170 bool done = FALSE;
171
172 echo();
173 getyx(win, y0, x0);
174 wattrset(win, A_REVERSE);
175
176 x = strlen(buffer);
177 while (!done) {
178 if (x > (int) strlen(buffer))
179 x = (int) strlen(buffer);
180 wmove(win, y0, x0);
181 wprintw(win, "%-*s", limit, buffer);
182 wmove(win, y0, x0 + x);
183 switch (ch = wGetchar(win)) {
184 case '\n':
185 case KEY_ENTER:
186 done = TRUE;
187 break;
188 case CTRL('U'):
189 *buffer = '\0';
190 break;
191 case '\b':
192 case KEY_BACKSPACE:
193 case KEY_DC:
194 if (x > 0) {
195 int j;
196 for (j = --x; (buffer[j] = buffer[j + 1]) != '\0'; ++j) {
197 ;
198 }
199 } else {
200 beep();
201 }
202 break;
203 case KEY_LEFT:
204 if (x > 0) {
205 --x;
206 } else {
207 flash();
208 }
209 break;
210 case KEY_RIGHT:
211 ++x;
212 break;
213 default:
214 if (!isprint(ch) || ch >= KEY_MIN) {
215 beep();
216 } else if ((int) strlen(buffer) < limit) {
217 int j;
218 for (j = strlen(buffer) + 1; j > x; --j) {
219 buffer[j] = buffer[j - 1];
220 }
221 buffer[x++] = ch;
222 } else {
223 flash();
224 }
225 }
226 }
227
228 wattroff(win, A_REVERSE);
229 wmove(win, y0, x0);
230 noecho();
231 }
232
233 #if USE_WIDEC_SUPPORT
234 static int
235 wGet_wchar(WINDOW *win, wint_t * result)
236 {
237 int c;
238 #ifdef TRACE
239 while ((c = wget_wch(win, result)) == CTRL('T')) {
240 if (_nc_tracing) {
241 save_trace = _nc_tracing;
242 _tracef("TOGGLE-TRACING OFF");
243 _nc_tracing = 0;
244 } else {
245 _nc_tracing = save_trace;
246 }
247 trace(_nc_tracing);
248 if (_nc_tracing)
249 _tracef("TOGGLE-TRACING ON");
250 }
251 #else
252 c = wget_wch(win, result);
253 #endif
254 return c;
255 }
256 #define Get_wchar(result) wGet_wchar(stdscr, result)
257
258 /* replaces wgetn_wstr(), since we want to be able to edit values */
259 static void
260 wGet_wstring(WINDOW *win, wchar_t * buffer, int limit)
261 {
262 int y0, x0, x;
263 wint_t ch;
264 bool done = FALSE;
265
266 echo();
267 getyx(win, y0, x0);
268 wattrset(win, A_REVERSE);
269
270 x = wcslen(buffer);
271 while (!done) {
272 if (x > (int) wcslen(buffer))
273 x = (int) wcslen(buffer);
274 wmove(win, y0, x0);
275 waddnwstr(win, buffer, limit);
276 if (x < limit)
277 wprintw(win, "%*s", limit - x, " ");
278 wmove(win, y0, x0 + x);
279 switch (wGet_wchar(win, &ch)) {
280 case KEY_CODE_YES:
281 switch (ch) {
282 case KEY_ENTER:
283 ch = '\n';
284 break;
285 case KEY_BACKSPACE:
286 case KEY_DC:
287 ch = '\b';
288 break;
289 case KEY_LEFT:
290 case KEY_RIGHT:
291 break;
292 default:
293 ch = (wint_t) - 1;
294 break;
295 }
296 case OK:
297 break;
298 default:
299 ch = (wint_t) - 1;
300 break;
301 }
302
303 switch (ch) {
304 case '\n':
305 done = TRUE;
306 break;
307 case CTRL('U'):
308 *buffer = '\0';
309 break;
310 case '\b':
311 if (x > 0) {
312 int j;
313 for (j = --x; (buffer[j] = buffer[j + 1]) != '\0'; ++j) {
314 ;
315 }
316 } else {
317 beep();
318 }
319 break;
320 case KEY_LEFT:
321 if (x > 0) {
322 --x;
323 } else {
324 flash();
325 }
326 break;
327 case KEY_RIGHT:
328 ++x;
329 break;
330 default:
331 if (!isprint(ch) || ch >= KEY_MIN) {
332 beep();
333 } else if ((int) wcslen(buffer) < limit) {
334 int j;
335 for (j = wcslen(buffer) + 1; j > x; --j) {
336 buffer[j] = buffer[j - 1];
337 }
338 buffer[x++] = ch;
339 } else {
340 flash();
341 }
342 }
343 }
344
345 wattroff(win, A_REVERSE);
346 wmove(win, y0, x0);
347 noecho();
348 }
349
350 #endif
351
352 static void
353 Pause(void)
354 {
355 move(LINES - 1, 0);
356 addstr("Press any key to continue... ");
357 (void) Getchar();
358 }
359
360 static void
361 Cannot(const char *what)
362 {
363 printw("\nThis %s terminal %s\n\n", getenv("TERM"), what);
364 Pause();
365 }
366
367 static void
368 ShellOut(bool message)
369 {
370 if (message)
371 addstr("Shelling out...");
372 def_prog_mode();
373 endwin();
374 system("sh");
375 if (message)
376 addstr("returned from shellout.\n");
377 refresh();
378 }
379
380 #ifdef NCURSES_MOUSE_VERSION
381 static const char *
382 mouse_decode(MEVENT const *ep)
383 {
384 static char buf[80];
385
386 (void) sprintf(buf, "id %2d at (%2d, %2d, %2d) state %4lx = {",
387 ep->id, ep->x, ep->y, ep->z, ep->bstate);
388
389 #define SHOW(m, s) if ((ep->bstate & m)==m) {strcat(buf,s); strcat(buf, ", ");}
390 SHOW(BUTTON1_RELEASED, "release-1");
391 SHOW(BUTTON1_PRESSED, "press-1");
392 SHOW(BUTTON1_CLICKED, "click-1");
393 SHOW(BUTTON1_DOUBLE_CLICKED, "doubleclick-1");
394 SHOW(BUTTON1_TRIPLE_CLICKED, "tripleclick-1");
395 SHOW(BUTTON1_RESERVED_EVENT, "reserved-1");
396 SHOW(BUTTON2_RELEASED, "release-2");
397 SHOW(BUTTON2_PRESSED, "press-2");
398 SHOW(BUTTON2_CLICKED, "click-2");
399 SHOW(BUTTON2_DOUBLE_CLICKED, "doubleclick-2");
400 SHOW(BUTTON2_TRIPLE_CLICKED, "tripleclick-2");
401 SHOW(BUTTON2_RESERVED_EVENT, "reserved-2");
402 SHOW(BUTTON3_RELEASED, "release-3");
403 SHOW(BUTTON3_PRESSED, "press-3");
404 SHOW(BUTTON3_CLICKED, "click-3");
405 SHOW(BUTTON3_DOUBLE_CLICKED, "doubleclick-3");
406 SHOW(BUTTON3_TRIPLE_CLICKED, "tripleclick-3");
407 SHOW(BUTTON3_RESERVED_EVENT, "reserved-3");
408 SHOW(BUTTON4_RELEASED, "release-4");
409 SHOW(BUTTON4_PRESSED, "press-4");
410 SHOW(BUTTON4_CLICKED, "click-4");
411 SHOW(BUTTON4_DOUBLE_CLICKED, "doubleclick-4");
412 SHOW(BUTTON4_TRIPLE_CLICKED, "tripleclick-4");
413 SHOW(BUTTON4_RESERVED_EVENT, "reserved-4");
414 SHOW(BUTTON_CTRL, "ctrl");
415 SHOW(BUTTON_SHIFT, "shift");
416 SHOW(BUTTON_ALT, "alt");
417 SHOW(ALL_MOUSE_EVENTS, "all-events");
418 SHOW(REPORT_MOUSE_POSITION, "position");
419 #undef SHOW
420
421 if (buf[strlen(buf) - 1] == ' ')
422 buf[strlen(buf) - 2] = '\0';
423 (void) strcat(buf, "}");
424 return (buf);
425 }
426 #endif /* NCURSES_MOUSE_VERSION */
427
428 /****************************************************************************
429 *
430 * Character input test
431 *
432 ****************************************************************************/
433
434 static void
435 setup_getch(WINDOW *win, bool flags[])
436 {
437 keypad(win, flags['k']); /* should be redundant, but for testing */
438 meta(win, flags['m']); /* force this to a known state */
439 if (flags['e'])
440 echo();
441 else
442 noecho();
443 }
444
445 static void
446 wgetch_help(WINDOW *win, bool flags[])
447 {
448 static const char *help[] =
449 {
450 "e -- toggle echo mode"
451 ,"g -- triggers a getstr test"
452 ,"k -- toggle keypad/literal mode"
453 ,"m -- toggle meta (7-bit/8-bit) mode"
454 ,"q -- quit (x also exits)"
455 ,"s -- shell out\n"
456 ,"w -- create a new window"
457 #ifdef SIGTSTP
458 ,"z -- suspend this process"
459 #endif
460 };
461 int y, x;
462 unsigned chk = ((SIZEOF(help) + 1) / 2);
463 unsigned n;
464
465 getyx(win, y, x);
466 move(0, 0);
467 printw("Type any key to see its %s value. Also:\n",
468 flags['k'] ? "keypad" : "literal");
469 for (n = 0; n < SIZEOF(help); ++n) {
470 int row = 1 + (n % chk);
471 int col = (n >= chk) ? COLS / 2 : 0;
472 int flg = ((strstr(help[n], "toggle") != 0)
473 && (flags[UChar(*help[n])] != FALSE));
474 if (flg)
475 standout();
476 mvprintw(row, col, "%s", help[n]);
477 if (col == 0)
478 clrtoeol();
479 if (flg)
480 standend();
481 }
482 wrefresh(stdscr);
483 wmove(win, y, x);
484 }
485
486 static void
487 wgetch_wrap(WINDOW *win, int first_y)
488 {
489 int last_y = getmaxy(win) - 1;
490 int y = getcury(win) + 1;
491
492 if (y >= last_y)
493 y = first_y;
494 wmove(win, y, 0);
495 wclrtoeol(win);
496 }
497
498 #if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
499 typedef struct {
500 WINDOW *text;
501 WINDOW *frame;
502 } WINSTACK;
503
504 static WINSTACK *winstack = 0;
505 static unsigned len_winstack = 0;
506
507 static void
508 remember_boxes(unsigned level, WINDOW *txt_win, WINDOW *box_win)
509 {
510 unsigned need = (level + 1) * 2;
511
512 if (winstack == 0) {
513 len_winstack = 20;
514 winstack = (WINSTACK *) malloc(len_winstack * sizeof(WINSTACK));
515 } else if (need >= len_winstack) {
516 len_winstack = need;
517 winstack = (WINSTACK *) realloc(winstack, len_winstack * sizeof(WINSTACK));
518 }
519 winstack[level].text = txt_win;
520 winstack[level].frame = box_win;
521 }
522
523 /*
524 * For wgetch_test(), we create pairs of windows - one for a box, one for text.
525 * Resize both and paint the box in the parent.
526 */
527 static void
528 resize_boxes(int level, WINDOW *win)
529 {
530 unsigned n;
531 int base = 5;
532 int high = LINES - base;
533 int wide = COLS;
534
535 touchwin(stdscr);
536 wnoutrefresh(stdscr);
537
538 /* FIXME: this chunk should be done in resizeterm() */
539 slk_touch();
540 slk_clear();
541 slk_noutrefresh();
542
543 for (n = 0; (int) n < level; ++n) {
544 wresize(winstack[n].frame, high, wide);
545 wresize(winstack[n].text, high - 2, wide - 2);
546 high -= 2;
547 wide -= 2;
548 werase(winstack[n].text);
549 box(winstack[n].frame, 0, 0);
550 wnoutrefresh(winstack[n].frame);
551 wprintw(winstack[n].text,
552 "size %dx%d\n",
553 getmaxy(winstack[n].text),
554 getmaxx(winstack[n].text));
555 wnoutrefresh(winstack[n].text);
556 if (winstack[n].text == win)
557 break;
558 }
559 doupdate();
560 }
561 #else
562 #define remember_boxes(level,text,frame) /* nothing */
563 #endif
564
565 static void
566 wgetch_test(int level, WINDOW *win, int delay)
567 {
568 char buf[BUFSIZ];
569 int first_y, first_x;
570 int c;
571 int incount = 0;
572 bool flags[256];
573 bool blocking = (delay < 0);
574 int y, x;
575
576 memset(flags, FALSE, sizeof(flags));
577 flags[UChar('k')] = (win == stdscr);
578
579 setup_getch(win, flags);
580 wtimeout(win, delay);
581 getyx(win, first_y, first_x);
582
583 wgetch_help(win, flags);
584 wsetscrreg(win, first_y, getmaxy(win) - 1);
585 scrollok(win, TRUE);
586
587 for (;;) {
588 while ((c = wGetchar(win)) == ERR) {
589 incount++;
590 if (blocking) {
591 (void) wprintw(win, "%05d: input error", incount);
592 break;
593 } else {
594 (void) wprintw(win, "%05d: input timed out", incount);
595 }
596 wgetch_wrap(win, first_y);
597 }
598 if (c == ERR && blocking) {
599 wprintw(win, "ERR");
600 wgetch_wrap(win, first_y);
601 } else if (c == 'x' || c == 'q') {
602 break;
603 } else if (c == 'e') {
604 flags[UChar('e')] = !flags[UChar('e')];
605 setup_getch(win, flags);
606 wgetch_help(win, flags);
607 } else if (c == 'g') {
608 waddstr(win, "getstr test: ");
609 echo();
610 wgetnstr(win, buf, sizeof(buf) - 1);
611 noecho();
612 wprintw(win, "I saw %d characters:\n\t`%s'.", (int) strlen(buf), buf);
613 wclrtoeol(win);
614 wgetch_wrap(win, first_y);
615 } else if (c == 'k') {
616 flags[UChar('k')] = !flags[UChar('k')];
617 setup_getch(win, flags);
618 wgetch_help(win, flags);
619 } else if (c == 'm') {
620 flags[UChar('m')] = !flags[UChar('m')];
621 setup_getch(win, flags);
622 wgetch_help(win, flags);
623 } else if (c == 's') {
624 ShellOut(TRUE);
625 } else if (c == 'w') {
626 int high = getmaxy(win) - 1 - first_y + 1;
627 int wide = getmaxx(win) - first_x;
628 int old_y, old_x;
629 int new_y = first_y + getbegy(win);
630 int new_x = first_x + getbegx(win);
631
632 getyx(win, old_y, old_x);
633 if (high > 2 && wide > 2) {
634 WINDOW *wb = newwin(high, wide, new_y, new_x);
635 WINDOW *wi = newwin(high - 2, wide - 2, new_y + 1, new_x + 1);
636
637 box(wb, 0, 0);
638 wrefresh(wb);
639 wmove(wi, 0, 0);
640 remember_boxes(level, wi, wb);
641 wgetch_test(level + 1, wi, delay);
642 delwin(wi);
643 delwin(wb);
644
645 wgetch_help(win, flags);
646 wmove(win, old_y, old_x);
647 touchwin(win);
648 wrefresh(win);
649 doupdate();
650 }
651 #ifdef SIGTSTP
652 } else if (c == 'z') {
653 kill(getpid(), SIGTSTP);
654 #endif
655 } else {
656 wprintw(win, "Key pressed: %04o ", c);
657 #ifdef NCURSES_MOUSE_VERSION
658 if (c == KEY_MOUSE) {
659 MEVENT event;
660
661 getmouse(&event);
662 wprintw(win, "KEY_MOUSE, %s", mouse_decode(&event));
663 getyx(win, y, x);
664 move(event.y, event.x);
665 addch('*');
666 wmove(win, y, x);
667 } else
668 #endif /* NCURSES_MOUSE_VERSION */
669 if (c >= KEY_MIN) {
670 #if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
671 if (c == KEY_RESIZE) {
672 resize_boxes(level, win);
673 }
674 #endif
675 (void) waddstr(win, keyname(c));
676 } else if (c > 0x80) {
677 int c2 = (c & 0x7f);
678 if (isprint(c2))
679 (void) wprintw(win, "M-%c", c2);
680 else
681 (void) wprintw(win, "M-%s", unctrl(c2));
682 waddstr(win, " (high-half character)");
683 } else {
684 if (isprint(c))
685 (void) wprintw(win, "%c (ASCII printable character)", c);
686 else
687 (void) wprintw(win, "%s (ASCII control character)",
688 unctrl(c));
689 }
690 wgetch_wrap(win, first_y);
691 }
692 }
693
694 wtimeout(win, -1);
695 }
696
697 static int
698 begin_getch_test(void)
699 {
700 char buf[BUFSIZ];
701 int delay;
702
703 refresh();
704
705 #ifdef NCURSES_MOUSE_VERSION
706 mousemask(ALL_MOUSE_EVENTS, (mmask_t *) 0);
707 #endif
708
709 (void) printw("Delay in 10ths of a second (<CR> for blocking input)? ");
710 echo();
711 getnstr(buf, sizeof(buf) - 1);
712 noecho();
713 nonl();
714
715 if (isdigit(UChar(buf[0]))) {
716 delay = atoi(buf) * 100;
717 } else {
718 delay = -1;
719 }
720 raw();
721 move(5, 0);
722 return delay;
723 }
724
725 static void
726 finish_getch_test(void)
727 {
728 #ifdef NCURSES_MOUSE_VERSION
729 mousemask(0, (mmask_t *) 0);
730 #endif
731 erase();
732 noraw();
733 nl();
734 endwin();
735 }
736
737 static void
738 getch_test(void)
739 {
740 int delay = begin_getch_test();
741 wgetch_test(0, stdscr, delay);
742 finish_getch_test();
743 }
744
745 #if USE_WIDEC_SUPPORT
746 /*
747 * For wgetch_test(), we create pairs of windows - one for a box, one for text.
748 * Resize both and paint the box in the parent.
749 */
750 #ifdef KEY_RESIZE
751 static void
752 resize_wide_boxes(int level, WINDOW *win)
753 {
754 unsigned n;
755 int base = 5;
756 int high = LINES - base;
757 int wide = COLS;
758
759 touchwin(stdscr);
760 wnoutrefresh(stdscr);
761
762 /* FIXME: this chunk should be done in resizeterm() */
763 slk_touch();
764 slk_clear();
765 slk_noutrefresh();
766
767 for (n = 0; (int) n < level; ++n) {
768 wresize(winstack[n].frame, high, wide);
769 wresize(winstack[n].text, high - 2, wide - 2);
770 high -= 2;
771 wide -= 2;
772 werase(winstack[n].text);
773 box_set(winstack[n].frame, 0, 0);
774 wnoutrefresh(winstack[n].frame);
775 wprintw(winstack[n].text,
776 "size %dx%d\n",
777 getmaxy(winstack[n].text),
778 getmaxx(winstack[n].text));
779 wnoutrefresh(winstack[n].text);
780 if (winstack[n].text == win)
781 break;
782 }
783 doupdate();
784 }
785 #endif /* KEY_RESIZE */
786
787 static char *
788 wcstos(const wchar_t * src)
789 {
790 int need;
791 mbstate_t state;
792 char *result = 0;
793 const wchar_t *tmp = src;
794
795 memset(&state, 0, sizeof(state));
796 if ((need = wcsrtombs(0, &tmp, 0, &state)) > 0) {
797 result = (char *) calloc(need + 1, 1);
798 tmp = src;
799 if (wcsrtombs(result, &tmp, need, &state) != (size_t) need) {
800 free(result);
801 result = 0;
802 }
803 }
804 return result;
805 }
806
807 static void
808 wget_wch_test(int level, WINDOW *win, int delay)
809 {
810 wchar_t buf[BUFSIZ];
811 int first_y, first_x;
812 wint_t c;
813 int incount = 0;
814 bool flags[256];
815 bool blocking = (delay < 0);
816 int y, x, code;
817 char *temp;
818
819 memset(flags, FALSE, sizeof(flags));
820 flags[UChar('k')] = (win == stdscr);
821
822 setup_getch(win, flags);
823 wtimeout(win, delay);
824 getyx(win, first_y, first_x);
825
826 wgetch_help(win, flags);
827 wsetscrreg(win, first_y, getmaxy(win) - 1);
828 scrollok(win, TRUE);
829
830 for (;;) {
831 while ((code = wGet_wchar(win, &c)) == ERR) {
832 incount++;
833 if (blocking) {
834 (void) wprintw(win, "%05d: input error", incount);
835 break;
836 } else {
837 (void) wprintw(win, "%05d: input timed out", incount);
838 }
839 wgetch_wrap(win, first_y);
840 }
841 if (code == ERR && blocking) {
842 wprintw(win, "ERR");
843 wgetch_wrap(win, first_y);
844 } else if (c == 'x' || c == 'q') {
845 break;
846 } else if (c == 'e') {
847 flags[UChar('e')] = !flags[UChar('e')];
848 setup_getch(win, flags);
849 wgetch_help(win, flags);
850 } else if (c == 'g') {
851 waddstr(win, "getstr test: ");
852 echo();
853 wgetn_wstr(win, (wint_t *) buf, sizeof(buf) - 1);
854 noecho();
855 if ((temp = wcstos(buf)) != 0) {
856 wprintw(win, "I saw %d characters:\n\t`%s'.", wcslen(buf), temp);
857 free(temp);
858 } else {
859 wprintw(win, "I saw %d characters (cannot convert).", wcslen(buf));
860 }
861 wclrtoeol(win);
862 wgetch_wrap(win, first_y);
863 } else if (c == 'k') {
864 flags[UChar('k')] = !flags[UChar('k')];
865 setup_getch(win, flags);
866 wgetch_help(win, flags);
867 } else if (c == 'm') {
868 flags[UChar('m')] = !flags[UChar('m')];
869 setup_getch(win, flags);
870 wgetch_help(win, flags);
871 } else if (c == 's') {
872 ShellOut(TRUE);
873 } else if (c == 'w') {
874 int high = getmaxy(win) - 1 - first_y + 1;
875 int wide = getmaxx(win) - first_x;
876 int old_y, old_x;
877 int new_y = first_y + getbegy(win);
878 int new_x = first_x + getbegx(win);
879
880 getyx(win, old_y, old_x);
881 if (high > 2 && wide > 2) {
882 WINDOW *wb = newwin(high, wide, new_y, new_x);
883 WINDOW *wi = newwin(high - 2, wide - 2, new_y + 1, new_x + 1);
884
885 box_set(wb, 0, 0);
886 wrefresh(wb);
887 wmove(wi, 0, 0);
888 remember_boxes(level, wi, wb);
889 wget_wch_test(level + 1, wi, delay);
890 delwin(wi);
891 delwin(wb);
892
893 wgetch_help(win, flags);
894 wmove(win, old_y, old_x);
895 touchwin(win);
896 wrefresh(win);
897 }
898 #ifdef SIGTSTP
899 } else if (c == 'z') {
900 kill(getpid(), SIGTSTP);
901 #endif
902 } else {
903 wprintw(win, "Key pressed: %04o ", c);
904 #ifdef NCURSES_MOUSE_VERSION
905 if (c == KEY_MOUSE) {
906 MEVENT event;
907
908 getmouse(&event);
909 wprintw(win, "KEY_MOUSE, %s", mouse_decode(&event));
910 getyx(win, y, x);
911 move(event.y, event.x);
912 addch('*');
913 wmove(win, y, x);
914 } else
915 #endif /* NCURSES_MOUSE_VERSION */
916 if (code == KEY_CODE_YES) {
917 #ifdef KEY_RESIZE
918 if (c == KEY_RESIZE) {
919 resize_wide_boxes(level, win);
920 }
921 #endif
922 (void) waddstr(win, key_name(c));
923 } else {
924 if (c < 256 && iscntrl(c)) {
925 (void) wprintw(win, "%s (control character)", unctrl(c));
926 } else {
927 wchar_t c2 = c;
928 waddnwstr(win, &c2, 1);
929 (void) wprintw(win, " = %#x (printable character)", c);
930 }
931 }
932 wgetch_wrap(win, first_y);
933 }
934 }
935
936 wtimeout(win, -1);
937 }
938
939 static void
940 get_wch_test(void)
941 {
942 int delay = begin_getch_test();
943 wget_wch_test(0, stdscr, delay);
944 finish_getch_test();
945 }
946 #endif
947
948 /****************************************************************************
949 *
950 * Character attributes test
951 *
952 ****************************************************************************/
953
954 #define MAX_ATTRSTRING 31
955 #define LEN_ATTRSTRING 26
956
957 static char attr_test_string[] = "abcde fghij klmno pqrst uvwxy z";
958
959 static void
960 adjust_attr_string(int adjust)
961 {
962 int first = ((int) UChar(attr_test_string[0])) + adjust;
963 int last = first + LEN_ATTRSTRING;
964
965 if (first >= ' ' && last <= '~') { /* 32..126 */
966 int j, k;
967 for (j = 0, k = first; k <= last; ++j, ++k) {
968 attr_test_string[j] = k;
969 if (((k + 1 - first) % 5) == 0) {
970 ++j;
971 if (j < MAX_ATTRSTRING)
972 attr_test_string[j] = ' ';
973 }
974 }
975 while (j < MAX_ATTRSTRING)
976 attr_test_string[j++] = ' ';
977 attr_test_string[j] = '\0';
978 } else {
979 beep();
980 }
981 }
982
983 static int
984 show_attr(int row, int skip, chtype attr, const char *name)
985 {
986 int ncv = tigetnum("ncv");
987 chtype test = attr & ~A_ALTCHARSET;
988
989 mvprintw(row, 8, "%s mode:", name);
990 mvprintw(row, 24, "|");
991 if (skip)
992 printw("%*s", skip, " ");
993 attrset(attr);
994 /*
995 * If we're to write a string in the alternate character set, it is not
996 * sufficient to just set A_ALTCHARSET. We have to perform the mapping
997 * that corresponds. This is not needed for vt100-compatible devices
998 * because the acs_map[] is 1:1, but for PC-style devices such as Linux
999 * console, the acs_map[] is scattered about the range.
1000 *
1001 * The addch/addstr functions do not themselves do this mapping, since it
1002 * is possible to turn off the A_ALTCHARSET flag for the characters which
1003 * are added, and it would be an unexpected result to have the mapped
1004 * characters visible on the screen.
1005 */
1006 if (attr & A_ALTCHARSET) {
1007 const char *s;
1008 int ch;
1009
1010 for (s = attr_test_string; *s != '\0'; ++s) {
1011 ch = UChar(*s);
1012 addch(ch);
1013 }
1014 } else {
1015 addstr(attr_test_string);
1016 }
1017 attroff(attr);
1018 if (skip)
1019 printw("%*s", skip, " ");
1020 printw("|");
1021 if (test != A_NORMAL) {
1022 if (!(termattrs() & test)) {
1023 printw(" (N/A)");
1024 } else if (ncv > 0 && (getbkgd(stdscr) & A_COLOR)) {
1025 static const chtype table[] =
1026 {
1027 A_STANDOUT,
1028 A_UNDERLINE,
1029 A_REVERSE,
1030 A_BLINK,
1031 A_DIM,
1032 A_BOLD,
1033 A_INVIS,
1034 A_PROTECT,
1035 A_ALTCHARSET
1036 };
1037 unsigned n;
1038 bool found = FALSE;
1039 for (n = 0; n < SIZEOF(table); n++) {
1040 if ((table[n] & attr) != 0
1041 && ((1 << n) & ncv) != 0) {
1042 found = TRUE;
1043 break;
1044 }
1045 }
1046 if (found)
1047 printw(" (NCV)");
1048 }
1049 }
1050 return row + 2;
1051 }
1052
1053 static bool
1054 attr_getc(int *skip, int *fg, int *bg, int *ac)
1055 {
1056 int ch = Getchar();
1057
1058 if (isdigit(ch)) {
1059 *skip = (ch - '0');
1060 } else if (ch == CTRL('L')) {
1061 touchwin(stdscr);
1062 touchwin(curscr);
1063 wrefresh(curscr);
1064 } else {
1065 switch (ch) {
1066 case 'a':
1067 *ac = 0;
1068 break;
1069 case 'A':
1070 *ac = A_ALTCHARSET;
1071 break;
1072 case '<':
1073 adjust_attr_string(-1);
1074 break;
1075 case '>':
1076 adjust_attr_string(1);
1077 break;
1078 default:
1079 if (has_colors()) {
1080 switch (ch) {
1081 case 'f':
1082 *fg = (*fg + 1);
1083 break;
1084 case 'F':
1085 *fg = (*fg - 1);
1086 break;
1087 case 'b':
1088 *bg = (*bg + 1);
1089 break;
1090 case 'B':
1091 *bg = (*bg - 1);
1092 break;
1093 default:
1094 return FALSE;
1095 }
1096 if (*fg >= max_colors)
1097 *fg = 0;
1098 if (*fg < 0)
1099 *fg = max_colors - 1;
1100 if (*bg >= max_colors)
1101 *bg = 0;
1102 if (*bg < 0)
1103 *bg = max_colors - 1;
1104 }
1105 break;
1106 }
1107 }
1108 return TRUE;
1109 }
1110
1111 static void
1112 attr_test(void)
1113 /* test text attributes */
1114 {
1115 int n;
1116 int skip = tigetnum("xmc");
1117 int fg = COLOR_BLACK; /* color pair 0 is special */
1118 int bg = COLOR_BLACK;
1119 int ac = 0;
1120 bool *pairs = (bool *) calloc(max_pairs, sizeof(bool));
1121 pairs[0] = TRUE;
1122
1123 if (skip < 0)
1124 skip = 0;
1125
1126 n = skip; /* make it easy */
1127
1128 do {
1129 int row = 2;
1130 int normal = A_NORMAL | BLANK;
1131
1132 if (has_colors()) {
1133 int pair = (fg * max_colors) + bg;
1134 if (!pairs[pair]) {
1135 init_pair(pair, fg, bg);
1136 pairs[pair] = TRUE;
1137 }
1138 normal |= COLOR_PAIR(pair);
1139 }
1140 bkgd(normal);
1141 bkgdset(normal);
1142 erase();
1143
1144 box(stdscr, 0, 0);
1145 mvaddstr(0, 20, "Character attribute test display");
1146
1147 row = show_attr(row, n, ac | A_STANDOUT, "STANDOUT");
1148 row = show_attr(row, n, ac | A_REVERSE, "REVERSE");
1149 row = show_attr(row, n, ac | A_BOLD, "BOLD");
1150 row = show_attr(row, n, ac | A_UNDERLINE, "UNDERLINE");
1151 row = show_attr(row, n, ac | A_DIM, "DIM");
1152 row = show_attr(row, n, ac | A_BLINK, "BLINK");
1153 row = show_attr(row, n, ac | A_PROTECT, "PROTECT");
1154 row = show_attr(row, n, ac | A_INVIS, "INVISIBLE");
1155 row = show_attr(row, n, ac | A_NORMAL, "NORMAL");
1156
1157 mvprintw(row, 8,
1158 "This terminal does %shave the magic-cookie glitch",
1159 tigetnum("xmc") > -1 ? "" : "not ");
1160 mvprintw(row + 1, 8,
1161 "Enter a digit to set gaps on each side of displayed attributes");
1162 mvprintw(row + 2, 8,
1163 "^L repaints, </> shifts, ");
1164 if (has_colors())
1165 printw("f/F/b/F toggle color (now %d/%d), a/A ACS (%d)",
1166 fg, bg, ac != 0);
1167 else
1168 printw("a/A ACS (%d)", ac != 0);
1169
1170 refresh();
1171 } while (attr_getc(&n, &fg, &bg, &ac));
1172
1173 free((char *) pairs);
1174 bkgdset(A_NORMAL | BLANK);
1175 erase();
1176 endwin();
1177 }
1178
1179 /****************************************************************************
1180 *
1181 * Color support tests
1182 *
1183 ****************************************************************************/
1184
1185 static NCURSES_CONST char *the_color_names[] =
1186 {
1187 "black",
1188 "red",
1189 "green",
1190 "yellow",
1191 "blue",
1192 "magenta",
1193 "cyan",
1194 "white",
1195 "BLACK",
1196 "RED",
1197 "GREEN",
1198 "YELLOW",
1199 "BLUE",
1200 "MAGENTA",
1201 "CYAN",
1202 "WHITE"
1203 };
1204
1205 static void
1206 show_color_name(int y, int x, int color)
1207 {
1208 if (max_colors > 8)
1209 mvprintw(y, x, "%02d ", color);
1210 else
1211 mvaddstr(y, x, the_color_names[color]);
1212 }
1213
1214 static void
1215 color_test(void)
1216 /* generate a color test pattern */
1217 {
1218 int i;
1219 int base, top, width;
1220 const char *hello;
1221
1222 refresh();
1223 (void) printw("There are %d color pairs\n", COLOR_PAIRS);
1224
1225 width = (max_colors > 8) ? 4 : 8;
1226 hello = (max_colors > 8) ? "Test" : "Hello";
1227
1228 for (base = 0; base < 2; base++) {
1229 top = (max_colors > 8) ? 0 : base * (max_colors + 3);
1230 clrtobot();
1231 (void) mvprintw(top + 1, 0,
1232 "%dx%d matrix of foreground/background colors, bright *%s*\n",
1233 max_colors, max_colors,
1234 base ? "on" : "off");
1235 for (i = 0; i < max_colors; i++)
1236 show_color_name(top + 2, (i + 1) * width, i);
1237 for (i = 0; i < max_colors; i++)
1238 show_color_name(top + 3 + i, 0, i);
1239 for (i = 1; i < max_pairs; i++) {
1240 init_pair(i, i % max_colors, i / max_colors);
1241 attron((attr_t) COLOR_PAIR(i));
1242 if (base)
1243 attron((attr_t) A_BOLD);
1244 mvaddstr(top + 3 + (i / max_colors), (i % max_colors + 1) *
1245 width, hello);
1246 attrset(A_NORMAL);
1247 }
1248 if ((max_colors > 8) || base)
1249 Pause();
1250 }
1251
1252 erase();
1253 endwin();
1254 }
1255
1256 static void
1257 change_color(int current, int field, int value, int usebase)
1258 {
1259 short red, green, blue;
1260
1261 if (usebase)
1262 color_content(current, &red, &green, &blue);
1263 else
1264 red = green = blue = 0;
1265
1266 switch (field) {
1267 case 0:
1268 red += value;
1269 break;
1270 case 1:
1271 green += value;
1272 break;
1273 case 2:
1274 blue += value;
1275 break;
1276 }
1277
1278 if (init_color(current, red, green, blue) == ERR)
1279 beep();
1280 }
1281
1282 static void
1283 color_edit(void)
1284 /* display the color test pattern, without trying to edit colors */
1285 {
1286 int i, this_c = 0, value = 0, current = 0, field = 0;
1287 int last_c;
1288
1289 refresh();
1290
1291 for (i = 0; i < max_colors; i++)
1292 init_pair(i, COLOR_WHITE, i);
1293
1294 mvprintw(LINES - 2, 0, "Number: %d", value);
1295
1296 do {
1297 short red, green, blue;
1298
1299 attron(A_BOLD);
1300 mvaddstr(0, 20, "Color RGB Value Editing");
1301 attroff(A_BOLD);
1302
1303 for (i = 0; i < max_colors; i++) {
1304 mvprintw(2 + i, 0, "%c %-8s:",
1305 (i == current ? '>' : ' '),
1306 (i < (int) SIZEOF(the_color_names)
1307 ? the_color_names[i] : ""));
1308 attrset(COLOR_PAIR(i));
1309 addstr(" ");
1310 attrset(A_NORMAL);
1311
1312 /*
1313 * Note: this refresh should *not* be necessary! It works around
1314 * a bug in attribute handling that apparently causes the A_NORMAL
1315 * attribute sets to interfere with the actual emission of the
1316 * color setting somehow. This needs to be fixed.
1317 */
1318 refresh();
1319
1320 color_content(i, &red, &green, &blue);
1321 addstr(" R = ");
1322 if (current == i && field == 0)
1323 attron(A_STANDOUT);
1324 printw("%04d", red);
1325 if (current == i && field == 0)
1326 attrset(A_NORMAL);
1327 addstr(", G = ");
1328 if (current == i && field == 1)
1329 attron(A_STANDOUT);
1330 printw("%04d", green);
1331 if (current == i && field == 1)
1332 attrset(A_NORMAL);
1333 addstr(", B = ");
1334 if (current == i && field == 2)
1335 attron(A_STANDOUT);
1336 printw("%04d", blue);
1337 if (current == i && field == 2)
1338 attrset(A_NORMAL);
1339 attrset(A_NORMAL);
1340 addstr(")");
1341 }
1342
1343 mvaddstr(max_colors + 3, 0,
1344 "Use up/down to select a color, left/right to change fields.");
1345 mvaddstr(max_colors + 4, 0,
1346 "Modify field by typing nnn=, nnn-, or nnn+. ? for help.");
1347
1348 move(2 + current, 0);
1349
1350 last_c = this_c;
1351 this_c = Getchar();
1352 if (isdigit(this_c) && !isdigit(last_c))
1353 value = 0;
1354
1355 switch (this_c) {
1356 case KEY_UP:
1357 current = (current == 0 ? (max_colors - 1) : current - 1);
1358 break;
1359
1360 case KEY_DOWN:
1361 current = (current == (max_colors - 1) ? 0 : current + 1);
1362 break;
1363
1364 case KEY_RIGHT:
1365 field = (field == 2 ? 0 : field + 1);
1366 break;
1367
1368 case KEY_LEFT:
1369 field = (field == 0 ? 2 : field - 1);
1370 break;
1371
1372 case '0':
1373 case '1':
1374 case '2':
1375 case '3':
1376 case '4':
1377 case '5':
1378 case '6':
1379 case '7':
1380 case '8':
1381 case '9':
1382 value = value * 10 + (this_c - '0');
1383 break;
1384
1385 case '+':
1386 change_color(current, field, value, 1);
1387 break;
1388
1389 case '-':
1390 change_color(current, field, -value, 1);
1391 break;
1392
1393 case '=':
1394 change_color(current, field, value, 0);
1395 break;
1396
1397 case '?':
1398 erase();
1399 P(" RGB Value Editing Help");
1400 P("");
1401 P("You are in the RGB value editor. Use the arrow keys to select one of");
1402 P("the fields in one of the RGB triples of the current colors; the one");
1403 P("currently selected will be reverse-video highlighted.");
1404 P("");
1405 P("To change a field, enter the digits of the new value; they are echoed");
1406 P("as entered. Finish by typing `='. The change will take effect instantly.");
1407 P("To increment or decrement a value, use the same procedure, but finish");
1408 P("with a `+' or `-'.");
1409 P("");
1410 P("To quit, do `x' or 'q'");
1411
1412 Pause();
1413 erase();
1414 break;
1415
1416 case 'x':
1417 case 'q':
1418 break;
1419
1420 default:
1421 beep();
1422 break;
1423 }
1424 mvprintw(LINES - 2, 0, "Number: %d", value);
1425 clrtoeol();
1426 } while
1427 (this_c != 'x' && this_c != 'q');
1428
1429 erase();
1430 endwin();
1431 }
1432
1433 /****************************************************************************
1434 *
1435 * Soft-key label test
1436 *
1437 ****************************************************************************/
1438
1439 #define SLK_HELP 17
1440 #define SLK_WORK (SLK_HELP + 3)
1441
1442 static void
1443 slk_help(void)
1444 {
1445 static const char *table[] =
1446 {
1447 "Available commands are:"
1448 ,""
1449 ,"^L -- repaint this message and activate soft keys"
1450 ,"a/d -- activate/disable soft keys"
1451 ,"c -- set centered format for labels"
1452 ,"l -- set left-justified format for labels"
1453 ,"r -- set right-justified format for labels"
1454 ,"[12345678] -- set label; labels are numbered 1 through 8"
1455 ,"e -- erase stdscr (should not erase labels)"
1456 ,"s -- test scrolling of shortened screen"
1457 #if HAVE_SLK_COLOR
1458 ,"F/B -- cycle through foreground/background colors"
1459 #endif
1460 ,"x, q -- return to main menu"
1461 ,""
1462 ,"Note: if activating the soft keys causes your terminal to scroll up"
1463 ,"one line, your terminal auto-scrolls when anything is written to the"
1464 ,"last screen position. The ncurses code does not yet handle this"
1465 ,"gracefully."
1466 };
1467 unsigned j;
1468
1469 move(2, 0);
1470 for (j = 0; j < SIZEOF(table); ++j) {
1471 P(table[j]);
1472 }
1473 refresh();
1474 }
1475
1476 static void
1477 slk_test(void)
1478 /* exercise the soft keys */
1479 {
1480 int c, fmt = 1;
1481 char buf[9];
1482 char *s;
1483 #if HAVE_SLK_COLOR
1484 short fg = COLOR_BLACK;
1485 short bg = COLOR_WHITE;
1486 bool new_color = FALSE;
1487 #endif
1488
1489 c = CTRL('l');
1490 #if HAVE_SLK_COLOR
1491 if (has_colors()) {
1492 new_color = TRUE;
1493 }
1494 #endif
1495
1496 do {
1497 #if HAVE_SLK_COLOR
1498 if (new_color) {
1499 init_pair(1, bg, fg);
1500 slk_color(1);
1501 new_color = FALSE;
1502 mvprintw(SLK_WORK, 0, "Colors %d/%d\n", fg, bg);
1503 refresh();
1504 }
1505 #endif
1506 move(0, 0);
1507 switch (c) {
1508 case CTRL('l'):
1509 erase();
1510 attron(A_BOLD);
1511 mvaddstr(0, 20, "Soft Key Exerciser");
1512 attroff(A_BOLD);
1513
1514 slk_help();
1515 /* fall through */
1516
1517 case 'a':
1518 slk_restore();
1519 break;
1520
1521 case 'e':
1522 wclear(stdscr);
1523 break;
1524
1525 case 's':
1526 mvprintw(SLK_WORK, 0, "Press Q to stop the scrolling-test: ");
1527 while ((c = Getchar()) != 'Q' && (c != ERR))
1528 addch((chtype) c);
1529 break;
1530
1531 case 'd':
1532 slk_clear();
1533 break;
1534
1535 case 'l':
1536 fmt = 0;
1537 break;
1538
1539 case 'c':
1540 fmt = 1;
1541 break;
1542
1543 case 'r':
1544 fmt = 2;
1545 break;
1546
1547 case '1':
1548 case '2':
1549 case '3':
1550 case '4':
1551 case '5':
1552 case '6':
1553 case '7':
1554 case '8':
1555 (void) mvaddstr(SLK_WORK, 0, "Please enter the label value: ");
1556 strcpy(buf, "");
1557 if ((s = slk_label(c - '0')) != 0) {
1558 strncpy(buf, s, 8);
1559 }
1560 wGetstring(stdscr, buf, 8);
1561 slk_set((c - '0'), buf, fmt);
1562 slk_refresh();
1563 move(SLK_WORK, 0);
1564 clrtobot();
1565 break;
1566
1567 case 'x':
1568 case 'q':
1569 goto done;
1570
1571 #if HAVE_SLK_COLOR
1572 case 'F':
1573 if (has_colors()) {
1574 fg = (fg + 1) % max_colors;
1575 new_color = TRUE;
1576 }
1577 break;
1578 case 'B':
1579 if (has_colors()) {
1580 bg = (bg + 1) % max_colors;
1581 new_color = TRUE;
1582 }
1583 break;
1584 #endif
1585
1586 default:
1587 beep();
1588 }
1589 } while
1590 ((c = Getchar()) != EOF);
1591
1592 done:
1593 erase();
1594 endwin();
1595 }
1596
1597 #if USE_WIDEC_SUPPORT
1598 static void
1599 wide_slk_test(void)
1600 /* exercise the soft keys */
1601 {
1602 int c, fmt = 1;
1603 wchar_t buf[9];
1604 char *s;
1605 short fg = COLOR_BLACK;
1606 short bg = COLOR_WHITE;
1607 bool new_color = FALSE;
1608
1609 c = CTRL('l');
1610 if (has_colors()) {
1611 new_color = TRUE;
1612 }
1613 do {
1614 if (new_color) {
1615 init_pair(1, bg, fg);
1616 slk_color(1);
1617 new_color = FALSE;
1618 mvprintw(SLK_WORK, 0, "Colors %d/%d\n", fg, bg);
1619 refresh();
1620 }
1621 move(0, 0);
1622 switch (c) {
1623 case CTRL('l'):
1624 erase();
1625 attr_on(WA_BOLD, NULL);
1626 mvaddstr(0, 20, "Soft Key Exerciser");
1627 attr_off(WA_BOLD, NULL);
1628
1629 slk_help();
1630 /* fall through */
1631
1632 case 'a':
1633 slk_restore();
1634 break;
1635
1636 case 'e':
1637 wclear(stdscr);
1638 break;
1639
1640 case 's':
1641 mvprintw(SLK_WORK, 0, "Press Q to stop the scrolling-test: ");
1642 while ((c = Getchar()) != 'Q' && (c != ERR))
1643 addch((chtype) c);
1644 break;
1645
1646 case 'd':
1647 slk_clear();
1648 break;
1649
1650 case 'l':
1651 fmt = 0;
1652 break;
1653
1654 case 'c':
1655 fmt = 1;
1656 break;
1657
1658 case 'r':
1659 fmt = 2;
1660 break;
1661
1662 case '1':
1663 case '2':
1664 case '3':
1665 case '4':
1666 case '5':
1667 case '6':
1668 case '7':
1669 case '8':
1670 (void) mvaddstr(SLK_WORK, 0, "Please enter the label value: ");
1671 *buf = 0;
1672 if ((s = slk_label(c - '0')) != 0) {
1673 int j;
1674 for (j = 0; j < 8; ++j) {
1675 if ((buf[j] = UChar(s[j])) == 0)
1676 break;
1677 }
1678 buf[j] = 0;
1679 }
1680 wGet_wstring(stdscr, buf, 8);
1681 slk_wset((c - '0'), buf, fmt);
1682 slk_refresh();
1683 move(SLK_WORK, 0);
1684 clrtobot();
1685 break;
1686
1687 case 'x':
1688 case 'q':
1689 goto done;
1690
1691 case 'F':
1692 if (has_colors()) {
1693 fg = (fg + 1) % max_colors;
1694 new_color = TRUE;
1695 }
1696 break;
1697 case 'B':
1698 if (has_colors()) {
1699 bg = (bg + 1) % max_colors;
1700 new_color = TRUE;
1701 }
1702 break;
1703
1704 default:
1705 beep();
1706 }
1707 } while
1708 ((c = Getchar()) != EOF);
1709
1710 done:
1711 erase();
1712 endwin();
1713 }
1714 #endif
1715
1716 /****************************************************************************
1717 *
1718 * Alternate character-set stuff
1719 *
1720 ****************************************************************************/
1721
1722 /* ISO 6429: codes 0x80 to 0x9f may be control characters that cause the
1723 * terminal to perform functions. The remaining codes can be graphic.
1724 */
1725 static void
1726 show_upper_chars(int first)
1727 {
1728 bool C1 = (first == 128);
1729 int code;
1730 int last = first + 31;
1731 int reply;
1732
1733 erase();
1734 attron(A_BOLD);
1735 mvprintw(0, 20, "Display of %s Character Codes %d to %d",
1736 C1 ? "C1" : "GR", first, last);
1737 attroff(A_BOLD);
1738 refresh();
1739
1740 for (code = first; code <= last; code++) {
1741 int row = 4 + ((code - first) % 16);
1742 int col = ((code - first) / 16) * COLS / 2;
1743 char tmp[80];
1744 sprintf(tmp, "%3d (0x%x)", code, code);
1745 mvprintw(row, col, "%*s: ", COLS / 4, tmp);
1746 if (C1)
1747 nodelay(stdscr, TRUE);
1748 echochar(code);
1749 if (C1) {
1750 /* (yes, this _is_ crude) */
1751 while ((reply = Getchar()) != ERR) {
1752 addch(reply);
1753 napms(10);
1754 }
1755 nodelay(stdscr, FALSE);
1756 }
1757 }
1758 }
1759
1760 static void
1761 show_box_chars(void)
1762 {
1763 erase();
1764 attron(A_BOLD);
1765 mvaddstr(0, 20, "Display of the ACS Line-Drawing Set");
1766 attroff(A_BOLD);
1767 refresh();
1768 box(stdscr, 0, 0);
1769 /* *INDENT-OFF* */
1770 mvhline(LINES / 2, 0, ACS_HLINE, COLS);
1771 mvvline(0, COLS / 2, ACS_VLINE, LINES);
1772 mvaddch(0, COLS / 2, ACS_TTEE);
1773 mvaddch(LINES / 2, COLS / 2, ACS_PLUS);
1774 mvaddch(LINES - 1, COLS / 2, ACS_BTEE);
1775 mvaddch(LINES / 2, 0, ACS_LTEE);
1776 mvaddch(LINES / 2, COLS - 1, ACS_RTEE);
1777 /* *INDENT-ON* */
1778
1779 }
1780
1781 static int
1782 show_1_acs(int n, const char *name, chtype code)
1783 {
1784 const int height = 16;
1785 int row = 4 + (n % height);
1786 int col = (n / height) * COLS / 2;
1787 mvprintw(row, col, "%*s : ", COLS / 4, name);
1788 addch(code);
1789 return n + 1;
1790 }
1791
1792 static void
1793 show_acs_chars(void)
1794 /* display the ACS character set */
1795 {
1796 int n;
1797
1798 #define BOTH(name) #name, name
1799
1800 erase();
1801 attron(A_BOLD);
1802 mvaddstr(0, 20, "Display of the ACS Character Set");
1803 attroff(A_BOLD);
1804 refresh();
1805
1806 n = show_1_acs(0, BOTH(ACS_ULCORNER));
1807 n = show_1_acs(n, BOTH(ACS_URCORNER));
1808 n = show_1_acs(n, BOTH(ACS_LLCORNER));
1809 n = show_1_acs(n, BOTH(ACS_LRCORNER));
1810
1811 n = show_1_acs(n, BOTH(ACS_LTEE));
1812 n = show_1_acs(n, BOTH(ACS_RTEE));
1813 n = show_1_acs(n, BOTH(ACS_TTEE));
1814 n = show_1_acs(n, BOTH(ACS_BTEE));
1815
1816 n = show_1_acs(n, BOTH(ACS_HLINE));
1817 n = show_1_acs(n, BOTH(ACS_VLINE));
1818
1819 n = show_1_acs(n, BOTH(ACS_LARROW));
1820 n = show_1_acs(n, BOTH(ACS_RARROW));
1821 n = show_1_acs(n, BOTH(ACS_UARROW));
1822 n = show_1_acs(n, BOTH(ACS_DARROW));
1823
1824 n = show_1_acs(n, BOTH(ACS_BLOCK));
1825 n = show_1_acs(n, BOTH(ACS_BOARD));
1826 n = show_1_acs(n, BOTH(ACS_LANTERN));
1827 n = show_1_acs(n, BOTH(ACS_BULLET));
1828 n = show_1_acs(n, BOTH(ACS_CKBOARD));
1829 n = show_1_acs(n, BOTH(ACS_DEGREE));
1830 n = show_1_acs(n, BOTH(ACS_DIAMOND));
1831 n = show_1_acs(n, BOTH(ACS_PLMINUS));
1832 n = show_1_acs(n, BOTH(ACS_PLUS));
1833
1834 n = show_1_acs(n, BOTH(ACS_GEQUAL));
1835 n = show_1_acs(n, BOTH(ACS_NEQUAL));
1836 n = show_1_acs(n, BOTH(ACS_LEQUAL));
1837
1838 n = show_1_acs(n, BOTH(ACS_STERLING));
1839 n = show_1_acs(n, BOTH(ACS_PI));
1840 n = show_1_acs(n, BOTH(ACS_S1));
1841 n = show_1_acs(n, BOTH(ACS_S3));
1842 n = show_1_acs(n, BOTH(ACS_S7));
1843 n = show_1_acs(n, BOTH(ACS_S9));
1844 }
1845
1846 static void
1847 acs_display(void)
1848 {
1849 int c = 'a';
1850
1851 do {
1852 switch (c) {
1853 case 'a':
1854 show_acs_chars();
1855 break;
1856 case 'b':
1857 show_box_chars();
1858 break;
1859 case '0':
1860 case '1':
1861 case '2':
1862 case '3':
1863 show_upper_chars((c - '0') * 32 + 128);
1864 break;
1865 }
1866 mvprintw(LINES - 3, 0,
1867 "Note: ANSI terminals may not display C1 characters.");
1868 mvprintw(LINES - 2, 0,
1869 "Select: a=ACS, b=box, 0=C1, 1,2,3=GR characters, q=quit");
1870 refresh();
1871 } while ((c = Getchar()) != 'x' && c != 'q');
1872
1873 Pause();
1874 erase();
1875 endwin();
1876 }
1877
1878 #if USE_WIDEC_SUPPORT
1879 static void
1880 show_upper_widechars(int first, int repeat)
1881 {
1882 cchar_t temp;
1883 wchar_t code;
1884 int last = first + 31;
1885
1886 erase();
1887 attron(A_BOLD);
1888 mvprintw(0, 20, "Display of Character Codes %d to %d", first, last);
1889 attroff(A_BOLD);
1890
1891 for (code = first; code <= last; code++) {
1892 int row = 4 + ((code - first) % 16);
1893 int col = ((code - first) / 16) * COLS / 2;
1894 wchar_t codes[10];
1895 attr_t attrs = A_NORMAL;
1896 char tmp[80];
1897 int count = repeat;
1898
1899 memset(&codes, 0, sizeof(codes));
1900 codes[0] = code;
1901 sprintf(tmp, "%3ld (0x%lx)", (long) code, (long) code);
1902 mvprintw(row, col, "%*s: ", COLS / 4, tmp);
1903 setcchar(&temp, codes, attrs, 0, 0);
1904 do {
1905 /*
1906 * This could use add_wch(), but is done for comparison with the
1907 * normal 'f' test (and to make a test-case for echo_wchar()).
1908 * The screen will flicker because the erase() at the top of the
1909 * function is met by the builtin refresh() in echo_wchar().
1910 */
1911 echo_wchar(&temp);
1912 } while (--count > 0);
1913 }
1914 }
1915
1916 static int
1917 show_1_wacs(int n, const char *name, const cchar_t * code)
1918 {
1919 const int height = 16;
1920 int row = 4 + (n % height);
1921 int col = (n / height) * COLS / 2;
1922 mvprintw(row, col, "%*s : ", COLS / 4, name);
1923 add_wchnstr(code, 1);
1924 return n + 1;
1925 }
1926
1927 static void
1928 show_wacs_chars(void)
1929 /* display the wide-ACS character set */
1930 {
1931 int n;
1932
1933 /*#define BOTH2(name) #name, &(name) */
1934 #define BOTH2(name) #name, name
1935
1936 erase();
1937 attron(A_BOLD);
1938 mvaddstr(0, 20, "Display of the Wide-ACS Character Set");
1939 attroff(A_BOLD);
1940 refresh();
1941
1942 n = show_1_wacs(0, BOTH2(WACS_ULCORNER));
1943 n = show_1_wacs(n, BOTH2(WACS_URCORNER));
1944 n = show_1_wacs(n, BOTH2(WACS_LLCORNER));
1945 n = show_1_wacs(n, BOTH2(WACS_LRCORNER));
1946
1947 n = show_1_wacs(n, BOTH2(WACS_LTEE));
1948 n = show_1_wacs(n, BOTH2(WACS_RTEE));
1949 n = show_1_wacs(n, BOTH2(WACS_TTEE));
1950 n = show_1_wacs(n, BOTH2(WACS_BTEE));
1951
1952 n = show_1_wacs(n, BOTH2(WACS_HLINE));
1953 n = show_1_wacs(n, BOTH2(WACS_VLINE));
1954
1955 n = show_1_wacs(n, BOTH2(WACS_LARROW));
1956 n = show_1_wacs(n, BOTH2(WACS_RARROW));
1957 n = show_1_wacs(n, BOTH2(WACS_UARROW));
1958 n = show_1_wacs(n, BOTH2(WACS_DARROW));
1959
1960 n = show_1_wacs(n, BOTH2(WACS_BLOCK));
1961 n = show_1_wacs(n, BOTH2(WACS_BOARD));
1962 n = show_1_wacs(n, BOTH2(WACS_LANTERN));
1963 n = show_1_wacs(n, BOTH2(WACS_BULLET));
1964 n = show_1_wacs(n, BOTH2(WACS_CKBOARD));
1965 n = show_1_wacs(n, BOTH2(WACS_DEGREE));
1966 n = show_1_wacs(n, BOTH2(WACS_DIAMOND));
1967 n = show_1_wacs(n, BOTH2(WACS_PLMINUS));
1968 n = show_1_wacs(n, BOTH2(WACS_PLUS));
1969
1970 #ifdef CURSES_WACS_ARRAY
1971 n = show_1_wacs(n, BOTH2(WACS_GEQUAL));
1972 n = show_1_wacs(n, BOTH2(WACS_NEQUAL));
1973 n = show_1_wacs(n, BOTH2(WACS_LEQUAL));
1974
1975 n = show_1_wacs(n, BOTH2(WACS_STERLING));
1976 n = show_1_wacs(n, BOTH2(WACS_PI));
1977 n = show_1_wacs(n, BOTH2(WACS_S1));
1978 n = show_1_wacs(n, BOTH2(WACS_S3));
1979 n = show_1_wacs(n, BOTH2(WACS_S7));
1980 n = show_1_wacs(n, BOTH2(WACS_S9));
1981 #endif
1982 }
1983
1984 static void
1985 show_wbox_chars(void)
1986 {
1987 erase();
1988 attron(A_BOLD);
1989 mvaddstr(0, 20, "Display of the Wide-ACS Line-Drawing Set");
1990 attroff(A_BOLD);
1991 refresh();
1992 box_set(stdscr, 0, 0);
1993 /* *INDENT-OFF* */
1994 mvhline_set(LINES / 2, 0, WACS_HLINE, COLS);
1995 mvvline_set(0, COLS / 2, WACS_VLINE, LINES);
1996 mvadd_wch(0, COLS / 2, WACS_TTEE);
1997 mvadd_wch(LINES / 2, COLS / 2, WACS_PLUS);
1998 mvadd_wch(LINES - 1, COLS / 2, WACS_BTEE);
1999 mvadd_wch(LINES / 2, 0, WACS_LTEE);
2000 mvadd_wch(LINES / 2, COLS - 1, WACS_RTEE);
2001 /* *INDENT-ON* */
2002
2003 }
2004
2005 static int
2006 show_2_wacs(int n, const char *name, const char *code)
2007 {
2008 const int height = 16;
2009 int row = 4 + (n % height);
2010 int col = (n / height) * COLS / 2;
2011 char temp[80];
2012
2013 mvprintw(row, col, "%*s : ", COLS / 4, name);
2014 addstr(strcpy(temp, code));
2015 return n + 1;
2016 }
2017
2018 static void
2019 show_utf8_chars(void)
2020 /* display the wide-ACS character set */
2021 {
2022 int n;
2023
2024 erase();
2025 attron(A_BOLD);
2026 mvaddstr(0, 20, "Display of the Wide-ACS Character Set");
2027 attroff(A_BOLD);
2028 refresh();
2029 /* *INDENT-OFF* */
2030 n = show_2_wacs(0, "WACS_ULCORNER", "\342\224\214");
2031 n = show_2_wacs(n, "WACS_URCORNER", "\342\224\220");
2032 n = show_2_wacs(n, "WACS_LLCORNER", "\342\224\224");
2033 n = show_2_wacs(n, "WACS_LRCORNER", "\342\224\230");
2034
2035 n = show_2_wacs(n, "WACS_LTEE", "\342\224\234");
2036 n = show_2_wacs(n, "WACS_RTEE", "\342\224\244");
2037 n = show_2_wacs(n, "WACS_TTEE", "\342\224\254");
2038 n = show_2_wacs(n, "WACS_BTEE", "\342\224\264");
2039
2040 n = show_2_wacs(n, "WACS_HLINE", "\342\224\200");
2041 n = show_2_wacs(n, "WACS_VLINE", "\342\224\202");
2042
2043 n = show_2_wacs(n, "WACS_LARROW", "\342\206\220");
2044 n = show_2_wacs(n, "WACS_RARROW", "\342\206\222");
2045 n = show_2_wacs(n, "WACS_UARROW", "\342\206\221");
2046 n = show_2_wacs(n, "WACS_DARROW", "\342\206\223");
2047
2048 n = show_2_wacs(n, "WACS_BLOCK", "\342\226\256");
2049 n = show_2_wacs(n, "WACS_BOARD", "\342\226\222");
2050 n = show_2_wacs(n, "WACS_LANTERN", "\342\230\203");
2051 n = show_2_wacs(n, "WACS_BULLET", "\302\267");
2052 n = show_2_wacs(n, "WACS_CKBOARD", "\342\226\222");
2053 n = show_2_wacs(n, "WACS_DEGREE", "\302\260");
2054 n = show_2_wacs(n, "WACS_DIAMOND", "\342\227\206");
2055 n = show_2_wacs(n, "WACS_PLMINUS", "\302\261");
2056 n = show_2_wacs(n, "WACS_PLUS", "\342\224\274");
2057 n = show_2_wacs(n, "WACS_GEQUAL", "\342\211\245");
2058 n = show_2_wacs(n, "WACS_NEQUAL", "\342\211\240");
2059 n = show_2_wacs(n, "WACS_LEQUAL", "\342\211\244");
2060
2061 n = show_2_wacs(n, "WACS_STERLING", "\302\243");
2062 n = show_2_wacs(n, "WACS_PI", "\317\200");
2063 n = show_2_wacs(n, "WACS_S1", "\342\216\272");
2064 n = show_2_wacs(n, "WACS_S3", "\342\216\273");
2065 n = show_2_wacs(n, "WACS_S7", "\342\216\274");
2066 n = show_2_wacs(n, "WACS_S9", "\342\216\275");
2067 /* *INDENT-ON* */
2068
2069 }
2070
2071 static void
2072 wide_acs_display(void)
2073 {
2074 int c = 'a';
2075 int digit = 0;
2076 int repeat = 0;
2077
2078 do {
2079 switch (c) {
2080 case 'a':
2081 show_wacs_chars();
2082 break;
2083 case 'b':
2084 show_wbox_chars();
2085 break;
2086 case 'u':
2087 show_utf8_chars();
2088 break;
2089 default:
2090 if (isdigit(c))
2091 digit = (c - '0');
2092 else if (c == '+')
2093 ++digit;
2094 else if (c == '-' && digit > 0)
2095 --digit;
2096 else if (c == '>')
2097 ++repeat;
2098 else if (c == '<' && repeat > 0)
2099 --repeat;
2100 else {
2101 beep();
2102 break;
2103 }
2104 show_upper_widechars(digit * 32 + 128, repeat);
2105 break;
2106 }
2107 mvprintw(LINES - 2, 0,
2108 "Select: a WACS, b box, u UTF-8, 0-9,+/- non-ASCII, </> repeat, q=quit");
2109 refresh();
2110 } while ((c = Getchar()) != 'x' && c != 'q');
2111
2112 Pause();
2113 erase();
2114 endwin();
2115 }
2116
2117 #endif
2118
2119 /*
2120 * Graphic-rendition test (adapted from vttest)
2121 */
2122 static void
2123 test_sgr_attributes(void)
2124 {
2125 int pass;
2126
2127 for (pass = 0; pass < 2; pass++) {
2128 int normal = ((pass == 0 ? A_NORMAL : A_REVERSE)) | BLANK;
2129
2130 /* Use non-default colors if possible to exercise bce a little */
2131 if (has_colors()) {
2132 init_pair(1, COLOR_WHITE, COLOR_BLUE);
2133 normal |= COLOR_PAIR(1);
2134 }
2135 bkgdset(normal);
2136 erase();
2137 mvprintw(1, 20, "Graphic rendition test pattern:");
2138
2139 mvprintw(4, 1, "vanilla");
2140
2141 #define set_sgr(mask) bkgdset((normal^(mask)));
2142 set_sgr(A_BOLD);
2143 mvprintw(4, 40, "bold");
2144
2145 set_sgr(A_UNDERLINE);
2146 mvprintw(6, 6, "underline");
2147
2148 set_sgr(A_BOLD | A_UNDERLINE);
2149 mvprintw(6, 45, "bold underline");
2150
2151 set_sgr(A_BLINK);
2152 mvprintw(8, 1, "blink");
2153
2154 set_sgr(A_BLINK | A_BOLD);
2155 mvprintw(8, 40, "bold blink");
2156
2157 set_sgr(A_UNDERLINE | A_BLINK);
2158 mvprintw(10, 6, "underline blink");
2159
2160 set_sgr(A_BOLD | A_UNDERLINE | A_BLINK);
2161 mvprintw(10, 45, "bold underline blink");
2162
2163 set_sgr(A_REVERSE);
2164 mvprintw(12, 1, "negative");
2165
2166 set_sgr(A_BOLD | A_REVERSE);
2167 mvprintw(12, 40, "bold negative");
2168
2169 set_sgr(A_UNDERLINE | A_REVERSE);
2170 mvprintw(14, 6, "underline negative");
2171
2172 set_sgr(A_BOLD | A_UNDERLINE | A_REVERSE);
2173 mvprintw(14, 45, "bold underline negative");
2174
2175 set_sgr(A_BLINK | A_REVERSE);
2176 mvprintw(16, 1, "blink negative");
2177
2178 set_sgr(A_BOLD | A_BLINK | A_REVERSE);
2179 mvprintw(16, 40, "bold blink negative");
2180
2181 set_sgr(A_UNDERLINE | A_BLINK | A_REVERSE);
2182 mvprintw(18, 6, "underline blink negative");
2183
2184 set_sgr(A_BOLD | A_UNDERLINE | A_BLINK | A_REVERSE);
2185 mvprintw(18, 45, "bold underline blink negative");
2186
2187 bkgdset(normal);
2188 mvprintw(LINES - 2, 1, "%s background. ", pass == 0 ? "Dark" :
2189 "Light");
2190 clrtoeol();
2191 Pause();
2192 }
2193
2194 bkgdset(A_NORMAL | BLANK);
2195 erase();
2196 endwin();
2197 }
2198
2199 /****************************************************************************
2200 *
2201 * Windows and scrolling tester.
2202 *
2203 ****************************************************************************/
2204
2205 #define BOTLINES 4 /* number of line stolen from screen bottom */
2206
2207 typedef struct {
2208 int y, x;
2209 } pair;
2210
2211 #define FRAME struct frame
2212 FRAME
2213 {
2214 FRAME *next, *last;
2215 bool do_scroll;
2216 bool do_keypad;
2217 WINDOW *wind;
2218 };
2219
2220 #ifdef NCURSES_VERSION
2221 #define keypad_active(win) (win)->_use_keypad
2222 #define scroll_active(win) (win)->_scroll
2223 #else
2224 #define keypad_active(win) FALSE
2225 #define scroll_active(win) FALSE
2226 #endif
2227
2228 /* We need to know if these flags are actually set, so don't look in FRAME.
2229 * These names are known to work with SVr4 curses as well as ncurses. The
2230 * _use_keypad name does not work with Solaris 8.
2231 */
2232 static bool
2233 HaveKeypad(FRAME * curp)
2234 {
2235 WINDOW *win = (curp ? curp->wind : stdscr);
2236 return keypad_active(win);
2237 }
2238
2239 static bool
2240 HaveScroll(FRAME * curp)
2241 {
2242 WINDOW *win = (curp ? curp->wind : stdscr);
2243 return scroll_active(win);
2244 }
2245
2246 static void
2247 newwin_legend(FRAME * curp)
2248 {
2249 static const struct {
2250 const char *msg;
2251 int code;
2252 } legend[] = {
2253 {
2254 "^C = create window", 0
2255 },
2256 {
2257 "^N = next window", 0
2258 },
2259 {
2260 "^P = previous window", 0
2261 },
2262 {
2263 "^F = scroll forward", 0
2264 },
2265 {
2266 "^B = scroll backward", 0
2267 },
2268 {
2269 "^K = keypad(%s)", 1
2270 },
2271 {
2272 "^S = scrollok(%s)", 2
2273 },
2274 {
2275 "^W = save window to file", 0
2276 },
2277 {
2278 "^R = restore window", 0
2279 },
2280 #if HAVE_WRESIZE
2281 {
2282 "^X = resize", 0
2283 },
2284 #endif
2285 {
2286 "^Q%s = exit", 3
2287 }
2288 };
2289 size_t n;
2290 int x;
2291 bool do_keypad = HaveKeypad(curp);
2292 bool do_scroll = HaveScroll(curp);
2293 char buf[BUFSIZ];
2294
2295 move(LINES - 4, 0);
2296 for (n = 0; n < SIZEOF(legend); n++) {
2297 switch (legend[n].code) {
2298 default:
2299 strcpy(buf, legend[n].msg);
2300 break;
2301 case 1:
2302 sprintf(buf, legend[n].msg, do_keypad ? "yes" : "no");
2303 break;
2304 case 2:
2305 sprintf(buf, legend[n].msg, do_scroll ? "yes" : "no");
2306 break;
2307 case 3:
2308 sprintf(buf, legend[n].msg, do_keypad ? "/ESC" : "");
2309 break;
2310 }
2311 x = getcurx(stdscr);
2312 addstr((COLS < (x + 3 + (int) strlen(buf))) ? "\n" : (n ? ", " : ""));
2313 addstr(buf);
2314 }
2315 clrtoeol();
2316 }
2317
2318 static void
2319 transient(FRAME * curp, NCURSES_CONST char *msg)
2320 {
2321 newwin_legend(curp);
2322 if (msg) {
2323 mvaddstr(LINES - 1, 0, msg);
2324 refresh();
2325 napms(1000);
2326 }
2327
2328 move(LINES - 1, 0);
2329 printw("%s characters are echoed, window should %sscroll.",
2330 HaveKeypad(curp) ? "Non-arrow" : "All other",
2331 HaveScroll(curp) ? "" : "not ");
2332 clrtoeol();
2333 }
2334
2335 static void
2336 newwin_report(FRAME * curp)
2337 /* report on the cursor's current position, then restore it */
2338 {
2339 WINDOW *win = (curp != 0) ? curp->wind : stdscr;
2340 int y, x;
2341
2342 if (win != stdscr)
2343 transient(curp, (char *) 0);
2344 getyx(win, y, x);
2345 move(LINES - 1, COLS - 17);
2346 printw("Y = %2d X = %2d", y, x);
2347 if (win != stdscr)
2348 refresh();
2349 else
2350 wmove(win, y, x);
2351 }
2352
2353 static pair *
2354 selectcell(int uli, int ulj, int lri, int lrj)
2355 /* arrows keys move cursor, return location at current on non-arrow key */
2356 {
2357 static pair res; /* result cell */
2358 int si = lri - uli + 1; /* depth of the select area */
2359 int sj = lrj - ulj + 1; /* width of the select area */
2360 int i = 0, j = 0; /* offsets into the select area */
2361
2362 res.y = uli;
2363 res.x = ulj;
2364 for (;;) {
2365 move(uli + i, ulj + j);
2366 newwin_report((FRAME *) 0);
2367
2368 switch (Getchar()) {
2369 case KEY_UP:
2370 i += si - 1;
2371 break;
2372 case KEY_DOWN:
2373 i++;
2374 break;
2375 case KEY_LEFT:
2376 j += sj - 1;
2377 break;
2378 case KEY_RIGHT:
2379 j++;
2380 break;
2381 case QUIT:
2382 case ESCAPE:
2383 return ((pair *) 0);
2384 #ifdef NCURSES_MOUSE_VERSION
2385 case KEY_MOUSE:
2386 {
2387 MEVENT event;
2388
2389 getmouse(&event);
2390 if (event.y > uli && event.x > ulj) {
2391 i = event.y - uli;
2392 j = event.x - ulj;
2393 } else {
2394 beep();
2395 break;
2396 }
2397 }
2398 /* FALLTHRU */
2399 #endif
2400 default:
2401 res.y = uli + i;
2402 res.x = ulj + j;
2403 return (&res);
2404 }
2405 i %= si;
2406 j %= sj;
2407 }
2408 }
2409
2410 static void
2411 outerbox(pair ul, pair lr, bool onoff)
2412 /* draw or erase a box *outside* the given pair of corners */
2413 {
2414 mvaddch(ul.y - 1, lr.x - 1, onoff ? ACS_ULCORNER : ' ');
2415 mvaddch(ul.y - 1, lr.x + 1, onoff ? ACS_URCORNER : ' ');
2416 mvaddch(lr.y + 1, lr.x + 1, onoff ? ACS_LRCORNER : ' ');
2417 mvaddch(lr.y + 1, ul.x - 1, onoff ? ACS_LLCORNER : ' ');
2418 move(ul.y - 1, ul.x);
2419 hline(onoff ? ACS_HLINE : ' ', lr.x - ul.x + 1);
2420 move(ul.y, ul.x - 1);
2421 vline(onoff ? ACS_VLINE : ' ', lr.y - ul.y + 1);
2422 move(lr.y + 1, ul.x);
2423 hline(onoff ? ACS_HLINE : ' ', lr.x - ul.x + 1);
2424 move(ul.y, lr.x + 1);
2425 vline(onoff ? ACS_VLINE : ' ', lr.y - ul.y + 1);
2426 }
2427
2428 static WINDOW *
2429 getwindow(void)
2430 /* Ask user for a window definition */
2431 {
2432 WINDOW *rwindow;
2433 pair ul, lr, *tmp;
2434
2435 move(0, 0);
2436 clrtoeol();
2437 addstr("Use arrows to move cursor, anything else to mark corner 1");
2438 refresh();
2439 if ((tmp = selectcell(2, 1, LINES - BOTLINES - 2, COLS - 2)) == (pair *) 0)
2440 return ((WINDOW *) 0);
2441 memcpy(&ul, tmp, sizeof(pair));
2442 mvaddch(ul.y - 1, ul.x - 1, ACS_ULCORNER);
2443 move(0, 0);
2444 clrtoeol();
2445 addstr("Use arrows to move cursor, anything else to mark corner 2");
2446 refresh();
2447 if ((tmp = selectcell(ul.y, ul.x, LINES - BOTLINES - 2, COLS - 2)) ==
2448 (pair *) 0)
2449 return ((WINDOW *) 0);
2450 memcpy(&lr, tmp, sizeof(pair));
2451
2452 rwindow = subwin(stdscr, lr.y - ul.y + 1, lr.x - ul.x + 1, ul.y, ul.x);
2453
2454 outerbox(ul, lr, TRUE);
2455 refresh();
2456
2457 wrefresh(rwindow);
2458
2459 move(0, 0);
2460 clrtoeol();
2461 return (rwindow);
2462 }
2463
2464 static void
2465 newwin_move(FRAME * curp, int dy, int dx)
2466 {
2467 WINDOW *win = (curp != 0) ? curp->wind : stdscr;
2468 int cur_y, cur_x;
2469 int max_y, max_x;
2470
2471 getyx(win, cur_y, cur_x);
2472 getmaxyx(win, max_y, max_x);
2473 if ((cur_x += dx) < 0)
2474 cur_x = 0;
2475 else if (cur_x >= max_x)
2476 cur_x = max_x - 1;
2477 if ((cur_y += dy) < 0)
2478 cur_y = 0;
2479 else if (cur_y >= max_y)
2480 cur_y = max_y - 1;
2481 wmove(win, cur_y, cur_x);
2482 }
2483
2484 static FRAME *
2485 delete_framed(FRAME * fp, bool showit)
2486 {
2487 FRAME *np;
2488
2489 fp->last->next = fp->next;
2490 fp->next->last = fp->last;
2491
2492 if (showit) {
2493 werase(fp->wind);
2494 wrefresh(fp->wind);
2495 }
2496 delwin(fp->wind);
2497
2498 np = (fp == fp->next) ? 0 : fp->next;
2499 free(fp);
2500 return np;
2501 }
2502
2503 static void
2504 acs_and_scroll(void)
2505 /* Demonstrate windows */
2506 {
2507 int c, i;
2508 FILE *fp;
2509 FRAME *current = (FRAME *) 0, *neww;
2510 WINDOW *usescr = stdscr;
2511
2512 #define DUMPFILE "screendump"
2513
2514 #ifdef NCURSES_MOUSE_VERSION
2515 mousemask(BUTTON1_CLICKED, (mmask_t *) 0);
2516 #endif
2517 c = CTRL('C');
2518 raw();
2519 do {
2520 transient((FRAME *) 0, (char *) 0);
2521 switch (c) {
2522 case CTRL('C'):
2523 neww = (FRAME *) calloc(1, sizeof(FRAME));
2524 if ((neww->wind = getwindow()) == (WINDOW *) 0)
2525 goto breakout;
2526
2527 if (current == 0) { /* First element, */
2528 neww->next = neww; /* so point it at itself */
2529 neww->last = neww;
2530 } else {
2531 neww->next = current->next;
2532 neww->last = current;
2533 neww->last->next = neww;
2534 neww->next->last = neww;
2535 }
2536 current = neww;
2537 /* SVr4 curses sets the keypad on all newly-created windows to
2538 * false. Someone reported that PDCurses makes new windows inherit
2539 * this flag. Remove the following 'keypad()' call to test this
2540 */
2541 keypad(current->wind, TRUE);
2542 current->do_keypad = HaveKeypad(current);
2543 current->do_scroll = HaveScroll(current);
2544 break;
2545
2546 case CTRL('N'): /* go to next window */
2547 if (current)
2548 current = current->next;
2549 break;
2550
2551 case CTRL('P'): /* go to previous window */
2552 if (current)
2553 current = current->last;
2554 break;
2555
2556 case CTRL('F'): /* scroll current window forward */
2557 if (current)
2558 wscrl(current->wind, 1);
2559 break;
2560
2561 case CTRL('B'): /* scroll current window backwards */
2562 if (current)
2563 wscrl(current->wind, -1);
2564 break;
2565
2566 case CTRL('K'): /* toggle keypad mode for current */
2567 if (current) {
2568 current->do_keypad = !current->do_keypad;
2569 keypad(current->wind, current->do_keypad);
2570 }
2571 break;
2572
2573 case CTRL('S'):
2574 if (current) {
2575 current->do_scroll = !current->do_scroll;
2576 scrollok(current->wind, current->do_scroll);
2577 }
2578 break;
2579
2580 case CTRL('W'): /* save and delete window */
2581 if (current == current->next) {
2582 transient(current, "Will not save/delete ONLY window");
2583 break;
2584 } else if ((fp = fopen(DUMPFILE, "w")) == (FILE *) 0) {
2585 transient(current, "Can't open screen dump file");
2586 } else {
2587 (void) putwin(current->wind, fp);
2588 (void) fclose(fp);
2589
2590 current = delete_framed(current, TRUE);
2591 }
2592 break;
2593
2594 case CTRL('R'): /* restore window */
2595 if ((fp = fopen(DUMPFILE, "r")) == (FILE *) 0) {
2596 transient(current, "Can't open screen dump file");
2597 } else {
2598 neww = (FRAME *) calloc(1, sizeof(FRAME));
2599
2600 neww->next = current->next;
2601 neww->last = current;
2602 neww->last->next = neww;
2603 neww->next->last = neww;
2604
2605 neww->wind = getwin(fp);
2606 (void) fclose(fp);
2607
2608 wrefresh(neww->wind);
2609 }
2610 break;
2611
2612 #if HAVE_WRESIZE
2613 case CTRL('X'): /* resize window */
2614 if (current) {
2615 pair *tmp, ul, lr;
2616 int mx, my;
2617
2618 move(0, 0);
2619 clrtoeol();
2620 addstr("Use arrows to move cursor, anything else to mark new corner");
2621 refresh();
2622
2623 getbegyx(current->wind, ul.y, ul.x);
2624
2625 tmp = selectcell(ul.y, ul.x, LINES - BOTLINES - 2, COLS - 2);
2626 if (tmp == (pair *) 0) {
2627 beep();
2628 break;
2629 }
2630
2631 getmaxyx(current->wind, lr.y, lr.x);
2632 lr.y += (ul.y - 1);
2633 lr.x += (ul.x - 1);
2634 outerbox(ul, lr, FALSE);
2635 wnoutrefresh(stdscr);
2636
2637 /* strictly cosmetic hack for the test */
2638 getmaxyx(current->wind, my, mx);
2639 if (my > tmp->y - ul.y) {
2640 getyx(current->wind, lr.y, lr.x);
2641 wmove(current->wind, tmp->y - ul.y + 1, 0);
2642 wclrtobot(current->wind);
2643 wmove(current->wind, lr.y, lr.x);
2644 }
2645 if (mx > tmp->x - ul.x)
2646 for (i = 0; i < my; i++) {
2647 wmove(current->wind, i, tmp->x - ul.x + 1);
2648 wclrtoeol(current->wind);
2649 }
2650 wnoutrefresh(current->wind);
2651
2652 memcpy(&lr, tmp, sizeof(pair));
2653 (void) wresize(current->wind, lr.y - ul.y + 0, lr.x - ul.x + 0);
2654
2655 getbegyx(current->wind, ul.y, ul.x);
2656 getmaxyx(current->wind, lr.y, lr.x);
2657 lr.y += (ul.y - 1);
2658 lr.x += (ul.x - 1);
2659 outerbox(ul, lr, TRUE);
2660 wnoutrefresh(stdscr);
2661
2662 wnoutrefresh(current->wind);
2663 move(0, 0);
2664 clrtoeol();
2665 doupdate();
2666 }
2667 break;
2668 #endif /* HAVE_WRESIZE */
2669
2670 case KEY_F(10): /* undocumented --- use this to test area clears */
2671 selectcell(0, 0, LINES - 1, COLS - 1);
2672 clrtobot();
2673 refresh();
2674 break;
2675
2676 case KEY_UP:
2677 newwin_move(current, -1, 0);
2678 break;
2679 case KEY_DOWN:
2680 newwin_move(current, 1, 0);
2681 break;
2682 case KEY_LEFT:
2683 newwin_move(current, 0, -1);
2684 break;
2685 case KEY_RIGHT:
2686 newwin_move(current, 0, 1);
2687 break;
2688
2689 case KEY_BACKSPACE:
2690 /* FALLTHROUGH */
2691 case KEY_DC:
2692 {
2693 int y, x;
2694 getyx(current->wind, y, x);
2695 if (--x < 0) {
2696 if (--y < 0)
2697 break;
2698 x = getmaxx(current->wind) - 1;
2699 }
2700 mvwdelch(current->wind, y, x);
2701 }
2702 break;
2703
2704 case '\r':
2705 c = '\n';
2706 /* FALLTHROUGH */
2707
2708 default:
2709 if (current)
2710 waddch(current->wind, (chtype) c);
2711 else
2712 beep();
2713 break;
2714 }
2715 newwin_report(current);
2716 usescr = (current ? current->wind : stdscr);
2717 wrefresh(usescr);
2718 } while
2719 ((c = wGetchar(usescr)) != QUIT
2720 && !((c == ESCAPE) && (keypad_active(usescr)))
2721 && (c != ERR));
2722
2723 breakout:
2724 while (current != 0)
2725 current = delete_framed(current, FALSE);
2726
2727 scrollok(stdscr, TRUE); /* reset to driver's default */
2728 #ifdef NCURSES_MOUSE_VERSION
2729 mousemask(0, (mmask_t *) 0);
2730 #endif
2731 noraw();
2732 erase();
2733 endwin();
2734 }
2735
2736 /****************************************************************************
2737 *
2738 * Panels tester
2739 *
2740 ****************************************************************************/
2741
2742 #if USE_LIBPANEL
2743 static unsigned long nap_msec = 1;
2744
2745 static NCURSES_CONST char *mod[] =
2746 {
2747 "test ",
2748 "TEST ",
2749 "(**) ",
2750 "*()* ",
2751 "<--> ",
2752 "LAST "
2753 };
2754
2755 /*+-------------------------------------------------------------------------
2756 wait_a_while(msec)
2757 --------------------------------------------------------------------------*/
2758 static void
2759 wait_a_while(unsigned long msec GCC_UNUSED)
2760 {
2761 #if HAVE_NAPMS
2762 if (nap_msec == 1)
2763 wGetchar(stdscr);
2764 else
2765 napms(nap_msec);
2766 #else
2767 if (nap_msec == 1)
2768 wGetchar(stdscr);
2769 else if (msec > 1000L)
2770 sleep((int) msec / 1000L);
2771 else
2772 sleep(1);
2773 #endif
2774 } /* end of wait_a_while */
2775
2776 /*+-------------------------------------------------------------------------
2777 saywhat(text)
2778 --------------------------------------------------------------------------*/
2779 static void
2780 saywhat(NCURSES_CONST char *text)
2781 {
2782 wmove(stdscr, LINES - 1, 0);
2783 wclrtoeol(stdscr);
2784 waddstr(stdscr, text);
2785 } /* end of saywhat */
2786
2787 /*+-------------------------------------------------------------------------
2788 mkpanel(rows,cols,tly,tlx) - alloc a win and panel and associate them
2789 --------------------------------------------------------------------------*/
2790 static PANEL *
2791 mkpanel(int color, int rows, int cols, int tly, int tlx)
2792 {
2793 WINDOW *win;
2794 PANEL *pan = 0;
2795
2796 if ((win = newwin(rows, cols, tly, tlx)) != 0) {
2797 if ((pan = new_panel(win)) == 0) {
2798 delwin(win);
2799 } else if (has_colors()) {
2800 int fg = (color == COLOR_BLUE) ? COLOR_WHITE : COLOR_BLACK;
2801 int bg = color;
2802 init_pair(color, fg, bg);
2803 wbkgdset(win, COLOR_PAIR(color) | ' ');
2804 } else {
2805 wbkgdset(win, A_BOLD | ' ');
2806 }
2807 }
2808 return pan;
2809 } /* end of mkpanel */
2810
2811 /*+-------------------------------------------------------------------------
2812 rmpanel(pan)
2813 --------------------------------------------------------------------------*/
2814 static void
2815 rmpanel(PANEL * pan)
2816 {
2817 WINDOW *win = panel_window(pan);
2818 del_panel(pan);
2819 delwin(win);
2820 } /* end of rmpanel */
2821
2822 /*+-------------------------------------------------------------------------
2823 pflush()
2824 --------------------------------------------------------------------------*/
2825 static void
2826 pflush(void)
2827 {
2828 update_panels();
2829 doupdate();
2830 } /* end of pflush */
2831
2832 /*+-------------------------------------------------------------------------
2833 fill_panel(win)
2834 --------------------------------------------------------------------------*/
2835 static void
2836 fill_panel(PANEL * pan)
2837 {
2838 WINDOW *win = panel_window(pan);
2839 int num = ((const char *) panel_userptr(pan))[1];
2840 int y, x;
2841
2842 wmove(win, 1, 1);
2843 wprintw(win, "-pan%c-", num);
2844 wclrtoeol(win);
2845 box(win, 0, 0);
2846 for (y = 2; y < getmaxy(win) - 1; y++) {
2847 for (x = 1; x < getmaxx(win) - 1; x++) {
2848 wmove(win, y, x);
2849 waddch(win, num);
2850 }
2851 }
2852 } /* end of fill_panel */
2853
2854 static void
2855 demo_panels(void)
2856 {
2857 int itmp;
2858 register int y, x;
2859
2860 refresh();
2861
2862 for (y = 0; y < LINES - 1; y++) {
2863 for (x = 0; x < COLS; x++)
2864 wprintw(stdscr, "%d", (y + x) % 10);
2865 }
2866 for (y = 0; y < 5; y++) {
2867 PANEL *p1;
2868 PANEL *p2;
2869 PANEL *p3;
2870 PANEL *p4;
2871 PANEL *p5;
2872
2873 p1 = mkpanel(COLOR_RED,
2874 LINES / 2 - 2,
2875 COLS / 8 + 1,
2876 0,
2877 0);
2878 set_panel_userptr(p1, (NCURSES_CONST void *) "p1");
2879
2880 p2 = mkpanel(COLOR_GREEN,
2881 LINES / 2 + 1,
2882 COLS / 7,
2883 LINES / 4,
2884 COLS / 10);
2885 set_panel_userptr(p2, (NCURSES_CONST void *) "p2");
2886
2887 p3 = mkpanel(COLOR_YELLOW,
2888 LINES / 4,
2889 COLS / 10,
2890 LINES / 2,
2891 COLS / 9);
2892 set_panel_userptr(p3, (NCURSES_CONST void *) "p3");
2893
2894 p4 = mkpanel(COLOR_BLUE,
2895 LINES / 2 - 2,
2896 COLS / 8,
2897 LINES / 2 - 2,
2898 COLS / 3);
2899 set_panel_userptr(p4, (NCURSES_CONST void *) "p4");
2900
2901 p5 = mkpanel(COLOR_MAGENTA,
2902 LINES / 2 - 2,
2903 COLS / 8,
2904 LINES / 2,
2905 COLS / 2 - 2);
2906 set_panel_userptr(p5, (NCURSES_CONST void *) "p5");
2907
2908 fill_panel(p1);
2909 fill_panel(p2);
2910 fill_panel(p3);
2911 fill_panel(p4);
2912 fill_panel(p5);
2913 hide_panel(p4);
2914 hide_panel(p5);
2915 pflush();
2916 saywhat("press any key to continue");
2917 wait_a_while(nap_msec);
2918
2919 saywhat("h3 s1 s2 s4 s5; press any key to continue");
2920 move_panel(p1, 0, 0);
2921 hide_panel(p3);
2922 show_panel(p1);
2923 show_panel(p2);
2924 show_panel(p4);
2925 show_panel(p5);
2926 pflush();
2927 wait_a_while(nap_msec);
2928
2929 saywhat("s1; press any key to continue");
2930 show_panel(p1);
2931 pflush();
2932 wait_a_while(nap_msec);
2933
2934 saywhat("s2; press any key to continue");
2935 show_panel(p2);
2936 pflush();
2937 wait_a_while(nap_msec);
2938
2939 saywhat("m2; press any key to continue");
2940 move_panel(p2, LINES / 3 + 1, COLS / 8);
2941 pflush();
2942 wait_a_while(nap_msec);
2943
2944 saywhat("s3;");
2945 show_panel(p3);
2946 pflush();
2947 wait_a_while(nap_msec);
2948
2949 saywhat("m3; press any key to continue");
2950 move_panel(p3, LINES / 4 + 1, COLS / 15);
2951 pflush();
2952 wait_a_while(nap_msec);
2953
2954 saywhat("b3; press any key to continue");
2955 bottom_panel(p3);
2956 pflush();
2957 wait_a_while(nap_msec);
2958
2959 saywhat("s4; press any key to continue");
2960 show_panel(p4);
2961 pflush();
2962 wait_a_while(nap_msec);
2963
2964 saywhat("s5; press any key to continue");
2965 show_panel(p5);
2966 pflush();
2967 wait_a_while(nap_msec);
2968
2969 saywhat("t3; press any key to continue");
2970 top_panel(p3);
2971 pflush();
2972 wait_a_while(nap_msec);
2973
2974 saywhat("t1; press any key to continue");
2975 top_panel(p1);
2976 pflush();
2977 wait_a_while(nap_msec);
2978
2979 saywhat("t2; press any key to continue");
2980 top_panel(p2);
2981 pflush();
2982 wait_a_while(nap_msec);
2983
2984 saywhat("t3; press any key to continue");
2985 top_panel(p3);
2986 pflush();
2987 wait_a_while(nap_msec);
2988
2989 saywhat("t4; press any key to continue");
2990 top_panel(p4);
2991 pflush();
2992 wait_a_while(nap_msec);
2993
2994 for (itmp = 0; itmp < 6; itmp++) {
2995 WINDOW *w4 = panel_window(p4);
2996 WINDOW *w5 = panel_window(p5);
2997
2998 saywhat("m4; press any key to continue");
2999 wmove(w4, LINES / 8, 1);
3000 waddstr(w4, mod[itmp]);
3001 move_panel(p4, LINES / 6, itmp * (COLS / 8));
3002 wmove(w5, LINES / 6, 1);
3003 waddstr(w5, mod[itmp]);
3004 pflush();
3005 wait_a_while(nap_msec);
3006
3007 saywhat("m5; press any key to continue");
3008 wmove(w4, LINES / 6, 1);
3009 waddstr(w4, mod[itmp]);
3010 move_panel(p5, LINES / 3 - 1, (itmp * 10) + 6);
3011 wmove(w5, LINES / 8, 1);
3012 waddstr(w5, mod[itmp]);
3013 pflush();
3014 wait_a_while(nap_msec);
3015 }
3016
3017 saywhat("m4; press any key to continue");
3018 move_panel(p4, LINES / 6, itmp * (COLS / 8));
3019 pflush();
3020 wait_a_while(nap_msec);
3021
3022 saywhat("t5; press any key to continue");
3023 top_panel(p5);
3024 pflush();
3025 wait_a_while(nap_msec);
3026
3027 saywhat("t2; press any key to continue");
3028 top_panel(p2);
3029 pflush();
3030 wait_a_while(nap_msec);
3031
3032 saywhat("t1; press any key to continue");
3033 top_panel(p1);
3034 pflush();
3035 wait_a_while(nap_msec);
3036
3037 saywhat("d2; press any key to continue");
3038 rmpanel(p2);
3039 pflush();
3040 wait_a_while(nap_msec);
3041
3042 saywhat("h3; press any key to continue");
3043 hide_panel(p3);
3044 pflush();
3045 wait_a_while(nap_msec);
3046
3047 saywhat("d1; press any key to continue");
3048 rmpanel(p1);
3049 pflush();
3050 wait_a_while(nap_msec);
3051
3052 saywhat("d4; press any key to continue");
3053 rmpanel(p4);
3054 pflush();
3055 wait_a_while(nap_msec);
3056
3057 saywhat("d5; press any key to continue");
3058 rmpanel(p5);
3059 pflush();
3060 wait_a_while(nap_msec);
3061 if (nap_msec == 1)
3062 break;
3063 nap_msec = 100L;
3064 }
3065
3066 erase();
3067 endwin();
3068 }
3069
3070 /****************************************************************************
3071 *
3072 * Pad tester
3073 *
3074 ****************************************************************************/
3075
3076 #define GRIDSIZE 3
3077
3078 static bool pending_pan = FALSE;
3079 static bool show_panner_legend = TRUE;
3080
3081 static int
3082 panner_legend(int line)
3083 {
3084 static const char *const legend[] =
3085 {
3086 "Use arrow keys (or U,D,L,R) to pan, q to quit, ! to shell-out.",
3087 "Use +,- (or j,k) to grow/shrink the panner vertically.",
3088 "Use <,> (or h,l) to grow/shrink the panner horizontally.",
3089 "Number repeats. Toggle legend:?, timer:t, scroll mark:s."
3090 };
3091 int n = (SIZEOF(legend) - (LINES - line));
3092 if (line < LINES && (n >= 0)) {
3093 move(line, 0);
3094 if (show_panner_legend)
3095 printw("%s", legend[n]);
3096 clrtoeol();
3097 return show_panner_legend;
3098 }
3099 return FALSE;
3100 }
3101
3102 static void
3103 panner_h_cleanup(int from_y, int from_x, int to_x)
3104 {
3105 if (!panner_legend(from_y))
3106 do_h_line(from_y, from_x, ' ', to_x);
3107 }
3108
3109 static void
3110 panner_v_cleanup(int from_y, int from_x, int to_y)
3111 {
3112 if (!panner_legend(from_y))
3113 do_v_line(from_y, from_x, ' ', to_y);
3114 }
3115
3116 static void
3117 panner(WINDOW *pad,
3118 int top_x, int top_y, int porty, int portx,
3119 int (*pgetc) (WINDOW *))
3120 {
3121 #if HAVE_GETTIMEOFDAY
3122 struct timeval before, after;
3123 bool timing = TRUE;
3124 #endif
3125 bool scrollers = TRUE;
3126 int basex = 0;
3127 int basey = 0;
3128 int pxmax, pymax, lowend, highend, c;
3129
3130 getmaxyx(pad, pymax, pxmax);
3131 scrollok(stdscr, FALSE); /* we don't want stdscr to scroll! */
3132
3133 c = KEY_REFRESH;
3134 do {
3135 #ifdef NCURSES_VERSION
3136 /*
3137 * During shell-out, the user may have resized the window. Adjust
3138 * the port size of the pad to accommodate this. Ncurses automatically
3139 * resizes all of the normal windows to fit on the new screen.
3140 */
3141 if (top_x > COLS)
3142 top_x = COLS;
3143 if (portx > COLS)
3144 portx = COLS;
3145 if (top_y > LINES)
3146 top_y = LINES;
3147 if (porty > LINES)
3148 porty = LINES;
3149 #endif
3150 switch (c) {
3151 case KEY_REFRESH:
3152 erase();
3153
3154 /* FALLTHRU */
3155 case '?':
3156 if (c == '?')
3157 show_panner_legend = !show_panner_legend;
3158 panner_legend(LINES - 4);
3159 panner_legend(LINES - 3);
3160 panner_legend(LINES - 2);
3161 panner_legend(LINES - 1);
3162 break;
3163 #if HAVE_GETTIMEOFDAY
3164 case 't':
3165 timing = !timing;
3166 if (!timing)
3167 panner_legend(LINES - 1);
3168 break;
3169 #endif
3170 case 's':
3171 scrollers = !scrollers;
3172 break;
3173
3174 /* Move the top-left corner of the pad, keeping the bottom-right
3175 * corner fixed.
3176 */
3177 case 'h': /* increase-columns: move left edge to left */
3178 if (top_x <= 0)
3179 beep();
3180 else {
3181 panner_v_cleanup(top_y, top_x, porty);
3182 top_x--;
3183 }
3184 break;
3185
3186 case 'j': /* decrease-lines: move top-edge down */
3187 if (top_y >= porty)
3188 beep();
3189 else {
3190 panner_h_cleanup(top_y - 1, top_x - (top_x > 0), portx);
3191 top_y++;
3192 }
3193 break;
3194
3195 case 'k': /* increase-lines: move top-edge up */
3196 if (top_y <= 0)
3197 beep();
3198 else {
3199 top_y--;
3200 panner_h_cleanup(top_y, top_x, portx);
3201 }
3202 break;
3203
3204 case 'l': /* decrease-columns: move left-edge to right */
3205 if (top_x >= portx)
3206 beep();
3207 else {
3208 panner_v_cleanup(top_y - (top_y > 0), top_x - 1, porty);
3209 top_x++;
3210 }
3211 break;
3212
3213 /* Move the bottom-right corner of the pad, keeping the top-left
3214 * corner fixed.
3215 */
3216 case KEY_IC: /* increase-columns: move right-edge to right */
3217 if (portx >= pxmax || portx >= COLS)
3218 beep();
3219 else {
3220 panner_v_cleanup(top_y - (top_y > 0), portx - 1, porty);
3221 ++portx;
3222 }
3223 break;
3224
3225 case KEY_IL: /* increase-lines: move bottom-edge down */
3226 if (porty >= pymax || porty >= LINES)
3227 beep();
3228 else {
3229 panner_h_cleanup(porty - 1, top_x - (top_x > 0), portx);
3230 ++porty;
3231 }
3232 break;
3233
3234 case KEY_DC: /* decrease-columns: move bottom edge up */
3235 if (portx <= top_x)
3236 beep();
3237 else {
3238 portx--;
3239 panner_v_cleanup(top_y - (top_y > 0), portx, porty);
3240 }
3241 break;
3242
3243 case KEY_DL: /* decrease-lines */
3244 if (porty <= top_y)
3245 beep();
3246 else {
3247 porty--;
3248 panner_h_cleanup(porty, top_x - (top_x > 0), portx);
3249 }
3250 break;
3251
3252 case KEY_LEFT: /* pan leftwards */
3253 if (basex > 0)
3254 basex--;
3255 else
3256 beep();
3257 break;
3258
3259 case KEY_RIGHT: /* pan rightwards */
3260 if (basex + portx - (pymax > porty) < pxmax)
3261 basex++;
3262 else
3263 beep();
3264 break;
3265
3266 case KEY_UP: /* pan upwards */
3267 if (basey > 0)
3268 basey--;
3269 else
3270 beep();
3271 break;
3272
3273 case KEY_DOWN: /* pan downwards */
3274 if (basey + porty - (pxmax > portx) < pymax)
3275 basey++;
3276 else
3277 beep();
3278 break;
3279
3280 case 'H':
3281 case KEY_HOME:
3282 case KEY_FIND:
3283 basey = 0;
3284 break;
3285
3286 case 'E':
3287 case KEY_END:
3288 case KEY_SELECT:
3289 basey = pymax - porty;
3290 if (basey < 0)
3291 basey = 0;
3292 break;
3293
3294 default:
3295 beep();
3296 break;
3297 }
3298
3299 mvaddch(top_y - 1, top_x - 1, ACS_ULCORNER);
3300 do_v_line(top_y, top_x - 1, ACS_VLINE, porty);
3301 do_h_line(top_y - 1, top_x, ACS_HLINE, portx);
3302
3303 if (scrollers && (pxmax > portx - 1)) {
3304 int length = (portx - top_x - 1);
3305 float ratio = ((float) length) / ((float) pxmax);
3306
3307 lowend = (int) (top_x + (basex * ratio));
3308 highend = (int) (top_x + ((basex + length) * ratio));
3309
3310 do_h_line(porty - 1, top_x, ACS_HLINE, lowend);
3311 if (highend < portx) {
3312 attron(A_REVERSE);
3313 do_h_line(porty - 1, lowend, ' ', highend + 1);
3314 attroff(A_REVERSE);
3315 do_h_line(porty - 1, highend + 1, ACS_HLINE, portx);
3316 }
3317 } else
3318 do_h_line(porty - 1, top_x, ACS_HLINE, portx);
3319
3320 if (scrollers && (pymax > porty - 1)) {
3321 int length = (porty - top_y - 1);
3322 float ratio = ((float) length) / ((float) pymax);
3323
3324 lowend = (int) (top_y + (basey * ratio));
3325 highend = (int) (top_y + ((basey + length) * ratio));
3326
3327 do_v_line(top_y, portx - 1, ACS_VLINE, lowend);
3328 if (highend < porty) {
3329 attron(A_REVERSE);
3330 do_v_line(lowend, portx - 1, ' ', highend + 1);
3331 attroff(A_REVERSE);
3332 do_v_line(highend + 1, portx - 1, ACS_VLINE, porty);
3333 }
3334 } else
3335 do_v_line(top_y, portx - 1, ACS_VLINE, porty);
3336
3337 mvaddch(top_y - 1, portx - 1, ACS_URCORNER);
3338 mvaddch(porty - 1, top_x - 1, ACS_LLCORNER);
3339 mvaddch(porty - 1, portx - 1, ACS_LRCORNER);
3340
3341 if (!pending_pan) {
3342 #if HAVE_GETTIMEOFDAY
3343 gettimeofday(&before, 0);
3344 #endif
3345 wnoutrefresh(stdscr);
3346
3347 pnoutrefresh(pad,
3348 basey, basex,
3349 top_y, top_x,
3350 porty - (pxmax > portx) - 1,
3351 portx - (pymax > porty) - 1);
3352
3353 doupdate();
3354 #if HAVE_GETTIMEOFDAY
3355 if (timing) {
3356 double elapsed;
3357 gettimeofday(&after, 0);
3358 elapsed = (after.tv_sec + after.tv_usec / 1.0e6)
3359 - (before.tv_sec + before.tv_usec / 1.0e6);
3360 move(LINES - 1, COLS - 20);
3361 printw("Secs: %2.03f", elapsed);
3362 refresh();
3363 }
3364 #endif
3365 }
3366
3367 } while
3368 ((c = pgetc(pad)) != KEY_EXIT);
3369
3370 scrollok(stdscr, TRUE); /* reset to driver's default */
3371 }
3372
3373 static int
3374 padgetch(WINDOW *win)
3375 {
3376 static int count;
3377 static int last;
3378 int c;
3379
3380 if ((pending_pan = (count > 0)) != FALSE) {
3381 count--;
3382 pending_pan = (count != 0);
3383 } else {
3384 for (;;) {
3385 switch (c = wGetchar(win)) {
3386 case '!':
3387 ShellOut(FALSE);
3388 /* FALLTHRU */
3389 case CTRL('r'):
3390 endwin();
3391 refresh();
3392 c = KEY_REFRESH;
3393 break;
3394 case CTRL('l'):
3395 c = KEY_REFRESH;
3396 break;
3397 case 'U':
3398 c = KEY_UP;
3399 break;
3400 case 'D':
3401 c = KEY_DOWN;
3402 break;
3403 case 'R':
3404 c = KEY_RIGHT;
3405 break;
3406 case 'L':
3407 c = KEY_LEFT;
3408 break;
3409 case '+':
3410 c = KEY_IL;
3411 break;
3412 case '-':
3413 c = KEY_DL;
3414 break;
3415 case '>':
3416 c = KEY_IC;
3417 break;
3418 case '<':
3419 c = KEY_DC;
3420 break;
3421 case ERR: /* FALLTHRU */
3422 case 'q':
3423 count = 0;
3424 c = KEY_EXIT;
3425 break;
3426 default:
3427 if (c >= '0' && c <= '9') {
3428 count = count * 10 + (c - '0');
3429 continue;
3430 }
3431 break;
3432 }
3433 last = c;
3434 break;
3435 }
3436 if (count > 0)
3437 count--;
3438 }
3439 return (last);
3440 }
3441
3442 #define PAD_HIGH 200
3443 #define PAD_WIDE 200
3444
3445 static void
3446 demo_pad(void)
3447 /* Demonstrate pads. */
3448 {
3449 int i, j;
3450 unsigned gridcount = 0;
3451 WINDOW *panpad = newpad(PAD_HIGH, PAD_WIDE);
3452
3453 if (panpad == 0) {
3454 Cannot("cannot create requested pad");
3455 return;
3456 }
3457
3458 for (i = 0; i < PAD_HIGH; i++) {
3459 for (j = 0; j < PAD_WIDE; j++)
3460 if (i % GRIDSIZE == 0 && j % GRIDSIZE == 0) {
3461 if (i == 0 || j == 0)
3462 waddch(panpad, '+');
3463 else
3464 waddch(panpad, (chtype) ('A' + (gridcount++ % 26)));
3465 } else if (i % GRIDSIZE == 0)
3466 waddch(panpad, '-');
3467 else if (j % GRIDSIZE == 0)
3468 waddch(panpad, '|');
3469 else
3470 waddch(panpad, ' ');
3471 }
3472 panner_legend(LINES - 4);
3473 panner_legend(LINES - 3);
3474 panner_legend(LINES - 2);
3475 panner_legend(LINES - 1);
3476
3477 keypad(panpad, TRUE);
3478
3479 /* Make the pad (initially) narrow enough that a trace file won't wrap.
3480 * We'll still be able to widen it during a test, since that's required
3481 * for testing boundaries.
3482 */
3483 panner(panpad, 2, 2, LINES - 5, COLS - 15, padgetch);
3484
3485 delwin(panpad);
3486 endwin();
3487 erase();
3488 }
3489 #endif /* USE_LIBPANEL */
3490
3491 /****************************************************************************
3492 *
3493 * Tests from John Burnell's PDCurses tester
3494 *
3495 ****************************************************************************/
3496
3497 static void
3498 Continue(WINDOW *win)
3499 {
3500 noecho();
3501 wmove(win, 10, 1);
3502 mvwaddstr(win, 10, 1, " Press any key to continue");
3503 wrefresh(win);
3504 wGetchar(win);
3505 }
3506
3507 static void
3508 flushinp_test(WINDOW *win)
3509 /* Input test, adapted from John Burnell's PDCurses tester */
3510 {
3511 int w, h, bx, by, sw, sh, i;
3512
3513 WINDOW *subWin;
3514 wclear(win);
3515
3516 getmaxyx(win, h, w);
3517 getbegyx(win, by, bx);
3518 sw = w / 3;
3519 sh = h / 3;
3520 if ((subWin = subwin(win, sh, sw, by + h - sh - 2, bx + w - sw - 2)) == 0)
3521 return;
3522
3523 #ifdef A_COLOR
3524 if (has_colors()) {
3525 init_pair(2, COLOR_CYAN, COLOR_BLUE);
3526 wbkgd(subWin, COLOR_PAIR(2) | ' ');
3527 }
3528 #endif
3529 wattrset(subWin, A_BOLD);
3530 box(subWin, ACS_VLINE, ACS_HLINE);
3531 mvwaddstr(subWin, 2, 1, "This is a subwindow");
3532 wrefresh(win);
3533
3534 /*
3535 * This used to set 'nocbreak()'. However, Alexander Lukyanov says that
3536 * it only happened to "work" on SVr4 because that implementation does not
3537 * emulate nocbreak+noecho mode, whereas ncurses does. To get the desired
3538 * test behavior, we're using 'cbreak()', which will allow a single
3539 * character to return without needing a newline. - T.Dickey 1997/10/11.
3540 */
3541 cbreak();
3542 mvwaddstr(win, 0, 1, "This is a test of the flushinp() call.");
3543
3544 mvwaddstr(win, 2, 1, "Type random keys for 5 seconds.");
3545 mvwaddstr(win, 3, 1,
3546 "These should be discarded (not echoed) after the subwindow goes away.");
3547 wrefresh(win);
3548
3549 for (i = 0; i < 5; i++) {
3550 mvwprintw(subWin, 1, 1, "Time = %d", i);
3551 wrefresh(subWin);
3552 napms(1000);
3553 flushinp();
3554 }
3555
3556 delwin(subWin);
3557 werase(win);
3558 flash();
3559 wrefresh(win);
3560 napms(1000);
3561
3562 mvwaddstr(win, 2, 1,
3563 "If you were still typing when the window timer expired,");
3564 mvwaddstr(win, 3, 1,
3565 "or else you typed nothing at all while it was running,");
3566 mvwaddstr(win, 4, 1,
3567 "test was invalid. You'll see garbage or nothing at all. ");
3568 mvwaddstr(win, 6, 1, "Press a key");
3569 wmove(win, 9, 10);
3570 wrefresh(win);
3571 echo();
3572 wGetchar(win);
3573 flushinp();
3574 mvwaddstr(win, 12, 0,
3575 "If you see any key other than what you typed, flushinp() is broken.");
3576 Continue(win);
3577
3578 wmove(win, 9, 10);
3579 wdelch(win);
3580 wrefresh(win);
3581 wmove(win, 12, 0);
3582 clrtoeol();
3583 waddstr(win,
3584 "What you typed should now have been deleted; if not, wdelch() failed.");
3585 Continue(win);
3586
3587 cbreak();
3588 }
3589
3590 /****************************************************************************
3591 *
3592 * Menu test
3593 *
3594 ****************************************************************************/
3595
3596 #if USE_LIBMENU
3597
3598 #define MENU_Y 8
3599 #define MENU_X 8
3600
3601 static int
3602 menu_virtualize(int c)
3603 {
3604 if (c == '\n' || c == KEY_EXIT)
3605 return (MAX_COMMAND + 1);
3606 else if (c == 'u')
3607 return (REQ_SCR_ULINE);
3608 else if (c == 'd')
3609 return (REQ_SCR_DLINE);
3610 else if (c == 'b' || c == KEY_NPAGE)
3611 return (REQ_SCR_UPAGE);
3612 else if (c == 'f' || c == KEY_PPAGE)
3613 return (REQ_SCR_DPAGE);
3614 else if (c == 'n' || c == KEY_DOWN)
3615 return (REQ_NEXT_ITEM);
3616 else if (c == 'p' || c == KEY_UP)
3617 return (REQ_PREV_ITEM);
3618 else if (c == ' ')
3619 return (REQ_TOGGLE_ITEM);
3620 else {
3621 if (c != KEY_MOUSE)
3622 beep();
3623 return (c);
3624 }
3625 }
3626
3627 static const char *animals[] =
3628 {
3629 "Lions", "Tigers", "Bears", "(Oh my!)", "Newts", "Platypi", "Lemurs",
3630 (char *) 0
3631 };
3632
3633 static void
3634 menu_test(void)
3635 {
3636 MENU *m;
3637 ITEM *items[SIZEOF(animals)];
3638 ITEM **ip = items;
3639 const char **ap;
3640 int mrows, mcols, c;
3641 WINDOW *menuwin;
3642
3643 #ifdef NCURSES_MOUSE_VERSION
3644 mousemask(ALL_MOUSE_EVENTS, (mmask_t *) 0);
3645 #endif
3646 mvaddstr(0, 0, "This is the menu test:");
3647 mvaddstr(2, 0, " Use up and down arrow to move the select bar.");
3648 mvaddstr(3, 0, " 'n' and 'p' act like arrows.");
3649 mvaddstr(4, 0,
3650 " 'b' and 'f' scroll up/down (page), 'u' and 'd' (line).");
3651 mvaddstr(5, 0, " Press return to exit.");
3652 refresh();
3653
3654 for (ap = animals; *ap; ap++)
3655 *ip++ = new_item(*ap, "");
3656 *ip = (ITEM *) 0;
3657
3658 m = new_menu(items);
3659
3660 set_menu_format(m, (SIZEOF(animals) + 1) / 2, 1);
3661 scale_menu(m, &mrows, &mcols);
3662
3663 menuwin = newwin(mrows + 2, mcols + 2, MENU_Y, MENU_X);
3664 set_menu_win(m, menuwin);
3665 keypad(menuwin, TRUE);
3666 box(menuwin, 0, 0);
3667
3668 set_menu_sub(m, derwin(menuwin, mrows, mcols, 1, 1));
3669
3670 post_menu(m);
3671
3672 while ((c = menu_driver(m, menu_virtualize(wGetchar(menuwin)))) != E_UNKNOWN_COMMAND) {
3673 if (c == E_REQUEST_DENIED)
3674 beep();
3675 continue;
3676 }
3677
3678 (void) mvprintw(LINES - 2, 0,
3679 "You chose: %s\n", item_name(current_item(m)));
3680 (void) addstr("Press any key to continue...");
3681 wGetchar(stdscr);
3682
3683 unpost_menu(m);
3684 delwin(menuwin);
3685
3686 free_menu(m);
3687 for (ip = items; *ip; ip++)
3688 free_item(*ip);
3689 #ifdef NCURSES_MOUSE_VERSION
3690 mousemask(0, (mmask_t *) 0);
3691 #endif
3692 }
3693
3694 #ifdef TRACE
3695 #define T_TBL(name) { #name, name }
3696 static struct {
3697 const char *name;
3698 int mask;
3699 } t_tbl[] = {
3700
3701 T_TBL(TRACE_DISABLE),
3702 T_TBL(TRACE_TIMES),
3703 T_TBL(TRACE_TPUTS),
3704 T_TBL(TRACE_UPDATE),
3705 T_TBL(TRACE_MOVE),
3706 T_TBL(TRACE_CHARPUT),
3707 T_TBL(TRACE_ORDINARY),
3708 T_TBL(TRACE_CALLS),
3709 T_TBL(TRACE_VIRTPUT),
3710 T_TBL(TRACE_IEVENT),
3711 T_TBL(TRACE_BITS),
3712 T_TBL(TRACE_ICALLS),
3713 T_TBL(TRACE_CCALLS),
3714 T_TBL(TRACE_DATABASE),
3715 T_TBL(TRACE_ATTRS),
3716 T_TBL(TRACE_MAXIMUM),
3717 {
3718 (char *) 0, 0
3719 }
3720 };
3721
3722 static char *
3723 tracetrace(int tlevel)
3724 {
3725 static char *buf;
3726 int n;
3727
3728 if (buf == 0) {
3729 size_t need = 12;
3730 for (n = 0; t_tbl[n].name != 0; n++)
3731 need += strlen(t_tbl[n].name) + 2;
3732 buf = (char *) malloc(need);
3733 }
3734 sprintf(buf, "0x%02x = {", tlevel);
3735 if (tlevel == 0) {
3736 sprintf(buf + strlen(buf), "%s, ", t_tbl[0].name);
3737 } else {
3738 for (n = 1; t_tbl[n].name != 0; n++)
3739 if ((tlevel & t_tbl[n].mask) == t_tbl[n].mask) {
3740 strcat(buf, t_tbl[n].name);
3741 strcat(buf, ", ");
3742 }
3743 }
3744 if (buf[strlen(buf) - 2] == ',')
3745 buf[strlen(buf) - 2] = '\0';
3746 return (strcat(buf, "}"));
3747 }
3748
3749 /* fake a dynamically reconfigurable menu using the 0th entry to deselect
3750 * the others
3751 */
3752 static int
3753 run_trace_menu(MENU * m)
3754 {
3755 ITEM **items;
3756 ITEM *i, **p;
3757
3758 for (;;) {
3759 bool changed = FALSE;
3760 switch (menu_driver(m, menu_virtualize(wGetchar(menu_win(m))))) {
3761 case E_UNKNOWN_COMMAND:
3762 return FALSE;
3763 default:
3764 items = menu_items(m);
3765 i = current_item(m);
3766 if (i == items[0]) {
3767 if (item_value(i)) {
3768 for (p = items + 1; *p != 0; p++)
3769 if (item_value(*p)) {
3770 set_item_value(*p, FALSE);
3771 changed = TRUE;
3772 }
3773 }
3774 } else {
3775 for (p = items + 1; *p != 0; p++)
3776 if (item_value(*p)) {
3777 set_item_value(items[0], FALSE);
3778 changed = TRUE;
3779 break;
3780 }
3781 }
3782 if (!changed)
3783 return TRUE;
3784 }
3785 }
3786 }
3787
3788 static void
3789 trace_set(void)
3790 /* interactively set the trace level */
3791 {
3792 MENU *m;
3793 ITEM *items[SIZEOF(t_tbl)];
3794 ITEM **ip = items;
3795 int mrows, mcols, newtrace;
3796 int n;
3797 WINDOW *menuwin;
3798
3799 mvaddstr(0, 0, "Interactively set trace level:");
3800 mvaddstr(2, 0, " Press space bar to toggle a selection.");
3801 mvaddstr(3, 0, " Use up and down arrow to move the select bar.");
3802 mvaddstr(4, 0, " Press return to set the trace level.");
3803 mvprintw(6, 0, "(Current trace level is %s)", tracetrace(_nc_tracing));
3804
3805 refresh();
3806
3807 for (n = 0; t_tbl[n].name != 0; n++)
3808 *ip++ = new_item(t_tbl[n].name, "");
3809 *ip = (ITEM *) 0;
3810
3811 m = new_menu(items);
3812
3813 set_menu_format(m, 0, 2);
3814 scale_menu(m, &mrows, &mcols);
3815
3816 menu_opts_off(m, O_ONEVALUE);
3817 menuwin = newwin(mrows + 2, mcols + 2, MENU_Y, MENU_X);
3818 set_menu_win(m, menuwin);
3819 keypad(menuwin, TRUE);
3820 box(menuwin, 0, 0);
3821
3822 set_menu_sub(m, derwin(menuwin, mrows, mcols, 1, 1));
3823
3824 post_menu(m);
3825
3826 for (ip = menu_items(m); *ip; ip++) {
3827 int mask = t_tbl[item_index(*ip)].mask;
3828 if (mask == 0)
3829 set_item_value(*ip, _nc_tracing == 0);
3830 else if ((mask & _nc_tracing) == mask)
3831 set_item_value(*ip, TRUE);
3832 }
3833
3834 while (run_trace_menu(m))
3835 continue;
3836
3837 newtrace = 0;
3838 for (ip = menu_items(m); *ip; ip++)
3839 if (item_value(*ip))
3840 newtrace |= t_tbl[item_index(*ip)].mask;
3841 trace(newtrace);
3842 _tracef("trace level interactively set to %s", tracetrace(_nc_tracing));
3843
3844 (void) mvprintw(LINES - 2, 0,
3845 "Trace level is %s\n", tracetrace(_nc_tracing));
3846 (void) addstr("Press any key to continue...");
3847 wGetchar(stdscr);
3848
3849 unpost_menu(m);
3850 delwin(menuwin);
3851
3852 free_menu(m);
3853 for (ip = items; *ip; ip++)
3854 free_item(*ip);
3855 }
3856 #endif /* TRACE */
3857 #endif /* USE_LIBMENU */
3858
3859 /****************************************************************************
3860 *
3861 * Forms test
3862 *
3863 ****************************************************************************/
3864 #if USE_LIBFORM
3865 static FIELD *
3866 make_label(int frow, int fcol, NCURSES_CONST char *label)
3867 {
3868 FIELD *f = new_field(1, strlen(label), frow, fcol, 0, 0);
3869
3870 if (f) {
3871 set_field_buffer(f, 0, label);
3872 set_field_opts(f, field_opts(f) & ~O_ACTIVE);
3873 }
3874 return (f);
3875 }
3876
3877 static FIELD *
3878 make_field(int frow, int fcol, int rows, int cols, bool secure)
3879 {
3880 FIELD *f = new_field(rows, cols, frow, fcol, 0, secure ? 1 : 0);
3881
3882 if (f) {
3883 set_field_back(f, A_UNDERLINE);
3884 set_field_userptr(f, (void *) 0);
3885 }
3886 return (f);
3887 }
3888
3889 static void
3890 display_form(FORM * f)
3891 {
3892 WINDOW *w;
3893 int rows, cols;
3894
3895 scale_form(f, &rows, &cols);
3896
3897 if ((w = newwin(rows + 2, cols + 4, 0, 0)) != (WINDOW *) 0) {
3898 set_form_win(f, w);
3899 set_form_sub(f, derwin(w, rows, cols, 1, 2));
3900 box(w, 0, 0);
3901 keypad(w, TRUE);
3902 }
3903
3904 if (post_form(f) != E_OK)
3905 wrefresh(w);
3906 }
3907
3908 static void
3909 erase_form(FORM * f)
3910 {
3911 WINDOW *w = form_win(f);
3912 WINDOW *s = form_sub(f);
3913
3914 unpost_form(f);
3915 werase(w);
3916 wrefresh(w);
3917 delwin(s);
3918 delwin(w);
3919 }
3920
3921 static int
3922 edit_secure(FIELD * me, int c)
3923 {
3924 int rows, cols, frow, fcol, nrow, nbuf;
3925
3926 if (field_info(me, &rows, &cols, &frow, &fcol, &nrow, &nbuf) == E_OK
3927 && nbuf > 0) {
3928 char temp[80];
3929 long len;
3930
3931 strcpy(temp, field_buffer(me, 1));
3932 len = (long) (char *) field_userptr(me);
3933 if (c <= KEY_MAX) {
3934 if (isgraph(c)) {
3935 temp[len++] = c;
3936 temp[len] = 0;
3937 set_field_buffer(me, 1, temp);
3938 c = '*';
3939 } else {
3940 c = 0;
3941 }
3942 } else {
3943 switch (c) {
3944 case REQ_BEG_FIELD:
3945 case REQ_CLR_EOF:
3946 case REQ_CLR_EOL:
3947 case REQ_DEL_LINE:
3948 case REQ_DEL_WORD:
3949 case REQ_DOWN_CHAR:
3950 case REQ_END_FIELD:
3951 case REQ_INS_CHAR:
3952 case REQ_INS_LINE:
3953 case REQ_LEFT_CHAR:
3954 case REQ_NEW_LINE:
3955 case REQ_NEXT_WORD:
3956 case REQ_PREV_WORD:
3957 case REQ_RIGHT_CHAR:
3958 case REQ_UP_CHAR:
3959 c = 0; /* we don't want to do inline editing */
3960 break;
3961 case REQ_CLR_FIELD:
3962 if (len) {
3963 temp[0] = 0;
3964 set_field_buffer(me, 1, temp);
3965 }
3966 break;
3967 case REQ_DEL_CHAR:
3968 case REQ_DEL_PREV:
3969 if (len) {
3970 temp[--len] = 0;
3971 set_field_buffer(me, 1, temp);
3972 }
3973 break;
3974 }
3975 }
3976 set_field_userptr(me, (void *) len);
3977 }
3978 return c;
3979 }
3980
3981 static int
3982 form_virtualize(FORM * f, WINDOW *w)
3983 {
3984 static const struct {
3985 int code;
3986 int result;
3987 } lookup[] = {
3988 {
3989 CTRL('A'), REQ_NEXT_CHOICE
3990 },
3991 {
3992 CTRL('B'), REQ_PREV_WORD
3993 },
3994 {
3995 CTRL('C'), REQ_CLR_EOL
3996 },
3997 {
3998 CTRL('D'), REQ_DOWN_FIELD
3999 },
4000 {
4001 CTRL('E'), REQ_END_FIELD
4002 },
4003 {
4004 CTRL('F'), REQ_NEXT_PAGE
4005 },
4006 {
4007 CTRL('G'), REQ_DEL_WORD
4008 },
4009 {
4010 CTRL('H'), REQ_DEL_PREV
4011 },
4012 {
4013 CTRL('I'), REQ_INS_CHAR
4014 },
4015 {
4016 CTRL('K'), REQ_CLR_EOF
4017 },
4018 {
4019 CTRL('L'), REQ_LEFT_FIELD
4020 },
4021 {
4022 CTRL('M'), REQ_NEW_LINE
4023 },
4024 {
4025 CTRL('N'), REQ_NEXT_FIELD
4026 },
4027 {
4028 CTRL('O'), REQ_INS_LINE
4029 },
4030 {
4031 CTRL('P'), REQ_PREV_FIELD
4032 },
4033 {
4034 CTRL('R'), REQ_RIGHT_FIELD
4035 },
4036 {
4037 CTRL('S'), REQ_BEG_FIELD
4038 },
4039 {
4040 CTRL('U'), REQ_UP_FIELD
4041 },
4042 {
4043 CTRL('V'), REQ_DEL_CHAR
4044 },
4045 {
4046 CTRL('W'), REQ_NEXT_WORD
4047 },
4048 {
4049 CTRL('X'), REQ_CLR_FIELD
4050 },
4051 {
4052 CTRL('Y'), REQ_DEL_LINE
4053 },
4054 {
4055 CTRL('Z'), REQ_PREV_CHOICE
4056 },
4057 {
4058 ESCAPE, MAX_FORM_COMMAND + 1
4059 },
4060 {
4061 KEY_BACKSPACE, REQ_DEL_PREV
4062 },
4063 {
4064 KEY_DOWN, REQ_DOWN_CHAR
4065 },
4066 {
4067 KEY_END, REQ_LAST_FIELD
4068 },
4069 {
4070 KEY_HOME, REQ_FIRST_FIELD
4071 },
4072 {
4073 KEY_LEFT, REQ_LEFT_CHAR
4074 },
4075 {
4076 KEY_LL, REQ_LAST_FIELD
4077 },
4078 {
4079 KEY_NEXT, REQ_NEXT_FIELD
4080 },
4081 {
4082 KEY_NPAGE, REQ_NEXT_PAGE
4083 },
4084 {
4085 KEY_PPAGE, REQ_PREV_PAGE
4086 },
4087 {
4088 KEY_PREVIOUS, REQ_PREV_FIELD
4089 },
4090 {
4091 KEY_RIGHT, REQ_RIGHT_CHAR
4092 },
4093 {
4094 KEY_UP, REQ_UP_CHAR
4095 },
4096 {
4097 QUIT, MAX_FORM_COMMAND + 1
4098 }
4099 };
4100
4101 static int mode = REQ_INS_MODE;
4102 int c = wGetchar(w);
4103 unsigned n;
4104 FIELD *me = current_field(f);
4105
4106 if (c == CTRL(']')) {
4107 if (mode == REQ_INS_MODE)
4108 mode = REQ_OVL_MODE;
4109 else
4110 mode = REQ_INS_MODE;
4111 c = mode;
4112 } else {
4113 for (n = 0; n < SIZEOF(lookup); n++) {
4114 if (lookup[n].code == c) {
4115 c = lookup[n].result;
4116 break;
4117 }
4118 }
4119 }
4120
4121 /*
4122 * Force the field that the user is typing into to be in reverse video,
4123 * while the other fields are shown underlined.
4124 */
4125 if (c <= KEY_MAX) {
4126 c = edit_secure(me, c);
4127 set_field_back(me, A_REVERSE);
4128 } else if (c <= MAX_FORM_COMMAND) {
4129 c = edit_secure(me, c);
4130 set_field_back(me, A_UNDERLINE);
4131 }
4132 return c;
4133 }
4134
4135 static int
4136 my_form_driver(FORM * form, int c)
4137 {
4138 if (c == (MAX_FORM_COMMAND + 1)
4139 && form_driver(form, REQ_VALIDATION) == E_OK)
4140 return (TRUE);
4141 else {
4142 beep();
4143 return (FALSE);
4144 }
4145 }
4146
4147 /*
4148 * Allow a middle initial, optionally with a '.' to end it.
4149 */
4150 static bool
4151 mi_field_check(FIELD * fld, const void *data GCC_UNUSED)
4152 {
4153 char *s = field_buffer(fld, 0);
4154 int state = 0;
4155 int n;
4156
4157 for (n = 0; s[n] != '\0'; ++n) {
4158 switch (state) {
4159 case 0:
4160 if (s[n] == '.') {
4161 if (n != 1)
4162 return FALSE;
4163 state = 2;
4164 } else if (isspace(UChar(s[n]))) {
4165 state = 2;
4166 }
4167 break;
4168 case 2:
4169 if (!isspace(UChar(s[n])))
4170 return FALSE;
4171 break;
4172 }
4173 }
4174
4175 /* force the form to display a leading capital */
4176 if (islower(UChar(s[0]))) {
4177 s[0] = toupper(UChar(s[0]));
4178 set_field_buffer(fld, 0, s);
4179 }
4180 return TRUE;
4181 }
4182
4183 static bool
4184 mi_char_check(int ch, const void *data GCC_UNUSED)
4185 {
4186 return ((isalpha(ch) || ch == '.') ? TRUE : FALSE);
4187 }
4188
4189 /*
4190 * Passwords should be at least 6 characters.
4191 */
4192 static bool
4193 pw_field_check(FIELD * fld, const void *data GCC_UNUSED)
4194 {
4195 char *s = field_buffer(fld, 0);
4196 int n;
4197
4198 for (n = 0; s[n] != '\0'; ++n) {
4199 if (isspace(UChar(s[n]))) {
4200 if (n < 6)
4201 return FALSE;
4202 }
4203 }
4204 return TRUE;
4205 }
4206
4207 static bool
4208 pw_char_check(int ch, const void *data GCC_UNUSED)
4209 {
4210 return (isgraph(ch) ? TRUE : FALSE);
4211 }
4212
4213 static void
4214 demo_forms(void)
4215 {
4216 WINDOW *w;
4217 FORM *form;
4218 FIELD *f[12], *secure;
4219 FIELDTYPE *fty_middle = new_fieldtype(mi_field_check, mi_char_check);
4220 FIELDTYPE *fty_passwd = new_fieldtype(pw_field_check, pw_char_check);
4221 int finished = 0, c;
4222 unsigned n = 0;
4223
4224 move(18, 0);
4225 addstr("Defined form-traversal keys: ^Q/ESC- exit form\n");
4226 addstr("^N -- go to next field ^P -- go to previous field\n");
4227 addstr("Home -- go to first field End -- go to last field\n");
4228 addstr("^L -- go to field to left ^R -- go to field to right\n");
4229 addstr("^U -- move upward to field ^D -- move downward to field\n");
4230 addstr("^W -- go to next word ^B -- go to previous word\n");
4231 addstr("^S -- go to start of field ^E -- go to end of field\n");
4232 addstr("^H -- delete previous char ^Y -- delete line\n");
4233 addstr("^G -- delete current word ^C -- clear to end of line\n");
4234 addstr("^K -- clear to end of field ^X -- clear field\n");
4235 addstr("Arrow keys move within a field as you would expect.");
4236
4237 mvaddstr(4, 57, "Forms Entry Test");
4238
4239 refresh();
4240
4241 /* describe the form */
4242 f[n++] = make_label(0, 15, "Sample Form");
4243
4244 f[n++] = make_label(2, 0, "Last Name");
4245 f[n++] = make_field(3, 0, 1, 18, FALSE);
4246 set_field_type(f[n - 1], TYPE_ALPHA, 1);
4247
4248 f[n++] = make_label(2, 20, "First Name");
4249 f[n++] = make_field(3, 20, 1, 12, FALSE);
4250 set_field_type(f[n - 1], TYPE_ALPHA, 1);
4251
4252 f[n++] = make_label(2, 34, "Middle Name");
4253 f[n++] = make_field(3, 34, 1, 12, FALSE);
4254 set_field_type(f[n - 1], fty_middle);
4255
4256 f[n++] = make_label(5, 0, "Comments");
4257 f[n++] = make_field(6, 0, 4, 46, FALSE);
4258
4259 f[n++] = make_label(5, 20, "Password:");
4260 secure =
4261 f[n++] = make_field(5, 30, 1, 9, TRUE);
4262 set_field_type(f[n - 1], fty_passwd);
4263 f[n++] = (FIELD *) 0;
4264
4265 form = new_form(f);
4266
4267 display_form(form);
4268
4269 w = form_win(form);
4270 raw();
4271 nonl(); /* lets us read ^M's */
4272 while (!finished) {
4273 switch (form_driver(form, c = form_virtualize(form, w))) {
4274 case E_OK:
4275 mvaddstr(5, 57, field_buffer(secure, 1));
4276 clrtoeol();
4277 refresh();
4278 break;
4279 case E_UNKNOWN_COMMAND:
4280 finished = my_form_driver(form, c);
4281 break;
4282 default:
4283 beep();
4284 break;
4285 }
4286 }
4287
4288 erase_form(form);
4289
4290 free_form(form);
4291 for (c = 0; f[c] != 0; c++)
4292 free_field(f[c]);
4293 noraw();
4294 nl();
4295 }
4296 #endif /* USE_LIBFORM */
4297
4298 /****************************************************************************
4299 *
4300 * Overlap test
4301 *
4302 ****************************************************************************/
4303
4304 static void
4305 fillwin(WINDOW *win, char ch)
4306 {
4307 int y, x;
4308 int y1, x1;
4309
4310 getmaxyx(win, y1, x1);
4311 for (y = 0; y < y1; y++) {
4312 wmove(win, y, 0);
4313 for (x = 0; x < x1; x++)
4314 waddch(win, ch);
4315 }
4316 }
4317
4318 static void
4319 crosswin(WINDOW *win, char ch)
4320 {
4321 int y, x;
4322 int y1, x1;
4323
4324 getmaxyx(win, y1, x1);
4325 for (y = 0; y < y1; y++) {
4326 for (x = 0; x < x1; x++)
4327 if (((x > (x1 - 1) / 3) && (x <= (2 * (x1 - 1)) / 3))
4328 || (((y > (y1 - 1) / 3) && (y <= (2 * (y1 - 1)) / 3)))) {
4329 wmove(win, y, x);
4330 waddch(win, ch);
4331 }
4332 }
4333 }
4334
4335 static void
4336 overlap_test(void)
4337 /* test effects of overlapping windows */
4338 {
4339 int ch;
4340
4341 WINDOW *win1 = newwin(9, 20, 3, 3);
4342 WINDOW *win2 = newwin(9, 20, 9, 16);
4343
4344 raw();
4345 refresh();
4346 move(0, 0);
4347 printw("This test shows the behavior of wnoutrefresh() with respect to\n");
4348 printw("the shared region of two overlapping windows A and B. The cross\n");
4349 printw("pattern in each window does not overlap the other.\n");
4350
4351 move(18, 0);
4352 printw("a = refresh A, then B, then doupdate. b = refresh B, then A, then doupdaute\n");
4353 printw("c = fill window A with letter A. d = fill window B with letter B.\n");
4354 printw("e = cross pattern in window A. f = cross pattern in window B.\n");
4355 printw("g = clear window A. h = clear window B.\n");
4356 printw("i = overwrite A onto B. j = overwrite B onto A.\n");
4357 printw("^Q/ESC = terminate test.");
4358
4359 while ((ch = Getchar()) != QUIT && ch != ESCAPE)
4360 switch (ch) {
4361 case 'a': /* refresh window A first, then B */
4362 wnoutrefresh(win1);
4363 wnoutrefresh(win2);
4364 doupdate();
4365 break;
4366
4367 case 'b': /* refresh window B first, then A */
4368 wnoutrefresh(win2);
4369 wnoutrefresh(win1);
4370 doupdate();
4371 break;
4372
4373 case 'c': /* fill window A so it's visible */
4374 fillwin(win1, 'A');
4375 break;
4376
4377 case 'd': /* fill window B so it's visible */
4378 fillwin(win2, 'B');
4379 break;
4380
4381 case 'e': /* cross test pattern in window A */
4382 crosswin(win1, 'A');
4383 break;
4384
4385 case 'f': /* cross test pattern in window A */
4386 crosswin(win2, 'B');
4387 break;
4388
4389 case 'g': /* clear window A */
4390 wclear(win1);
4391 wmove(win1, 0, 0);
4392 break;
4393
4394 case 'h': /* clear window B */
4395 wclear(win2);
4396 wmove(win2, 0, 0);
4397 break;
4398
4399 case 'i': /* overwrite A onto B */
4400 overwrite(win1, win2);
4401 break;
4402
4403 case 'j': /* overwrite B onto A */
4404 overwrite(win2, win1);
4405 break;
4406 }
4407
4408 delwin(win2);
4409 delwin(win1);
4410 erase();
4411 endwin();
4412 }
4413
4414 /****************************************************************************
4415 *
4416 * Main sequence
4417 *
4418 ****************************************************************************/
4419
4420 static bool
4421 do_single_test(const char c)
4422 /* perform a single specified test */
4423 {
4424 switch (c) {
4425 case 'a':
4426 getch_test();
4427 break;
4428
4429 #if USE_WIDEC_SUPPORT
4430 case 'A':
4431 get_wch_test();
4432 break;
4433 #endif
4434
4435 case 'b':
4436 attr_test();
4437 break;
4438
4439 case 'c':
4440 if (!has_colors())
4441 Cannot("does not support color.");
4442 else
4443 color_test();
4444 break;
4445
4446 case 'd':
4447 if (!has_colors())
4448 Cannot("does not support color.");
4449 else if (!can_change_color())
4450 Cannot("has hardwired color values.");
4451 else
4452 color_edit();
4453 break;
4454
4455 case 'e':
4456 slk_test();
4457 break;
4458
4459 #if USE_WIDEC_SUPPORT
4460 case 'E':
4461 wide_slk_test();
4462 break;
4463 #endif
4464 case 'f':
4465 acs_display();
4466 break;
4467
4468 #if USE_WIDEC_SUPPORT
4469 case 'F':
4470 wide_acs_display();
4471 break;
4472 #endif
4473
4474 #if USE_LIBPANEL
4475 case 'o':
4476 demo_panels();
4477 break;
4478 #endif
4479
4480 case 'g':
4481 acs_and_scroll();
4482 break;
4483
4484 case 'i':
4485 flushinp_test(stdscr);
4486 break;
4487
4488 case 'k':
4489 test_sgr_attributes();
4490 break;
4491
4492 #if USE_LIBMENU
4493 case 'm':
4494 menu_test();
4495 break;
4496 #endif
4497
4498 #if USE_LIBPANEL
4499 case 'p':
4500 demo_pad();
4501 break;
4502 #endif
4503
4504 #if USE_LIBFORM
4505 case 'r':
4506 demo_forms();
4507 break;
4508 #endif
4509
4510 case 's':
4511 overlap_test();
4512 break;
4513
4514 #if USE_LIBMENU && defined(TRACE)
4515 case 't':
4516 trace_set();
4517 break;
4518 #endif
4519
4520 case '?':
4521 break;
4522
4523 default:
4524 return FALSE;
4525 }
4526
4527 return TRUE;
4528 }
4529
4530 static void
4531 usage(void)
4532 {
4533 static const char *const tbl[] =
4534 {
4535 "Usage: ncurses [options]"
4536 ,""
4537 ,"Options:"
4538 #ifdef NCURSES_VERSION
4539 ," -a f,b set default-colors (assumed white-on-black)"
4540 ," -d use default-colors if terminal supports them"
4541 #endif
4542 ," -e fmt specify format for soft-keys test (e)"
4543 ," -f rip-off footer line (can repeat)"
4544 ," -h rip-off header line (can repeat)"
4545 ," -s msec specify nominal time for panel-demo (default: 1, to hold)"
4546 #ifdef TRACE
4547 ," -t mask specify default trace-level (may toggle with ^T)"
4548 #endif
4549 };
4550 size_t n;
4551 for (n = 0; n < SIZEOF(tbl); n++)
4552 fprintf(stderr, "%s\n", tbl[n]);
4553 ExitProgram(EXIT_FAILURE);
4554 }
4555
4556 static void
4557 set_terminal_modes(void)
4558 {
4559 noraw();
4560 cbreak();
4561 noecho();
4562 scrollok(stdscr, TRUE);
4563 idlok(stdscr, TRUE);
4564 keypad(stdscr, TRUE);
4565 }
4566
4567 #ifdef SIGUSR1
4568 static RETSIGTYPE
4569 announce_sig(int sig)
4570 {
4571 (void) fprintf(stderr, "Handled signal %d\r\n", sig);
4572 }
4573 #endif
4574
4575 static int
4576 rip_footer(WINDOW *win, int cols)
4577 {
4578 wbkgd(win, A_REVERSE);
4579 werase(win);
4580 wmove(win, 0, 0);
4581 wprintw(win, "footer: %d columns", cols);
4582 wnoutrefresh(win);
4583 return OK;
4584 }
4585
4586 static int
4587 rip_header(WINDOW *win, int cols)
4588 {
4589 wbkgd(win, A_REVERSE);
4590 werase(win);
4591 wmove(win, 0, 0);
4592 wprintw(win, "header: %d columns", cols);
4593 wnoutrefresh(win);
4594 return OK;
4595 }
4596
4597 /*+-------------------------------------------------------------------------
4598 main(argc,argv)
4599 --------------------------------------------------------------------------*/
4600
4601 int
4602 main(int argc, char *argv[])
4603 {
4604 int command, c;
4605 int my_e_param = 1;
4606 #ifdef NCURSES_VERSION
4607 int default_fg = COLOR_WHITE;
4608 int default_bg = COLOR_BLACK;
4609 bool assumed_colors = FALSE;
4610 bool default_colors = FALSE;
4611 #endif
4612
4613 setlocale(LC_ALL, "");
4614
4615 while ((c = getopt(argc, argv, "a:de:fhs:t:")) != EOF) {
4616 switch (c) {
4617 #ifdef NCURSES_VERSION
4618 case 'a':
4619 assumed_colors = TRUE;
4620 sscanf(optarg, "%d,%d", &default_fg, &default_bg);
4621 break;
4622 case 'd':
4623 default_colors = TRUE;
4624 break;
4625 #endif
4626 case 'e':
4627 my_e_param = atoi(optarg);
4628 #ifdef NCURSES_VERSION
4629 if (my_e_param > 3) /* allow extended layouts */
4630 usage();
4631 #else
4632 if (my_e_param > 1)
4633 usage();
4634 #endif
4635 break;
4636 case 'f':
4637 ripoffline(-1, rip_footer);
4638 break;
4639 case 'h':
4640 ripoffline(1, rip_header);
4641 break;
4642 #if USE_LIBPANEL
4643 case 's':
4644 nap_msec = atol(optarg);
4645 break;
4646 #endif
4647 #ifdef TRACE
4648 case 't':
4649 save_trace = atoi(optarg);
4650 break;
4651 #endif
4652 default:
4653 usage();
4654 }
4655 }
4656
4657 /*
4658 * If there's no menus (unlikely for ncurses!), then we'll have to set
4659 * tracing on initially, just in case the user wants to test something that
4660 * doesn't involve wGetchar.
4661 */
4662 #ifdef TRACE
4663 /* enable debugging */
4664 #if !USE_LIBMENU
4665 trace(save_trace);
4666 #else
4667 if (!isatty(fileno(stdin)))
4668 trace(save_trace);
4669 #endif /* USE_LIBMENU */
4670 #endif /* TRACE */
4671
4672 /* tell it we're going to play with soft keys */
4673 slk_init(my_e_param);
4674
4675 #ifdef SIGUSR1
4676 /* set up null signal catcher so we can see what interrupts to getch do */
4677 signal(SIGUSR1, announce_sig);
4678 #endif
4679
4680 /* we must initialize the curses data structure only once */
4681 initscr();
4682 bkgdset(BLANK);
4683
4684 /* tests, in general, will want these modes */
4685 if (has_colors()) {
4686 start_color();
4687 #ifdef NCURSES_VERSION_PATCH
4688 max_colors = COLORS > 16 ? 16 : COLORS;
4689 #if HAVE_USE_DEFAULT_COLORS
4690 if (default_colors)
4691 use_default_colors();
4692 #if NCURSES_VERSION_PATCH >= 20000708
4693 else if (assumed_colors)
4694 assume_default_colors(default_fg, default_bg);
4695 #endif
4696 #endif
4697 #else /* normal SVr4 curses */
4698 max_colors = COLORS > 8 ? 8 : COLORS;
4699 #endif
4700 max_pairs = (max_colors * max_colors);
4701 if (max_pairs < COLOR_PAIRS)
4702 max_pairs = COLOR_PAIRS;
4703 }
4704 set_terminal_modes();
4705 def_prog_mode();
4706
4707 /*
4708 * Return to terminal mode, so we're guaranteed of being able to
4709 * select terminal commands even if the capabilities are wrong.
4710 */
4711 endwin();
4712
4713 #if HAVE_CURSES_VERSION
4714 (void) printf("Welcome to %s. Press ? for help.\n", curses_version());
4715 #elif defined(NCURSES_VERSION_MAJOR) && defined(NCURSES_VERSION_MINOR) && defined(NCURSES_VERSION_PATCH)
4716 (void) printf("Welcome to ncurses %d.%d.%d. Press ? for help.\n",
4717 NCURSES_VERSION_MAJOR,
4718 NCURSES_VERSION_MINOR,
4719 NCURSES_VERSION_PATCH);
4720 #else
4721 (void) puts("Welcome to ncurses. Press ? for help.");
4722 #endif
4723
4724 do {
4725 (void) puts("This is the ncurses main menu");
4726 (void) puts("a = keyboard and mouse input test");
4727 #if USE_WIDEC_SUPPORT
4728 (void) puts("A = wide-character keyboard and mouse input test");
4729 #endif
4730 (void) puts("b = character attribute test");
4731 (void) puts("c = color test pattern");
4732 (void) puts("d = edit RGB color values");
4733 (void) puts("e = exercise soft keys");
4734 #if USE_WIDEC_SUPPORT
4735 (void) puts("E = exercise soft keys using wide-characters");
4736 #endif
4737 (void) puts("f = display ACS characters");
4738 #if USE_WIDEC_SUPPORT
4739 (void) puts("F = display Wide-ACS characters");
4740 #endif
4741 (void) puts("g = display windows and scrolling");
4742 (void) puts("i = test of flushinp()");
4743 (void) puts("k = display character attributes");
4744 #if USE_LIBMENU
4745 (void) puts("m = menu code test");
4746 #endif
4747 #if USE_LIBPANEL
4748 (void) puts("o = exercise panels library");
4749 (void) puts("p = exercise pad features");
4750 (void) puts("q = quit");
4751 #endif
4752 #if USE_LIBFORM
4753 (void) puts("r = exercise forms code");
4754 #endif
4755 (void) puts("s = overlapping-refresh test");
4756 #if USE_LIBMENU && defined(TRACE)
4757 (void) puts("t = set trace level");
4758 #endif
4759 (void) puts("? = repeat this command summary");
4760
4761 (void) fputs("> ", stdout);
4762 (void) fflush(stdout); /* necessary under SVr4 curses */
4763
4764 /*
4765 * This used to be an 'fgets()' call. However (on Linux, at least)
4766 * mixing stream I/O and 'read()' (used in the library) causes the
4767 * input stream to be flushed when switching between the two.
4768 */
4769 command = 0;
4770 for (;;) {
4771 char ch;
4772 if (read(fileno(stdin), &ch, 1) <= 0) {
4773 if (command == 0)
4774 command = 'q';
4775 break;
4776 } else if (command == 0 && !isspace(UChar(ch))) {
4777 command = ch;
4778 } else if (ch == '\n' || ch == '\r') {
4779 if (command != 0)
4780 break;
4781 (void) fputs("> ", stdout);
4782 (void) fflush(stdout);
4783 }
4784 }
4785
4786 if (do_single_test(command)) {
4787 /*
4788 * This may be overkill; it's intended to reset everything back
4789 * to the initial terminal modes so that tests don't get in
4790 * each other's way.
4791 */
4792 flushinp();
4793 set_terminal_modes();
4794 reset_prog_mode();
4795 clear();
4796 refresh();
4797 endwin();
4798 if (command == '?') {
4799 (void) puts("This is the ncurses capability tester.");
4800 (void)
4801 puts("You may select a test from the main menu by typing the");
4802 (void)
4803 puts("key letter of the choice (the letter to left of the =)");
4804 (void)
4805 puts("at the > prompt. The commands `x' or `q' will exit.");
4806 }
4807 continue;
4808 }
4809 } while
4810 (command != 'q');
4811
4812 ExitProgram(EXIT_SUCCESS);
4813 }
4814
4815 /* ncurses.c ends here */
DragonFly BSD