ncurses 6.0 - patch 20160312
[ncurses.git] / test / ncurses.c
1 /****************************************************************************
2  * Copyright (c) 1998-2015,2016 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.429 2016/01/03 01:50:10 tom Exp $
44
45 ***************************************************************************/
46
47 #include <test.priv.h>
48
49 #ifdef __hpux
50 #undef mvwdelch                 /* HPUX 11.23 macro will not compile */
51 #endif
52
53 #if HAVE_GETTIMEOFDAY
54 #if HAVE_SYS_TIME_H && HAVE_SYS_TIME_SELECT
55 #include <sys/time.h>
56 #endif
57 #if HAVE_SYS_SELECT_H
58 #include <sys/select.h>
59 #endif
60 #endif
61
62 #if USE_LIBPANEL
63 #include <panel.h>
64 #endif
65
66 #if USE_LIBMENU
67 #include <menu.h>
68 #endif
69
70 #if USE_LIBFORM
71 #include <form.h>
72 #endif
73
74 #ifdef NCURSES_VERSION
75
76 #define NCURSES_CONST_PARAM const void
77
78 #ifdef TRACE
79 static unsigned save_trace = TRACE_ORDINARY | TRACE_ICALLS | TRACE_CALLS;
80 extern unsigned _nc_tracing;
81 #endif
82
83 #else
84
85 #define NCURSES_CONST_PARAM char
86
87 #define mmask_t chtype          /* not specified in XSI */
88
89 #ifndef ACS_S3
90 #ifdef CURSES_ACS_ARRAY
91 #define ACS_S3          (CURSES_ACS_ARRAY['p'])         /* scan line 3 */
92 #define ACS_S7          (CURSES_ACS_ARRAY['r'])         /* scan line 7 */
93 #define ACS_LEQUAL      (CURSES_ACS_ARRAY['y'])         /* less/equal */
94 #define ACS_GEQUAL      (CURSES_ACS_ARRAY['z'])         /* greater/equal */
95 #define ACS_PI          (CURSES_ACS_ARRAY['{'])         /* Pi */
96 #define ACS_NEQUAL      (CURSES_ACS_ARRAY['|'])         /* not equal */
97 #define ACS_STERLING    (CURSES_ACS_ARRAY['}'])         /* UK pound sign */
98 #else
99 #define ACS_S3          (A_ALTCHARSET + 'p')    /* scan line 3 */
100 #define ACS_S7          (A_ALTCHARSET + 'r')    /* scan line 7 */
101 #define ACS_LEQUAL      (A_ALTCHARSET + 'y')    /* less/equal */
102 #define ACS_GEQUAL      (A_ALTCHARSET + 'z')    /* greater/equal */
103 #define ACS_PI          (A_ALTCHARSET + '{')    /* Pi */
104 #define ACS_NEQUAL      (A_ALTCHARSET + '|')    /* not equal */
105 #define ACS_STERLING    (A_ALTCHARSET + '}')    /* UK pound sign */
106 #endif
107 #endif /* ACS_S3 */
108
109 #ifndef WACS_S3
110 #ifdef CURSES_WACS_ARRAY
111 #define WACS_S3         (&(CURSES_WACS_ARRAY['p']))     /* scan line 3 */
112 #define WACS_S7         (&(CURSES_WACS_ARRAY['r']))     /* scan line 7 */
113 #define WACS_LEQUAL     (&(CURSES_WACS_ARRAY['y']))     /* less/equal */
114 #define WACS_GEQUAL     (&(CURSES_WACS_ARRAY['z']))     /* greater/equal */
115 #define WACS_PI         (&(CURSES_WACS_ARRAY['{']))     /* Pi */
116 #define WACS_NEQUAL     (&(CURSES_WACS_ARRAY['|']))     /* not equal */
117 #define WACS_STERLING   (&(CURSES_WACS_ARRAY['}']))     /* UK pound sign */
118 #endif
119 #endif
120
121 #endif
122
123 #if HAVE_WCSRTOMBS
124 #define count_wchars(src, len, state)      wcsrtombs(0,   &src, len, state)
125 #define trans_wchars(dst, src, len, state) wcsrtombs(dst, &src, len, state)
126 #define reset_wchars(state) init_mb(state)
127 #elif HAVE_WCSTOMBS && HAVE_MBTOWC && HAVE_MBLEN
128 #define count_wchars(src, len, state)      wcstombs(0,   src, len)
129 #define trans_wchars(dst, src, len, state) wcstombs(dst, src, len)
130 #define reset_wchars(state) IGNORE_RC(mblen(NULL, 0)), IGNORE_RC(mbtowc(NULL, NULL, 0))
131 #define state_unused
132 #endif
133
134 #if HAVE_MBSRTOWCS
135 #define count_mbytes(src, len, state)      mbsrtowcs(0,   &src, len, state)
136 #define trans_mbytes(dst, src, len, state) mbsrtowcs(dst, &src, len, state)
137 #define reset_mbytes(state) init_mb(state)
138 #elif HAVE_MBSTOWCS && HAVE_MBTOWC && HAVE_MBLEN
139 #define count_mbytes(src, len, state)      mbstowcs(0,   src, len)
140 #define trans_mbytes(dst, src, len, state) mbstowcs(dst, src, len)
141 #define reset_mbytes(state) IGNORE_RC(mblen(NULL, 0)), IGNORE_RC(mbtowc(NULL, NULL, 0))
142 #define state_unused
143 #endif
144
145 #define ToggleAcs(temp,real) temp = ((temp == real) ? 0 : real)
146
147 #define P(string)       printw("%s\n", string)
148
149 #define BLANK           ' '     /* this is the background character */
150
151 #undef max_colors
152 static int max_colors;          /* the actual number of colors we'll use */
153 static int min_colors;          /* the minimum color code */
154 static bool use_colors;         /* true if we use colors */
155
156 #undef max_pairs
157 static int max_pairs;           /* ...and the number of color pairs */
158
159 typedef struct {
160     NCURSES_COLOR_T red;
161     NCURSES_COLOR_T green;
162     NCURSES_COLOR_T blue;
163 } RGB_DATA;
164
165 static RGB_DATA *all_colors;
166
167 static void main_menu(bool);
168
169 static void
170 failed(const char *s)
171 {
172     perror(s);
173     endwin();
174     ExitProgram(EXIT_FAILURE);
175 }
176
177 /* The behavior of mvhline, mvvline for negative/zero length is unspecified,
178  * though we can rely on negative x/y values to stop the macro.
179  */
180 static void
181 do_h_line(int y, int x, chtype c, int to)
182 {
183     if ((to) > (x))
184         MvHLine(y, x, c, (to) - (x));
185 }
186
187 static void
188 do_v_line(int y, int x, chtype c, int to)
189 {
190     if ((to) > (y))
191         MvVLine(y, x, c, (to) - (y));
192 }
193
194 static void
195 Repaint(void)
196 {
197     touchwin(stdscr);
198     touchwin(curscr);
199     wrefresh(curscr);
200 }
201
202 static bool
203 isQuit(int c)
204 {
205     return ((c) == QUIT || (c) == ESCAPE);
206 }
207 #define case_QUIT       QUIT: case ESCAPE
208
209 /* Common function to allow ^T to toggle trace-mode in the middle of a test
210  * so that trace-files can be made smaller.
211  */
212 static int
213 wGetchar(WINDOW *win)
214 {
215     int c;
216 #ifdef TRACE
217     while ((c = wgetch(win)) == CTRL('T')) {
218         if (_nc_tracing) {
219             save_trace = _nc_tracing;
220             Trace(("TOGGLE-TRACING OFF"));
221             _nc_tracing = 0;
222         } else {
223             _nc_tracing = save_trace;
224         }
225         trace(_nc_tracing);
226         if (_nc_tracing)
227             Trace(("TOGGLE-TRACING ON"));
228     }
229 #else
230     c = wgetch(win);
231 #endif
232     return c;
233 }
234 #define Getchar() wGetchar(stdscr)
235
236 /* replaces wgetnstr(), since we want to be able to edit values */
237 static void
238 wGetstring(WINDOW *win, char *buffer, int limit)
239 {
240     int y0, x0, x, ch;
241     bool done = FALSE;
242
243     echo();
244     getyx(win, y0, x0);
245     (void) wattrset(win, A_REVERSE);
246
247     x = (int) strlen(buffer);
248     while (!done) {
249         if (x > (int) strlen(buffer))
250             x = (int) strlen(buffer);
251         wmove(win, y0, x0);
252         wprintw(win, "%-*s", limit, buffer);
253         wmove(win, y0, x0 + x);
254         switch (ch = wGetchar(win)) {
255         case '\n':
256         case KEY_ENTER:
257             done = TRUE;
258             break;
259         case CTRL('U'):
260             *buffer = '\0';
261             break;
262         case '\b':
263         case KEY_BACKSPACE:
264         case KEY_DC:
265             if (x > 0) {
266                 int j;
267                 for (j = --x; (buffer[j] = buffer[j + 1]) != '\0'; ++j) {
268                     ;
269                 }
270             } else {
271                 beep();
272             }
273             break;
274         case KEY_LEFT:
275             if (x > 0) {
276                 --x;
277             } else {
278                 flash();
279             }
280             break;
281         case KEY_RIGHT:
282             ++x;
283             break;
284         default:
285             if (!isprint(ch) || ch >= KEY_MIN) {
286                 beep();
287             } else if ((int) strlen(buffer) < limit) {
288                 int j;
289                 for (j = (int) strlen(buffer) + 1; j > x; --j) {
290                     buffer[j] = buffer[j - 1];
291                 }
292                 buffer[x++] = (char) ch;
293             } else {
294                 flash();
295             }
296         }
297     }
298
299     wattroff(win, A_REVERSE);
300     wmove(win, y0, x0);
301     noecho();
302 }
303
304 #if USE_WIDEC_SUPPORT
305 static wchar_t
306 fullwidth_digit(int ch)
307 {
308     return (wchar_t) (ch + 0xff10 - '0');
309 }
310
311 static void
312 make_fullwidth_text(wchar_t *target, const char *source)
313 {
314     int ch;
315     while ((ch = *source++) != 0) {
316         *target++ = fullwidth_digit(ch);
317     }
318     *target = 0;
319 }
320
321 static void
322 make_narrow_text(wchar_t *target, const char *source)
323 {
324     int ch;
325     while ((ch = *source++) != 0) {
326         *target++ = (wchar_t) ch;
327     }
328     *target = 0;
329 }
330
331 #if USE_LIBPANEL
332 static void
333 make_fullwidth_digit(cchar_t *target, int digit)
334 {
335     wchar_t source[2];
336
337     source[0] = fullwidth_digit(digit + '0');
338     source[1] = 0;
339     setcchar(target, source, A_NORMAL, 0, 0);
340 }
341 #endif
342
343 static int
344 wGet_wchar(WINDOW *win, wint_t *result)
345 {
346     int c;
347 #ifdef TRACE
348     while ((c = wget_wch(win, result)) == CTRL('T')) {
349         if (_nc_tracing) {
350             save_trace = _nc_tracing;
351             Trace(("TOGGLE-TRACING OFF"));
352             _nc_tracing = 0;
353         } else {
354             _nc_tracing = save_trace;
355         }
356         trace(_nc_tracing);
357         if (_nc_tracing)
358             Trace(("TOGGLE-TRACING ON"));
359     }
360 #else
361     c = wget_wch(win, result);
362 #endif
363     return c;
364 }
365 #define Get_wchar(result) wGet_wchar(stdscr, result)
366
367 /* replaces wgetn_wstr(), since we want to be able to edit values */
368 static void
369 wGet_wstring(WINDOW *win, wchar_t *buffer, int limit)
370 {
371     int y0, x0, x;
372     wint_t ch;
373     bool done = FALSE;
374     bool fkey = FALSE;
375
376     echo();
377     getyx(win, y0, x0);
378     (void) wattrset(win, A_REVERSE);
379
380     x = (int) wcslen(buffer);
381     while (!done) {
382         if (x > (int) wcslen(buffer))
383             x = (int) wcslen(buffer);
384
385         /* clear the "window' */
386         wmove(win, y0, x0);
387         wprintw(win, "%*s", limit, " ");
388
389         /* write the existing buffer contents */
390         wmove(win, y0, x0);
391         waddnwstr(win, buffer, limit);
392
393         /* positions the cursor past character 'x' */
394         wmove(win, y0, x0);
395         waddnwstr(win, buffer, x);
396
397         switch (wGet_wchar(win, &ch)) {
398         case KEY_CODE_YES:
399             fkey = TRUE;
400             switch (ch) {
401             case KEY_ENTER:
402                 ch = '\n';
403                 fkey = FALSE;
404                 break;
405             case KEY_BACKSPACE:
406             case KEY_DC:
407                 ch = '\b';
408                 fkey = FALSE;
409                 break;
410             case KEY_LEFT:
411             case KEY_RIGHT:
412                 break;
413             default:
414                 ch = (wint_t) -1;
415                 break;
416             }
417             break;
418         case OK:
419             fkey = FALSE;
420             break;
421         default:
422             ch = (wint_t) -1;
423             fkey = TRUE;
424             break;
425         }
426
427         switch (ch) {
428         case '\n':
429             done = TRUE;
430             break;
431         case CTRL('U'):
432             *buffer = '\0';
433             break;
434         case '\b':
435             if (x > 0) {
436                 int j;
437                 for (j = --x; (buffer[j] = buffer[j + 1]) != '\0'; ++j) {
438                     ;
439                 }
440             } else {
441                 beep();
442             }
443             break;
444         case KEY_LEFT:
445             if (x > 0) {
446                 --x;
447             } else {
448                 beep();
449             }
450             break;
451         case KEY_RIGHT:
452             ++x;
453             break;
454         default:
455             if (fkey) {
456                 beep();
457             } else if ((int) wcslen(buffer) < limit) {
458                 int j;
459                 for (j = (int) wcslen(buffer) + 1; j > x; --j) {
460                     buffer[j] = buffer[j - 1];
461                 }
462                 buffer[x++] = (wchar_t) ch;
463             } else {
464                 beep();
465             }
466         }
467     }
468
469     wattroff(win, A_REVERSE);
470     wmove(win, y0, x0);
471     noecho();
472 }
473
474 #endif
475
476 static void
477 Pause(void)
478 {
479     move(LINES - 1, 0);
480     addstr("Press any key to continue... ");
481     (void) Getchar();
482 }
483
484 static void
485 Cannot(const char *what)
486 {
487     printw("\nThis %s terminal %s\n\n", getenv("TERM"), what);
488     Pause();
489 }
490
491 static void
492 ShellOut(bool message)
493 {
494     if (message)
495         addstr("Shelling out...");
496     def_prog_mode();
497     endwin();
498 #ifdef __MINGW32__
499     system("cmd.exe");
500 #else
501     IGNORE_RC(system("sh"));
502 #endif
503     if (message)
504         addstr("returned from shellout.\n");
505     refresh();
506 }
507
508 #ifdef NCURSES_MOUSE_VERSION
509 /*
510  * This function is the same as _tracemouse(), but we cannot count on that
511  * being available in the non-debug library.
512  */
513 static const char *
514 mouse_decode(MEVENT const *ep)
515 {
516     static char buf[80 + (5 * 10) + (32 * 15)];
517
518     (void) sprintf(buf, "id %2d at (%2d, %2d, %d) state %4lx = {",
519                    ep->id, ep->x, ep->y, ep->z, (unsigned long) ep->bstate);
520
521 #define SHOW(m, s) if ((ep->bstate & m)==m) {strcat(buf,s); strcat(buf, ", ");}
522
523     SHOW(BUTTON1_RELEASED, "release-1");
524     SHOW(BUTTON1_PRESSED, "press-1");
525     SHOW(BUTTON1_CLICKED, "click-1");
526     SHOW(BUTTON1_DOUBLE_CLICKED, "doubleclick-1");
527     SHOW(BUTTON1_TRIPLE_CLICKED, "tripleclick-1");
528 #if NCURSES_MOUSE_VERSION == 1
529     SHOW(BUTTON1_RESERVED_EVENT, "reserved-1");
530 #endif
531
532     SHOW(BUTTON2_RELEASED, "release-2");
533     SHOW(BUTTON2_PRESSED, "press-2");
534     SHOW(BUTTON2_CLICKED, "click-2");
535     SHOW(BUTTON2_DOUBLE_CLICKED, "doubleclick-2");
536     SHOW(BUTTON2_TRIPLE_CLICKED, "tripleclick-2");
537 #if NCURSES_MOUSE_VERSION == 1
538     SHOW(BUTTON2_RESERVED_EVENT, "reserved-2");
539 #endif
540
541     SHOW(BUTTON3_RELEASED, "release-3");
542     SHOW(BUTTON3_PRESSED, "press-3");
543     SHOW(BUTTON3_CLICKED, "click-3");
544     SHOW(BUTTON3_DOUBLE_CLICKED, "doubleclick-3");
545     SHOW(BUTTON3_TRIPLE_CLICKED, "tripleclick-3");
546 #if NCURSES_MOUSE_VERSION == 1
547     SHOW(BUTTON3_RESERVED_EVENT, "reserved-3");
548 #endif
549
550     SHOW(BUTTON4_RELEASED, "release-4");
551     SHOW(BUTTON4_PRESSED, "press-4");
552     SHOW(BUTTON4_CLICKED, "click-4");
553     SHOW(BUTTON4_DOUBLE_CLICKED, "doubleclick-4");
554     SHOW(BUTTON4_TRIPLE_CLICKED, "tripleclick-4");
555 #if NCURSES_MOUSE_VERSION == 1
556     SHOW(BUTTON4_RESERVED_EVENT, "reserved-4");
557 #endif
558
559 #if NCURSES_MOUSE_VERSION == 2
560     SHOW(BUTTON5_RELEASED, "release-5");
561     SHOW(BUTTON5_PRESSED, "press-5");
562     SHOW(BUTTON5_CLICKED, "click-5");
563     SHOW(BUTTON5_DOUBLE_CLICKED, "doubleclick-5");
564     SHOW(BUTTON5_TRIPLE_CLICKED, "tripleclick-5");
565 #endif
566
567     SHOW(BUTTON_CTRL, "ctrl");
568     SHOW(BUTTON_SHIFT, "shift");
569     SHOW(BUTTON_ALT, "alt");
570     SHOW(ALL_MOUSE_EVENTS, "all-events");
571     SHOW(REPORT_MOUSE_POSITION, "position");
572
573 #undef SHOW
574
575     if (buf[strlen(buf) - 1] == ' ')
576         buf[strlen(buf) - 2] = '\0';
577     (void) strcat(buf, "}");
578     return (buf);
579 }
580
581 static void
582 show_mouse(WINDOW *win)
583 {
584     int y, x;
585     MEVENT event;
586     bool outside;
587     bool show_loc;
588
589     getmouse(&event);
590     outside = !wenclose(win, event.y, event.x);
591
592     if (outside) {
593         (void) wstandout(win);
594         waddstr(win, "KEY_MOUSE");
595         (void) wstandend(win);
596     } else {
597         waddstr(win, "KEY_MOUSE");
598     }
599     wprintw(win, ", %s", mouse_decode(&event));
600
601     if (outside)
602         win = stdscr;
603
604     show_loc = wmouse_trafo(win, &event.y, &event.x, FALSE);
605
606     if (show_loc) {
607         getyx(win, y, x);
608         wmove(win, event.y, event.x);
609         waddch(win, '*');
610         wmove(win, y, x);
611     }
612
613     if (outside)
614         wnoutrefresh(win);
615 }
616 #endif /* NCURSES_MOUSE_VERSION */
617
618 /****************************************************************************
619  *
620  * Character input test
621  *
622  ****************************************************************************/
623
624 #define NUM_GETCH_FLAGS 256
625 typedef bool GetchFlags[NUM_GETCH_FLAGS];
626
627 static void
628 setup_getch(WINDOW *win, GetchFlags flags)
629 {
630     keypad(win, flags['k']);    /* should be redundant, but for testing */
631     meta(win, flags['m']);      /* force this to a known state */
632     if (flags['e'])
633         echo();
634     else
635         noecho();
636 }
637
638 static void
639 init_getch(WINDOW *win, GetchFlags flags, int delay)
640 {
641     memset(flags, FALSE, NUM_GETCH_FLAGS);
642     flags[UChar('k')] = (win == stdscr);
643     flags[UChar('m')] = TRUE;
644     flags[UChar('t')] = (delay != 0);
645
646     setup_getch(win, flags);
647 }
648
649 static bool
650 blocking_getch(GetchFlags flags, int delay)
651 {
652     return ((delay < 0) && flags['t']);
653 }
654
655 static void
656 wgetch_help(WINDOW *win, GetchFlags flags)
657 {
658     static const char *help[] =
659     {
660         "e  -- toggle echo mode"
661         ,"g  -- triggers a getstr test"
662         ,"k  -- toggle keypad/literal mode"
663         ,"m  -- toggle meta (7-bit/8-bit) mode"
664         ,"^q -- quit"
665         ,"s  -- shell out"
666         ,"t  -- toggle timeout"
667         ,"w  -- create a new window"
668 #ifdef SIGTSTP
669         ,"z  -- suspend this process"
670 #endif
671     };
672     int y, x;
673     unsigned chk = ((SIZEOF(help) + 1) / 2);
674     unsigned n;
675
676     getyx(win, y, x);
677     move(0, 0);
678     printw("Type any key to see its %s value.  Also:\n",
679            flags['k'] ? "keypad" : "literal");
680     for (n = 0; n < SIZEOF(help); ++n) {
681         int row = 1 + (int) (n % chk);
682         int col = (n >= chk) ? COLS / 2 : 0;
683         int flg = ((strstr(help[n], "toggle") != 0)
684                    && (flags[UChar(*help[n])] != FALSE));
685         if (flg)
686             (void) standout();
687         MvPrintw(row, col, "%s", help[n]);
688         if (col == 0)
689             clrtoeol();
690         if (flg)
691             (void) standend();
692     }
693     wrefresh(stdscr);
694     wmove(win, y, x);
695 }
696
697 static void
698 wgetch_wrap(WINDOW *win, int first_y)
699 {
700     int last_y = getmaxy(win) - 1;
701     int y = getcury(win) + 1;
702
703     if (y >= last_y)
704         y = first_y;
705     wmove(win, y, 0);
706     wclrtoeol(win);
707 }
708
709 #if defined(KEY_RESIZE) && HAVE_WRESIZE
710 typedef struct {
711     WINDOW *text;
712     WINDOW *frame;
713 } WINSTACK;
714
715 static WINSTACK *winstack = 0;
716 static unsigned len_winstack = 0;
717
718 static void
719 forget_boxes(void)
720 {
721     if (winstack != 0) {
722         free(winstack);
723     }
724     winstack = 0;
725     len_winstack = 0;
726 }
727
728 static void
729 remember_boxes(unsigned level, WINDOW *txt_win, WINDOW *box_win)
730 {
731     unsigned need = (level + 1) * 2;
732
733     assert(level < (unsigned) COLS);
734
735     if (winstack == 0) {
736         len_winstack = 20;
737         winstack = typeMalloc(WINSTACK, len_winstack);
738     } else if (need >= len_winstack) {
739         len_winstack = need;
740         winstack = typeRealloc(WINSTACK, len_winstack, winstack);
741     }
742     if (!winstack)
743         failed("remember_boxes");
744     winstack[level].text = txt_win;
745     winstack[level].frame = box_win;
746 }
747
748 #if USE_SOFTKEYS && (defined(NCURSES_VERSION_PATCH) && NCURSES_VERSION_PATCH < 20071229) && NCURSES_EXT_FUNCS
749 static void
750 slk_repaint(void)
751 {
752     /* this chunk is now done in resize_term() */
753     slk_touch();
754     slk_clear();
755     slk_noutrefresh();
756 }
757
758 #else
759 #define slk_repaint()           /* nothing */
760 #endif
761
762 #if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
763 /*
764  * For wgetch_test(), we create pairs of windows - one for a box, one for text.
765  * Resize both and paint the box in the parent.
766  */
767 static void
768 resize_boxes(unsigned level, WINDOW *win)
769 {
770     unsigned n;
771     int base = 5;
772     int high = LINES - base;
773     int wide = COLS;
774
775     touchwin(stdscr);
776     wnoutrefresh(stdscr);
777
778     slk_repaint();
779
780     for (n = 0; n < level; ++n) {
781         wresize(winstack[n].frame, high, wide);
782         wresize(winstack[n].text, high - 2, wide - 2);
783         high -= 2;
784         wide -= 2;
785         werase(winstack[n].text);
786         box(winstack[n].frame, 0, 0);
787         wnoutrefresh(winstack[n].frame);
788         wprintw(winstack[n].text,
789                 "size %dx%d\n",
790                 getmaxy(winstack[n].text),
791                 getmaxx(winstack[n].text));
792         wnoutrefresh(winstack[n].text);
793         if (winstack[n].text == win)
794             break;
795     }
796     doupdate();
797 }
798 #endif /* resize_boxes */
799 #else
800 #define forget_boxes()          /* nothing */
801 #define remember_boxes(level,text,frame)        /* nothing */
802 #endif
803
804 /*
805  * Return-code is OK/ERR or a keyname.
806  */
807 static const char *
808 ok_keyname(int code)
809 {
810     return ((code == OK) ? "OK" : ((code == ERR) ? "ERR" : keyname(code)));
811 }
812
813 static void
814 wgetch_test(unsigned level, WINDOW *win, int delay)
815 {
816     char buf[BUFSIZ];
817     int first_y, first_x;
818     int c;
819     int incount = 0;
820     GetchFlags flags;
821
822     init_getch(win, flags, delay);
823     notimeout(win, FALSE);
824     wtimeout(win, delay);
825     getyx(win, first_y, first_x);
826
827     wgetch_help(win, flags);
828     wsetscrreg(win, first_y, getmaxy(win) - 1);
829     scrollok(win, TRUE);
830
831     for (;;) {
832         while ((c = wGetchar(win)) == ERR) {
833             incount++;
834             if (blocking_getch(flags, delay)) {
835                 (void) wprintw(win, "%05d: input error", incount);
836                 break;
837             } else {
838                 (void) wprintw(win, "%05d: input timed out", incount);
839             }
840             wgetch_wrap(win, first_y);
841         }
842         if (c == ERR && blocking_getch(flags, delay)) {
843             wprintw(win, "ERR");
844             wgetch_wrap(win, first_y);
845         } else if (isQuit(c)) {
846             break;
847         } else if (c == 'e') {
848             flags[UChar('e')] = !flags[UChar('e')];
849             setup_getch(win, flags);
850             wgetch_help(win, flags);
851         } else if (c == 'g') {
852             waddstr(win, "getstr test: ");
853             echo();
854             c = wgetnstr(win, buf, sizeof(buf) - 1);
855             noecho();
856             wprintw(win, "I saw %d characters:\n\t`%s' (%s).",
857                     (int) strlen(buf), buf,
858                     ok_keyname(c));
859             wclrtoeol(win);
860             wgetch_wrap(win, first_y);
861         } else if (c == 'k') {
862             flags[UChar('k')] = !flags[UChar('k')];
863             setup_getch(win, flags);
864             wgetch_help(win, flags);
865         } else if (c == 'm') {
866             flags[UChar('m')] = !flags[UChar('m')];
867             setup_getch(win, flags);
868             wgetch_help(win, flags);
869         } else if (c == 's') {
870             ShellOut(TRUE);
871         } else if (c == 't') {
872             notimeout(win, flags[UChar('t')]);
873             flags[UChar('t')] = !flags[UChar('t')];
874             wgetch_help(win, flags);
875         } else if (c == 'w') {
876             int high = getmaxy(win) - 1 - first_y + 1;
877             int wide = getmaxx(win) - first_x;
878             int old_y, old_x;
879             int new_y = first_y + getbegy(win);
880             int new_x = first_x + getbegx(win);
881
882             getyx(win, old_y, old_x);
883             if (high > 2 && wide > 2) {
884                 WINDOW *wb = newwin(high, wide, new_y, new_x);
885                 WINDOW *wi = newwin(high - 2, wide - 2, new_y + 1, new_x + 1);
886
887                 box(wb, 0, 0);
888                 wrefresh(wb);
889                 wmove(wi, 0, 0);
890                 remember_boxes(level, wi, wb);
891                 wgetch_test(level + 1, wi, delay);
892                 delwin(wi);
893                 delwin(wb);
894
895                 wgetch_help(win, flags);
896                 wmove(win, old_y, old_x);
897                 touchwin(win);
898                 wrefresh(win);
899                 doupdate();
900             }
901 #ifdef SIGTSTP
902         } else if (c == 'z') {
903             kill(getpid(), SIGTSTP);
904 #endif
905         } else {
906             wprintw(win, "Key pressed: %04o ", c);
907 #ifdef NCURSES_MOUSE_VERSION
908             if (c == KEY_MOUSE) {
909                 show_mouse(win);
910             } else
911 #endif /* NCURSES_MOUSE_VERSION */
912             if (c >= KEY_MIN) {
913 #if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
914                 if (c == KEY_RESIZE) {
915                     resize_boxes(level, win);
916                 }
917 #endif
918                 (void) waddstr(win, keyname(c));
919             } else if (c >= 0x80) {
920                 unsigned c2 = (unsigned) c;
921 #if !(defined(NCURSES_VERSION) || defined(_XOPEN_CURSES))
922                 /* at least Solaris SVR4 curses breaks unctrl(128), etc. */
923                 c2 &= 0x7f;
924 #endif
925                 if (isprint(c))
926                     (void) wprintw(win, "%c", UChar(c));
927                 else if (c2 != UChar(c))
928                     (void) wprintw(win, "M-%s", unctrl(c2));
929                 else
930                     (void) wprintw(win, "%s", unctrl(c2));
931                 waddstr(win, " (high-half character)");
932             } else {
933                 if (isprint(c))
934                     (void) wprintw(win, "%c (ASCII printable character)", c);
935                 else
936                     (void) wprintw(win, "%s (ASCII control character)",
937                                    unctrl(UChar(c)));
938             }
939             wgetch_wrap(win, first_y);
940         }
941     }
942
943     wtimeout(win, -1);
944
945     if (!level)
946         init_getch(win, flags, delay);
947 }
948
949 static int
950 begin_getch_test(void)
951 {
952     char buf[BUFSIZ];
953     int delay;
954
955     refresh();
956
957 #ifdef NCURSES_MOUSE_VERSION
958     mousemask(ALL_MOUSE_EVENTS | REPORT_MOUSE_POSITION, (mmask_t *) 0);
959 #endif
960
961     (void) printw("Delay in 10ths of a second (<CR> for blocking input)? ");
962     echo();
963     getnstr(buf, sizeof(buf) - 1);
964     noecho();
965     nonl();
966
967     if (isdigit(UChar(buf[0]))) {
968         delay = atoi(buf) * 100;
969     } else {
970         delay = -1;
971     }
972     raw();
973     move(6, 0);
974     return delay;
975 }
976
977 static void
978 finish_getch_test(void)
979 {
980 #ifdef NCURSES_MOUSE_VERSION
981     mousemask(0, (mmask_t *) 0);
982 #endif
983     erase();
984     noraw();
985     nl();
986     endwin();
987 }
988
989 static void
990 getch_test(void)
991 {
992     int delay = begin_getch_test();
993
994     slk_restore();
995     wgetch_test(0, stdscr, delay);
996     forget_boxes();
997     finish_getch_test();
998     slk_clear();
999 }
1000
1001 #if USE_WIDEC_SUPPORT
1002 /*
1003  * For wget_wch_test(), we create pairs of windows - one for a box, one for text.
1004  * Resize both and paint the box in the parent.
1005  */
1006 #if defined(KEY_RESIZE) && HAVE_WRESIZE
1007 static void
1008 resize_wide_boxes(unsigned level, WINDOW *win)
1009 {
1010     unsigned n;
1011     int base = 5;
1012     int high = LINES - base;
1013     int wide = COLS;
1014
1015     touchwin(stdscr);
1016     wnoutrefresh(stdscr);
1017
1018     slk_repaint();
1019
1020     for (n = 0; n < level; ++n) {
1021         wresize(winstack[n].frame, high, wide);
1022         wresize(winstack[n].text, high - 2, wide - 2);
1023         high -= 2;
1024         wide -= 2;
1025         werase(winstack[n].text);
1026         box_set(winstack[n].frame, 0, 0);
1027         wnoutrefresh(winstack[n].frame);
1028         wprintw(winstack[n].text,
1029                 "size %dx%d\n",
1030                 getmaxy(winstack[n].text),
1031                 getmaxx(winstack[n].text));
1032         wnoutrefresh(winstack[n].text);
1033         if (winstack[n].text == win)
1034             break;
1035     }
1036     doupdate();
1037 }
1038 #endif /* KEY_RESIZE */
1039
1040 static char *
1041 wcstos(const wchar_t *src)
1042 {
1043     int need;
1044     char *result = 0;
1045     const wchar_t *tmp = src;
1046 #ifndef state_unused
1047     mbstate_t state;
1048 #endif
1049
1050     reset_wchars(state);
1051     if ((need = (int) count_wchars(tmp, 0, &state)) > 0) {
1052         unsigned have = (unsigned) need;
1053         if ((result = typeCalloc(char, have + 1)) != 0) {
1054             tmp = src;
1055             if (trans_wchars(result, tmp, have, &state) != have) {
1056                 free(result);
1057                 result = 0;
1058             }
1059         } else {
1060             failed("wcstos");
1061         }
1062     }
1063     return result;
1064 }
1065
1066 static void
1067 wget_wch_test(unsigned level, WINDOW *win, int delay)
1068 {
1069     wchar_t wchar_buf[BUFSIZ];
1070     wint_t wint_buf[BUFSIZ];
1071     int first_y, first_x;
1072     wint_t c;
1073     int incount = 0;
1074     GetchFlags flags;
1075     int code;
1076     char *temp;
1077
1078     init_getch(win, flags, delay);
1079     notimeout(win, FALSE);
1080     wtimeout(win, delay);
1081     getyx(win, first_y, first_x);
1082
1083     wgetch_help(win, flags);
1084     wsetscrreg(win, first_y, getmaxy(win) - 1);
1085     scrollok(win, TRUE);
1086
1087     for (;;) {
1088         while ((code = wGet_wchar(win, &c)) == ERR) {
1089             incount++;
1090             if (blocking_getch(flags, delay)) {
1091                 (void) wprintw(win, "%05d: input error", incount);
1092                 break;
1093             } else {
1094                 (void) wprintw(win, "%05d: input timed out", incount);
1095             }
1096             wgetch_wrap(win, first_y);
1097         }
1098         if (code == ERR && blocking_getch(flags, delay)) {
1099             wprintw(win, "ERR");
1100             wgetch_wrap(win, first_y);
1101         } else if (isQuit((int) c)) {
1102             break;
1103         } else if (c == 'e') {
1104             flags[UChar('e')] = !flags[UChar('e')];
1105             setup_getch(win, flags);
1106             wgetch_help(win, flags);
1107         } else if (c == 'g') {
1108             waddstr(win, "getstr test: ");
1109             echo();
1110             code = wgetn_wstr(win, wint_buf, BUFSIZ - 1);
1111             noecho();
1112             if (code == ERR) {
1113                 wprintw(win, "wgetn_wstr returns an error.");
1114             } else {
1115                 int n;
1116                 for (n = 0; (wchar_buf[n] = (wchar_t) wint_buf[n]) != 0; ++n) {
1117                     ;
1118                 }
1119                 if ((temp = wcstos(wchar_buf)) != 0) {
1120                     wprintw(win, "I saw %d characters:\n\t`%s'.",
1121                             (int) wcslen(wchar_buf), temp);
1122                     free(temp);
1123                 } else {
1124                     wprintw(win, "I saw %d characters (cannot convert).",
1125                             (int) wcslen(wchar_buf));
1126                 }
1127             }
1128             wclrtoeol(win);
1129             wgetch_wrap(win, first_y);
1130         } else if (c == 'k') {
1131             flags[UChar('k')] = !flags[UChar('k')];
1132             setup_getch(win, flags);
1133             wgetch_help(win, flags);
1134         } else if (c == 'm') {
1135             flags[UChar('m')] = !flags[UChar('m')];
1136             setup_getch(win, flags);
1137             wgetch_help(win, flags);
1138         } else if (c == 's') {
1139             ShellOut(TRUE);
1140         } else if (c == 't') {
1141             notimeout(win, flags[UChar('t')]);
1142             flags[UChar('t')] = !flags[UChar('t')];
1143             wgetch_help(win, flags);
1144         } else if (c == 'w') {
1145             int high = getmaxy(win) - 1 - first_y + 1;
1146             int wide = getmaxx(win) - first_x;
1147             int old_y, old_x;
1148             int new_y = first_y + getbegy(win);
1149             int new_x = first_x + getbegx(win);
1150
1151             getyx(win, old_y, old_x);
1152             if (high > 2 && wide > 2) {
1153                 WINDOW *wb = newwin(high, wide, new_y, new_x);
1154                 WINDOW *wi = newwin(high - 2, wide - 2, new_y + 1, new_x + 1);
1155
1156                 box_set(wb, 0, 0);
1157                 wrefresh(wb);
1158                 wmove(wi, 0, 0);
1159                 remember_boxes(level, wi, wb);
1160                 wget_wch_test(level + 1, wi, delay);
1161                 delwin(wi);
1162                 delwin(wb);
1163
1164                 wgetch_help(win, flags);
1165                 wmove(win, old_y, old_x);
1166                 touchwin(win);
1167                 wrefresh(win);
1168             }
1169 #ifdef SIGTSTP
1170         } else if (c == 'z') {
1171             kill(getpid(), SIGTSTP);
1172 #endif
1173         } else {
1174             wprintw(win, "Key pressed: %04o ", (int) c);
1175 #ifdef NCURSES_MOUSE_VERSION
1176             if (c == KEY_MOUSE) {
1177                 show_mouse(win);
1178             } else
1179 #endif /* NCURSES_MOUSE_VERSION */
1180             if (code == KEY_CODE_YES) {
1181 #if defined(KEY_RESIZE) && HAVE_WRESIZE
1182                 if (c == KEY_RESIZE) {
1183                     resize_wide_boxes(level, win);
1184                 }
1185 #endif
1186                 (void) waddstr(win, keyname((wchar_t) c));
1187             } else {
1188                 (void) waddstr(win, key_name((wchar_t) c));
1189                 if (c < 256 && iscntrl(c)) {
1190                     (void) wprintw(win, " (control character)");
1191                 } else {
1192                     (void) wprintw(win, " = %#x (printable character)",
1193                                    (unsigned) c);
1194                 }
1195             }
1196             wgetch_wrap(win, first_y);
1197         }
1198     }
1199
1200     wtimeout(win, -1);
1201
1202     if (!level)
1203         init_getch(win, flags, delay);
1204 }
1205
1206 static void
1207 get_wch_test(void)
1208 {
1209     int delay = begin_getch_test();
1210
1211     slk_restore();
1212     wget_wch_test(0, stdscr, delay);
1213     forget_boxes();
1214     finish_getch_test();
1215     slk_clear();
1216 }
1217 #endif
1218
1219 /****************************************************************************
1220  *
1221  * Character attributes test
1222  *
1223  ****************************************************************************/
1224
1225 #if HAVE_SETUPTERM || HAVE_TGETENT
1226 #define get_ncv() TIGETNUM("ncv","NC")
1227 #define get_xmc() TIGETNUM("xmc","sg")
1228 #else
1229 #define get_ncv() -1
1230 #define get_xmc() -1
1231 #endif
1232
1233 #if !HAVE_TERMATTRS
1234 static chtype
1235 my_termattrs(void)
1236 {
1237     static int first = TRUE;
1238     static chtype result = 0;
1239
1240     if (first) {
1241 #if !HAVE_TIGETSTR
1242         char buffer[4096];
1243         char parsed[4096];
1244         char *area_pointer = parsed;
1245
1246         tgetent(buffer, getenv("TERM"));
1247 #endif
1248
1249         if (TIGETSTR("smso", "so"))
1250             result |= A_STANDOUT;
1251         if (TIGETSTR("smul", "us"))
1252             result |= A_UNDERLINE;
1253         if (TIGETSTR("rev", "mr"))
1254             result |= A_REVERSE;
1255         if (TIGETSTR("blink", "mb"))
1256             result |= A_BLINK;
1257         if (TIGETSTR("dim", "mh"))
1258             result |= A_DIM;
1259         if (TIGETSTR("bold", "md"))
1260             result |= A_BOLD;
1261         if (TIGETSTR("smacs", "ac"))
1262             result |= A_ALTCHARSET;
1263
1264         first = FALSE;
1265     }
1266     return result;
1267 }
1268 #define termattrs() my_termattrs()
1269 #endif
1270
1271 #define ATTRSTRING_1ST 32       /* ' ' */
1272 #define ATTRSTRING_END 126      /* '~' */
1273
1274 #define COLS_PRE_ATTRS 5
1275 #define COLS_AFT_ATTRS 15
1276 #define COL_ATTRSTRING (COLS_PRE_ATTRS + 17)
1277 #define LEN_ATTRSTRING (COLS - (COL_ATTRSTRING + COLS_AFT_ATTRS))
1278 #define MAX_ATTRSTRING (ATTRSTRING_END + 1 - ATTRSTRING_1ST)
1279
1280 static char attr_test_string[MAX_ATTRSTRING + 1];
1281
1282 static void
1283 attr_legend(WINDOW *helpwin)
1284 {
1285     int row = 1;
1286     int col = 1;
1287
1288     MvWPrintw(helpwin, row++, col,
1289               "ESC to exit.");
1290     MvWPrintw(helpwin, row++, col,
1291               "^L repaints.");
1292     ++row;
1293     MvWPrintw(helpwin, row++, col,
1294               "Modify the test strings:");
1295     MvWPrintw(helpwin, row++, col,
1296               "  A digit sets gaps on each side of displayed attributes");
1297     MvWPrintw(helpwin, row++, col,
1298               "  </> shifts the text left/right. ");
1299     ++row;
1300     MvWPrintw(helpwin, row++, col,
1301               "Toggles:");
1302     if (use_colors) {
1303         MvWPrintw(helpwin, row++, col,
1304                   "  f/F/b/F toggle foreground/background background color");
1305         MvWPrintw(helpwin, row++, col,
1306                   "  t/T     toggle text/background color attribute");
1307     }
1308     MvWPrintw(helpwin, row++, col,
1309               "  a/A     toggle ACS (alternate character set) mapping");
1310     MvWPrintw(helpwin, row, col,
1311               "  v/V     toggle video attribute to combine with each line");
1312 #if USE_WIDEC_SUPPORT
1313     MvWPrintw(helpwin, row, col,
1314               "  w/W     toggle normal/wide (double-width) test-characters");
1315 #endif
1316 }
1317
1318 static void
1319 show_color_attr(int fg, int bg, int tx)
1320 {
1321     if (use_colors) {
1322         printw("  Colors (fg %d, bg %d", fg, bg);
1323         if (tx >= 0)
1324             printw(", text %d", tx);
1325         printw("),");
1326     }
1327 }
1328
1329 static bool
1330 cycle_color_attr(int ch, NCURSES_COLOR_T *fg, NCURSES_COLOR_T *bg, NCURSES_COLOR_T *tx)
1331 {
1332     bool error = FALSE;
1333
1334     if (use_colors) {
1335         switch (ch) {
1336         case 'f':
1337             *fg = (NCURSES_COLOR_T) (*fg + 1);
1338             break;
1339         case 'F':
1340             *fg = (NCURSES_COLOR_T) (*fg - 1);
1341             break;
1342         case 'b':
1343             *bg = (NCURSES_COLOR_T) (*bg + 1);
1344             break;
1345         case 'B':
1346             *bg = (NCURSES_COLOR_T) (*bg - 1);
1347             break;
1348         case 't':
1349             *tx = (NCURSES_COLOR_T) (*tx + 1);
1350             break;
1351         case 'T':
1352             *tx = (NCURSES_COLOR_T) (*tx - 1);
1353             break;
1354         default:
1355             beep();
1356             error = TRUE;
1357             break;
1358         }
1359         if (*fg >= COLORS)
1360             *fg = (NCURSES_COLOR_T) min_colors;
1361         if (*fg < min_colors)
1362             *fg = (NCURSES_COLOR_T) (COLORS - 1);
1363         if (*bg >= COLORS)
1364             *bg = (NCURSES_COLOR_T) min_colors;
1365         if (*bg < min_colors)
1366             *bg = (NCURSES_COLOR_T) (COLORS - 1);
1367         if (*tx >= COLORS)
1368             *tx = -1;
1369         if (*tx < -1)
1370             *tx = (NCURSES_COLOR_T) (COLORS - 1);
1371     } else {
1372         beep();
1373         error = TRUE;
1374     }
1375     return error;
1376 }
1377
1378 static void
1379 adjust_attr_string(int adjust)
1380 {
1381     char save = attr_test_string[0];
1382     int first = ((int) UChar(save)) + adjust;
1383     int j, k;
1384
1385     if (first >= ATTRSTRING_1ST) {
1386         for (j = 0, k = first; j < MAX_ATTRSTRING; ++j, ++k) {
1387             if (k > ATTRSTRING_END)
1388                 break;
1389             attr_test_string[j] = (char) k;
1390             if (((k + 1 - first) % 5) == 0) {
1391                 if (++j >= MAX_ATTRSTRING)
1392                     break;
1393                 attr_test_string[j] = ' ';
1394             }
1395         }
1396         if ((LEN_ATTRSTRING - j) > 5) {
1397             attr_test_string[0] = save;
1398             adjust_attr_string(adjust - 1);
1399         } else {
1400             while (j < MAX_ATTRSTRING)
1401                 attr_test_string[j++] = ' ';
1402             attr_test_string[j] = '\0';
1403         }
1404     }
1405 }
1406
1407 /*
1408  * Prefer the right-end of the string for starting, since that maps to the
1409  * VT100 line-drawing.
1410  */
1411 static int
1412 default_attr_string(void)
1413 {
1414     int result = (ATTRSTRING_END - LEN_ATTRSTRING);
1415     result += (LEN_ATTRSTRING / 5);
1416     if (result < ATTRSTRING_1ST)
1417         result = ATTRSTRING_1ST;
1418     return result;
1419 }
1420
1421 static void
1422 init_attr_string(void)
1423 {
1424     attr_test_string[0] = (char) default_attr_string();
1425     adjust_attr_string(0);
1426 }
1427
1428 static int
1429 show_attr(WINDOW *win, int row, int skip, bool arrow, chtype attr, const char *name)
1430 {
1431     int ncv = get_ncv();
1432     chtype test = attr & (chtype) (~(A_ALTCHARSET | A_CHARTEXT));
1433
1434     if (arrow)
1435         MvPrintw(row, COLS_PRE_ATTRS - 3, "-->");
1436     MvPrintw(row, COLS_PRE_ATTRS, "%s mode:", name);
1437     MvPrintw(row, COL_ATTRSTRING - 1, "|");
1438     if (skip)
1439         printw("%*s", skip, " ");
1440     /*
1441      * Just for testing, write text using the alternate character set one
1442      * character at a time (to pass its rendition directly), and use the
1443      * string operation for the other attributes.
1444      */
1445     wmove(win, 0, 0);
1446     werase(win);
1447     if (attr & A_ALTCHARSET) {
1448         const char *s;
1449         chtype ch;
1450
1451         for (s = attr_test_string; *s != '\0'; ++s) {
1452             ch = UChar(*s);
1453             (void) waddch(win, ch | attr);
1454         }
1455     } else {
1456         (void) wattrset(win, AttrArg(attr, 0));
1457         (void) waddstr(win, attr_test_string);
1458         (void) wattroff(win, (int) attr);
1459     }
1460     if (skip)
1461         printw("%*s", skip, " ");
1462     MvPrintw(row, COL_ATTRSTRING + LEN_ATTRSTRING, "|");
1463     if (test != A_NORMAL) {
1464         if (!(termattrs() & test)) {
1465             printw(" (N/A)");
1466         } else {
1467             if (ncv > 0 && stdscr && (getbkgd(stdscr) & A_COLOR)) {
1468                 static const chtype table[] =
1469                 {
1470                     A_STANDOUT,
1471                     A_UNDERLINE,
1472                     A_REVERSE,
1473                     A_BLINK,
1474                     A_DIM,
1475                     A_BOLD,
1476 #ifdef A_INVIS
1477                     A_INVIS,
1478 #endif
1479 #ifdef A_ITALIC
1480                     A_ITALIC,
1481 #endif
1482                     A_PROTECT,
1483                     A_ALTCHARSET
1484                 };
1485                 unsigned n;
1486                 bool found = FALSE;
1487                 for (n = 0; n < SIZEOF(table); n++) {
1488                     if ((table[n] & attr) != 0
1489                         && ((1 << n) & ncv) != 0) {
1490                         found = TRUE;
1491                         break;
1492                     }
1493                 }
1494                 if (found)
1495                     printw(" (NCV)");
1496             }
1497             if ((termattrs() & test) != test) {
1498                 printw(" (Part)");
1499             }
1500         }
1501     }
1502     return row + 2;
1503 }
1504
1505 typedef struct {
1506     attr_t attr;
1507     NCURSES_CONST char *name;
1508 } ATTR_TBL;
1509 /* *INDENT-OFF* */
1510 static const ATTR_TBL attrs_to_test[] = {
1511     { A_STANDOUT,       "STANDOUT" },
1512     { A_REVERSE,        "REVERSE" },
1513     { A_BOLD,           "BOLD" },
1514     { A_UNDERLINE,      "UNDERLINE" },
1515     { A_DIM,            "DIM" },
1516     { A_BLINK,          "BLINK" },
1517     { A_PROTECT,        "PROTECT" },
1518 #ifdef A_INVIS
1519     { A_INVIS,          "INVISIBLE" },
1520 #endif
1521 #ifdef A_ITALIC
1522     { A_ITALIC,         "ITALIC" },
1523 #endif
1524     { A_NORMAL,         "NORMAL" },
1525 };
1526 /* *INDENT-ON* */
1527
1528 static unsigned
1529 init_attr_list(ATTR_TBL * target, attr_t attrs)
1530 {
1531     unsigned result = 0;
1532     size_t n;
1533
1534     for (n = 0; n < SIZEOF(attrs_to_test); ++n) {
1535         attr_t test = attrs_to_test[n].attr;
1536         if (test == A_NORMAL || (test & attrs) != 0) {
1537             target[result++] = attrs_to_test[n];
1538         }
1539     }
1540     return result;
1541 }
1542
1543 static bool
1544 attr_getc(int *skip,
1545           NCURSES_COLOR_T *fg,
1546           NCURSES_COLOR_T *bg,
1547           NCURSES_COLOR_T *tx,
1548           int *ac,
1549           unsigned *kc,
1550           unsigned limit)
1551 {
1552     bool result = TRUE;
1553     bool error = FALSE;
1554     WINDOW *helpwin;
1555
1556     do {
1557         int ch = Getchar();
1558
1559         error = FALSE;
1560         if (ch < 256 && isdigit(ch)) {
1561             *skip = (ch - '0');
1562         } else {
1563             switch (ch) {
1564             case CTRL('L'):
1565                 Repaint();
1566                 break;
1567             case '?':
1568                 if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
1569                     box(helpwin, 0, 0);
1570                     attr_legend(helpwin);
1571                     wGetchar(helpwin);
1572                     delwin(helpwin);
1573                 }
1574                 break;
1575             case 'a':
1576                 *ac = 0;
1577                 break;
1578             case 'A':
1579                 *ac = A_ALTCHARSET;
1580                 break;
1581             case 'v':
1582                 if (*kc == 0)
1583                     *kc = limit - 1;
1584                 else
1585                     *kc -= 1;
1586                 break;
1587             case 'V':
1588                 *kc += 1;
1589                 if (*kc >= limit)
1590                     *kc = 0;
1591                 break;
1592             case '<':
1593                 adjust_attr_string(-1);
1594                 break;
1595             case '>':
1596                 adjust_attr_string(1);
1597                 break;
1598             case case_QUIT:
1599                 result = FALSE;
1600                 break;
1601             default:
1602                 error = cycle_color_attr(ch, fg, bg, tx);
1603                 break;
1604             }
1605         }
1606     } while (error);
1607     return result;
1608 }
1609
1610 static void
1611 attr_test(void)
1612 /* test text attributes */
1613 {
1614     int n;
1615     int skip = get_xmc();
1616     NCURSES_COLOR_T fg = COLOR_BLACK;   /* color pair 0 is special */
1617     NCURSES_COLOR_T bg = COLOR_BLACK;
1618     NCURSES_COLOR_T tx = -1;
1619     int ac = 0;
1620     unsigned j, k;
1621     WINDOW *my_wins[SIZEOF(attrs_to_test)];
1622     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
1623     unsigned my_size = init_attr_list(my_list, termattrs());
1624
1625     if (my_size > 1) {
1626         for (j = 0; j < my_size; ++j) {
1627             my_wins[j] = subwin(stdscr,
1628                                 1, LEN_ATTRSTRING,
1629                                 2 + (int) (2 * j), COL_ATTRSTRING);
1630             scrollok(my_wins[j], FALSE);
1631         }
1632
1633         if (skip < 0)
1634             skip = 0;
1635
1636         n = skip;               /* make it easy */
1637         k = my_size - 1;
1638         init_attr_string();
1639
1640         do {
1641             int row = 2;
1642             chtype normal = A_NORMAL | BLANK;
1643             chtype extras = (chtype) ac;
1644
1645             if (use_colors) {
1646                 NCURSES_PAIRS_T pair = 0;
1647                 if ((fg != COLOR_BLACK) || (bg != COLOR_BLACK)) {
1648                     pair = 1;
1649                     if (init_pair(pair, fg, bg) == ERR) {
1650                         beep();
1651                     } else {
1652                         normal |= (chtype) COLOR_PAIR(pair);
1653                     }
1654                 }
1655                 if (tx >= 0) {
1656                     pair = 2;
1657                     if (init_pair(pair, tx, bg) == ERR) {
1658                         beep();
1659                     } else {
1660                         extras |= (chtype) COLOR_PAIR(pair);
1661                         normal &= ~A_COLOR;
1662                     }
1663                 }
1664             }
1665             bkgd(normal);
1666             bkgdset(normal);
1667             erase();
1668
1669             box(stdscr, 0, 0);
1670             MvAddStr(0, 20, "Character attribute test display");
1671
1672             for (j = 0; j < my_size; ++j) {
1673                 bool arrow = (j == k);
1674                 row = show_attr(my_wins[j], row, n, arrow,
1675                                 normal |
1676                                 extras |
1677                                 my_list[j].attr |
1678                                 my_list[k].attr,
1679                                 my_list[j].name);
1680             }
1681
1682             MvPrintw(row, COLS_PRE_ATTRS,
1683                      "This terminal does %shave the magic-cookie glitch",
1684                      get_xmc() > -1 ? "" : "not ");
1685             MvPrintw(row + 1, COLS_PRE_ATTRS, "Enter '?' for help.");
1686             show_color_attr(fg, bg, tx);
1687             printw("  ACS (%d)", ac != 0);
1688
1689             refresh();
1690         } while (attr_getc(&n, &fg, &bg, &tx, &ac, &k, my_size));
1691
1692         bkgdset(A_NORMAL | BLANK);
1693         erase();
1694         endwin();
1695     } else {
1696         Cannot("does not support video attributes.");
1697     }
1698 }
1699
1700 #if USE_WIDEC_SUPPORT
1701 static bool use_fullwidth;
1702 static wchar_t wide_attr_test_string[MAX_ATTRSTRING + 1];
1703
1704 #define FULL_LO 0xff00
1705 #define FULL_HI 0xff5e
1706 #define HALF_LO 0x20
1707
1708 #define isFullWidth(ch)   ((int)(ch) >= FULL_LO && (int)(ch) <= FULL_HI)
1709 #define ToNormalWidth(ch) (wchar_t) (((int)(ch) - FULL_LO) + HALF_LO)
1710 #define ToFullWidth(ch)   (wchar_t) (((int)(ch) - HALF_LO) + FULL_LO)
1711
1712 /*
1713  * Returns an ASCII code in [32..126]
1714  */
1715 static wchar_t
1716 normal_wchar(int ch)
1717 {
1718     wchar_t result = (wchar_t) ch;
1719     if (isFullWidth(ch))
1720         result = ToNormalWidth(ch);
1721     return result;
1722 }
1723
1724 /*
1725  * Returns either an ASCII code in in [32..126] or full-width in
1726  * [0xff00..0xff5e], according to use_fullwidth setting.
1727  */
1728 static wchar_t
1729 target_wchar(int ch)
1730 {
1731     wchar_t result = (wchar_t) ch;
1732     if (use_fullwidth) {
1733         if (!isFullWidth(ch))
1734             result = ToFullWidth(ch);
1735     } else {
1736         if (isFullWidth(ch))
1737             result = ToNormalWidth(ch);
1738     }
1739     return result;
1740 }
1741
1742 static void
1743 wide_adjust_attr_string(int adjust)
1744 {
1745     wchar_t save = wide_attr_test_string[0];
1746     int first = ((int) normal_wchar(save)) + adjust;
1747     int j, k;
1748
1749     if (first >= ATTRSTRING_1ST) {
1750         for (j = 0, k = first; j < MAX_ATTRSTRING; ++j, ++k) {
1751             if (k > ATTRSTRING_END)
1752                 break;
1753             wide_attr_test_string[j] = target_wchar(k);
1754             if (((k + 1 - first) % 5) == 0) {
1755                 if (++j >= MAX_ATTRSTRING)
1756                     break;
1757                 wide_attr_test_string[j] = ' ';
1758             }
1759         }
1760         if ((LEN_ATTRSTRING - j) > 5) {
1761             wide_attr_test_string[0] = save;
1762             wide_adjust_attr_string(adjust - 1);
1763         } else {
1764             while (j < MAX_ATTRSTRING)
1765                 wide_attr_test_string[j++] = ' ';
1766             wide_attr_test_string[j] = '\0';
1767         }
1768     }
1769 }
1770
1771 static void
1772 wide_init_attr_string(void)
1773 {
1774     use_fullwidth = FALSE;
1775     wide_attr_test_string[0] = (wchar_t) default_attr_string();
1776     wide_adjust_attr_string(0);
1777 }
1778
1779 static void
1780 set_wide_background(NCURSES_PAIRS_T pair)
1781 {
1782     cchar_t normal;
1783     wchar_t blank[2];
1784
1785     blank[0] = ' ';
1786     blank[1] = 0;
1787     setcchar(&normal, blank, A_NORMAL, pair, 0);
1788     bkgrnd(&normal);
1789     bkgrndset(&normal);
1790 }
1791
1792 static attr_t
1793 get_wide_background(void)
1794 {
1795     attr_t result = A_NORMAL;
1796     attr_t attr;
1797     cchar_t ch;
1798     NCURSES_PAIRS_T pair;
1799     wchar_t wch[10];
1800
1801     memset(&ch, 0, sizeof(ch));
1802     if (getbkgrnd(&ch) != ERR) {
1803         if (getcchar(&ch, wch, &attr, &pair, 0) != ERR) {
1804             result = attr;
1805         }
1806     }
1807     return result;
1808 }
1809
1810 static int
1811 wide_show_attr(WINDOW *win,
1812                int row,
1813                int skip,
1814                bool arrow,
1815                chtype attr,
1816                NCURSES_PAIRS_T pair,
1817                const char *name)
1818 {
1819     int ncv = get_ncv();
1820     chtype test = attr & ~WA_ALTCHARSET;
1821
1822     if (arrow)
1823         MvPrintw(row, COLS_PRE_ATTRS - 3, "-->");
1824     MvPrintw(row, COLS_PRE_ATTRS, "%s mode:", name);
1825     MvPrintw(row, COL_ATTRSTRING - 1, "|");
1826     if (skip)
1827         printw("%*s", skip, " ");
1828
1829     /*
1830      * Just for testing, write text using the alternate character set one
1831      * character at a time (to pass its rendition directly), and use the
1832      * string operation for the other attributes.
1833      */
1834     wmove(win, 0, 0);
1835     werase(win);
1836     if (attr & WA_ALTCHARSET) {
1837         const wchar_t *s;
1838         cchar_t ch;
1839
1840         for (s = wide_attr_test_string; *s != L'\0'; ++s) {
1841             wchar_t fill[2];
1842             fill[0] = *s;
1843             fill[1] = L'\0';
1844             setcchar(&ch, fill, attr, pair, 0);
1845             (void) wadd_wch(win, &ch);
1846         }
1847     } else {
1848         attr_t old_attr = 0;
1849         NCURSES_PAIRS_T old_pair = 0;
1850
1851         (void) (wattr_get) (win, &old_attr, &old_pair, 0);
1852         (void) wattr_set(win, attr, pair, 0);
1853         (void) waddwstr(win, wide_attr_test_string);
1854         (void) wattr_set(win, old_attr, old_pair, 0);
1855     }
1856     if (skip)
1857         printw("%*s", skip, " ");
1858     MvPrintw(row, COL_ATTRSTRING + LEN_ATTRSTRING, "|");
1859     if (test != A_NORMAL) {
1860         if (!(term_attrs() & test)) {
1861             printw(" (N/A)");
1862         } else {
1863             if (ncv > 0 && (get_wide_background() & A_COLOR)) {
1864                 static const attr_t table[] =
1865                 {
1866                     WA_STANDOUT,
1867                     WA_UNDERLINE,
1868                     WA_REVERSE,
1869                     WA_BLINK,
1870                     WA_DIM,
1871                     WA_BOLD,
1872                     WA_INVIS,
1873                     WA_PROTECT,
1874                     WA_ALTCHARSET
1875                 };
1876                 unsigned n;
1877                 bool found = FALSE;
1878                 for (n = 0; n < SIZEOF(table); n++) {
1879                     if ((table[n] & attr) != 0
1880                         && ((1 << n) & ncv) != 0) {
1881                         found = TRUE;
1882                         break;
1883                     }
1884                 }
1885                 if (found)
1886                     printw(" (NCV)");
1887             }
1888             if ((term_attrs() & test) != test) {
1889                 printw(" (Part)");
1890             }
1891         }
1892     }
1893     return row + 2;
1894 }
1895
1896 static bool
1897 wide_attr_getc(int *skip,
1898                NCURSES_COLOR_T *fg, NCURSES_COLOR_T *bg,
1899                NCURSES_COLOR_T *tx, int *ac,
1900                unsigned *kc, unsigned limit)
1901 {
1902     bool result = TRUE;
1903     bool error = FALSE;
1904     WINDOW *helpwin;
1905
1906     do {
1907         int ch = Getchar();
1908
1909         error = FALSE;
1910         if (ch < 256 && isdigit(ch)) {
1911             *skip = (ch - '0');
1912         } else {
1913             switch (ch) {
1914             case CTRL('L'):
1915                 Repaint();
1916                 break;
1917             case '?':
1918                 if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
1919                     box_set(helpwin, 0, 0);
1920                     attr_legend(helpwin);
1921                     wGetchar(helpwin);
1922                     delwin(helpwin);
1923                 }
1924                 break;
1925             case 'a':
1926                 *ac = 0;
1927                 break;
1928             case 'A':
1929                 *ac = A_ALTCHARSET;
1930                 break;
1931             case 'v':
1932                 if (*kc == 0)
1933                     *kc = limit - 1;
1934                 else
1935                     *kc -= 1;
1936                 break;
1937             case 'V':
1938                 *kc += 1;
1939                 if (*kc >= limit)
1940                     *kc = 0;
1941                 break;
1942             case 'w':
1943                 use_fullwidth = FALSE;
1944                 wide_adjust_attr_string(0);
1945                 break;
1946             case 'W':
1947                 use_fullwidth = TRUE;
1948                 wide_adjust_attr_string(0);
1949                 break;
1950             case '<':
1951                 wide_adjust_attr_string(-1);
1952                 break;
1953             case '>':
1954                 wide_adjust_attr_string(1);
1955                 break;
1956             case case_QUIT:
1957                 result = FALSE;
1958                 break;
1959             default:
1960                 error = cycle_color_attr(ch, fg, bg, tx);
1961                 break;
1962             }
1963         }
1964     } while (error);
1965     return result;
1966 }
1967
1968 static void
1969 wide_attr_test(void)
1970 /* test text attributes using wide-character calls */
1971 {
1972     int n;
1973     int skip = get_xmc();
1974     NCURSES_COLOR_T fg = COLOR_BLACK;   /* color pair 0 is special */
1975     NCURSES_COLOR_T bg = COLOR_BLACK;
1976     NCURSES_COLOR_T tx = -1;
1977     int ac = 0;
1978     unsigned j, k;
1979     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
1980     WINDOW *my_wins[SIZEOF(attrs_to_test)];
1981     unsigned my_size = init_attr_list(my_list, term_attrs());
1982
1983     if (my_size > 1) {
1984         for (j = 0; j < my_size; ++j) {
1985             my_wins[j] = subwin(stdscr,
1986                                 1, LEN_ATTRSTRING,
1987                                 2 + (int) (2 * j), COL_ATTRSTRING);
1988             scrollok(my_wins[j], FALSE);
1989         }
1990
1991         if (skip < 0)
1992             skip = 0;
1993
1994         n = skip;               /* make it easy */
1995         k = my_size - 1;
1996         wide_init_attr_string();
1997
1998         do {
1999             int row = 2;
2000             NCURSES_PAIRS_T pair = 0;
2001             NCURSES_PAIRS_T extras = 0;
2002
2003             if (use_colors) {
2004                 pair = (NCURSES_PAIRS_T) (fg != COLOR_BLACK || bg != COLOR_BLACK);
2005                 if (pair != 0) {
2006                     pair = 1;
2007                     if (init_pair(pair, fg, bg) == ERR) {
2008                         beep();
2009                     }
2010                 }
2011                 extras = pair;
2012                 if (tx >= 0) {
2013                     extras = 2;
2014                     if (init_pair(extras, tx, bg) == ERR) {
2015                         beep();
2016                     }
2017                 }
2018             }
2019             set_wide_background(pair);
2020             erase();
2021
2022             box_set(stdscr, 0, 0);
2023             MvAddStr(0, 20, "Character attribute test display");
2024
2025             for (j = 0; j < my_size; ++j) {
2026                 row = wide_show_attr(my_wins[j], row, n, (j == k),
2027                                      ((attr_t) ac |
2028                                       my_list[j].attr |
2029                                       my_list[k].attr),
2030                                      extras,
2031                                      my_list[j].name);
2032             }
2033
2034             MvPrintw(row, COLS_PRE_ATTRS,
2035                      "This terminal does %shave the magic-cookie glitch",
2036                      get_xmc() > -1 ? "" : "not ");
2037             MvPrintw(row + 1, COLS_PRE_ATTRS, "Enter '?' for help.");
2038             show_color_attr(fg, bg, tx);
2039             printw("  ACS (%d)", ac != 0);
2040
2041             refresh();
2042         } while (wide_attr_getc(&n, &fg, &bg, &tx, &ac, &k, my_size));
2043
2044         set_wide_background(0);
2045         erase();
2046         endwin();
2047     } else {
2048         Cannot("does not support extended video attributes.");
2049     }
2050 }
2051 #endif
2052
2053 /****************************************************************************
2054  *
2055  * Color support tests
2056  *
2057  ****************************************************************************/
2058
2059 static NCURSES_CONST char *the_color_names[] =
2060 {
2061     "black",
2062     "red",
2063     "green",
2064     "yellow",
2065     "blue",
2066     "magenta",
2067     "cyan",
2068     "white",
2069     "BLACK",
2070     "RED",
2071     "GREEN",
2072     "YELLOW",
2073     "BLUE",
2074     "MAGENTA",
2075     "CYAN",
2076     "WHITE"
2077 };
2078
2079 static void
2080 show_color_name(int y, int x, int color, bool wide)
2081 {
2082     if (move(y, x) != ERR) {
2083         char temp[80];
2084         int width = 8;
2085
2086         if (wide) {
2087             sprintf(temp, "%02d", color);
2088             width = 4;
2089         } else if (color >= 8) {
2090             sprintf(temp, "[%02d]", color);
2091         } else if (color < 0) {
2092             strcpy(temp, "default");
2093         } else {
2094             sprintf(temp, "%.*s", 16, the_color_names[color]);
2095         }
2096         printw("%-*.*s", width, width, temp);
2097     }
2098 }
2099
2100 static void
2101 color_legend(WINDOW *helpwin, bool wide)
2102 {
2103     int row = 1;
2104     int col = 1;
2105
2106     MvWPrintw(helpwin, row++, col,
2107               "ESC to exit.");
2108     ++row;
2109     MvWPrintw(helpwin, row++, col,
2110               "Use up/down arrow to scroll through the display if it is");
2111     MvWPrintw(helpwin, row++, col,
2112               "longer than one screen. Control/N and Control/P can be used");
2113     MvWPrintw(helpwin, row++, col,
2114               "in place of up/down arrow.  Use pageup/pagedown to scroll a");
2115     MvWPrintw(helpwin, row++, col,
2116               "full screen; control/B and control/F can be used here.");
2117     ++row;
2118     MvWPrintw(helpwin, row++, col,
2119               "Toggles:");
2120     MvWPrintw(helpwin, row++, col,
2121               "  a/A     toggle altcharset off/on");
2122     MvWPrintw(helpwin, row++, col,
2123               "  b/B     toggle bold off/on");
2124     if (has_colors()) {
2125         MvWPrintw(helpwin, row++, col,
2126                   "  c/C     cycle used-colors through 8,16,...,COLORS");
2127     }
2128     MvWPrintw(helpwin, row++, col,
2129               "  n/N     toggle text/number on/off");
2130     MvWPrintw(helpwin, row++, col,
2131               "  r/R     toggle reverse on/off");
2132     MvWPrintw(helpwin, row++, col,
2133               "  w/W     toggle width between 8/16 colors");
2134 #if USE_WIDEC_SUPPORT
2135     if (wide) {
2136         MvWPrintw(helpwin, row++, col,
2137                   "Wide characters:");
2138         MvWPrintw(helpwin, row, col,
2139                   "  x/X     toggle text between ASCII and wide-character");
2140     }
2141 #else
2142     (void) wide;
2143 #endif
2144 }
2145
2146 #define set_color_test(name, value) if (name != value) { name = value; base_row = 0; }
2147
2148 static int
2149 color_cycle(int current, int step)
2150 {
2151     int result = current;
2152     if (step < 0) {
2153         if (current <= 8) {
2154             result = COLORS;
2155         } else {
2156             result = 8;
2157             if ((result * 2) > COLORS) {
2158                 result = COLORS;
2159             } else {
2160                 while ((result * 2) < current) {
2161                     result *= 2;
2162                 }
2163             }
2164         }
2165     } else {
2166         if (current >= COLORS) {
2167             result = 8;
2168         } else {
2169             result *= 2;
2170         }
2171         if (result > COLORS)
2172             result = COLORS;
2173     }
2174     return result;
2175 }
2176
2177 /* generate a color test pattern */
2178 static void
2179 color_test(void)
2180 {
2181     NCURSES_PAIRS_T i;
2182     int top = 0, width;
2183     int base_row = 0;
2184     int grid_top = top + 3;
2185     int page_size = (LINES - grid_top);
2186     int pairs_max;
2187     int colors_max = COLORS;
2188     int col_limit;
2189     int row_limit;
2190     int per_row;
2191     char *numbered = 0;
2192     const char *hello;
2193     bool done = FALSE;
2194     bool opt_acsc = FALSE;
2195     bool opt_bold = FALSE;
2196     bool opt_revs = FALSE;
2197     bool opt_nums = FALSE;
2198     bool opt_wide = FALSE;
2199     WINDOW *helpwin;
2200
2201     numbered = (char *) calloc((size_t) (COLS + 1), sizeof(char));
2202     done = ((COLS < 16) || (numbered == 0));
2203
2204     /*
2205      * Because the number of colors is usually a power of two, we also use
2206      * a power of two for the number of colors shown per line (to be tidy).
2207      */
2208     for (col_limit = 1; col_limit * 2 < COLS; col_limit *= 2) ;
2209
2210     while (!done) {
2211         int shown = 0;
2212
2213         pairs_max = PAIR_NUMBER(A_COLOR) + 1;
2214         if (colors_max * colors_max <= COLOR_PAIRS) {
2215             int limit = (colors_max - min_colors) * (colors_max - min_colors);
2216             if (pairs_max > limit)
2217                 pairs_max = limit;
2218         } else {
2219             if (pairs_max > COLOR_PAIRS)
2220                 pairs_max = COLOR_PAIRS;
2221         }
2222
2223         /* this assumes an 80-column line */
2224         if (opt_wide) {
2225             width = 4;
2226             hello = "Test";
2227             per_row = (col_limit / ((colors_max > 8) ? 4 : 8));
2228         } else {
2229             width = 8;
2230             hello = "Hello";
2231             per_row = (col_limit / 8);
2232         }
2233         per_row -= min_colors;
2234
2235         row_limit = (pairs_max + per_row - 1) / per_row;
2236
2237         move(0, 0);
2238         (void) printw("There are %d color pairs and %d colors",
2239                       pairs_max, COLORS);
2240         if (colors_max != COLORS)
2241             (void) printw(" (using %d colors)", colors_max);
2242         if (min_colors)
2243             (void) addstr(" besides 'default'");
2244
2245         clrtobot();
2246         MvPrintw(top + 1, 0,
2247                  "%dx%d matrix of foreground/background colors, bold *%s*\n",
2248                  row_limit,
2249                  per_row,
2250                  opt_bold ? "on" : "off");
2251
2252         /* show color names/numbers across the top */
2253         for (i = 0; i < per_row; i++)
2254             show_color_name(top + 2, (i + 1) * width, i + min_colors, opt_wide);
2255
2256         /* show a grid of colors, with color names/ numbers on the left */
2257         for (i = (NCURSES_PAIRS_T) (base_row * per_row); i < pairs_max; i++) {
2258             int row = grid_top + (i / per_row) - base_row;
2259             int col = (i % per_row + 1) * width;
2260             NCURSES_PAIRS_T pair = i;
2261
2262             if ((i / per_row) > row_limit)
2263                 break;
2264
2265 #define InxToFG(i) (NCURSES_COLOR_T) ((i % (colors_max - min_colors)) + min_colors)
2266 #define InxToBG(i) (NCURSES_COLOR_T) ((i / (colors_max - min_colors)) + min_colors)
2267             if (row >= 0 && move(row, col) != ERR) {
2268                 NCURSES_COLOR_T fg = InxToFG(i);
2269                 NCURSES_COLOR_T bg = InxToBG(i);
2270
2271                 init_pair(pair, fg, bg);
2272                 attron(COLOR_PAIR(pair));
2273                 if (opt_acsc)
2274                     attron(A_ALTCHARSET);
2275                 if (opt_bold)
2276                     attron(A_BOLD);
2277                 if (opt_revs)
2278                     attron(A_REVERSE);
2279
2280                 if (opt_nums) {
2281                     sprintf(numbered, "{%02X}", (int) i);
2282                     hello = numbered;
2283                 }
2284                 printw("%-*.*s", width, width, hello);
2285                 (void) attrset(A_NORMAL);
2286
2287                 if ((i % per_row) == 0 && InxToFG(i) == min_colors) {
2288                     show_color_name(row, 0, InxToBG(i), opt_wide);
2289                 }
2290                 ++shown;
2291             } else if (shown) {
2292                 break;
2293             }
2294         }
2295
2296         switch (wGetchar(stdscr)) {
2297         case 'a':
2298             opt_acsc = FALSE;
2299             break;
2300         case 'A':
2301             opt_acsc = TRUE;
2302             break;
2303         case 'b':
2304             opt_bold = FALSE;
2305             break;
2306         case 'B':
2307             opt_bold = TRUE;
2308             break;
2309         case 'c':
2310             colors_max = color_cycle(colors_max, -1);
2311             break;
2312         case 'C':
2313             colors_max = color_cycle(colors_max, 1);
2314             break;
2315         case 'n':
2316             opt_nums = FALSE;
2317             break;
2318         case 'N':
2319             opt_nums = TRUE;
2320             break;
2321         case 'r':
2322             opt_revs = FALSE;
2323             break;
2324         case 'R':
2325             opt_revs = TRUE;
2326             break;
2327         case case_QUIT:
2328             done = TRUE;
2329             continue;
2330         case 'w':
2331             set_color_test(opt_wide, FALSE);
2332             break;
2333         case 'W':
2334             set_color_test(opt_wide, TRUE);
2335             break;
2336         case CTRL('p'):
2337         case KEY_UP:
2338             if (base_row <= 0) {
2339                 beep();
2340             } else {
2341                 base_row -= 1;
2342             }
2343             break;
2344         case CTRL('n'):
2345         case KEY_DOWN:
2346             if (base_row + page_size >= row_limit) {
2347                 beep();
2348             } else {
2349                 base_row += 1;
2350             }
2351             break;
2352         case CTRL('b'):
2353         case KEY_PREVIOUS:
2354         case KEY_PPAGE:
2355             if (base_row <= 0) {
2356                 beep();
2357             } else {
2358                 base_row -= (page_size - 1);
2359                 if (base_row < 0)
2360                     base_row = 0;
2361             }
2362             break;
2363         case CTRL('f'):
2364         case KEY_NEXT:
2365         case KEY_NPAGE:
2366             if (base_row + page_size >= row_limit) {
2367                 beep();
2368             } else {
2369                 base_row += page_size - 1;
2370                 if (base_row + page_size >= row_limit) {
2371                     base_row = row_limit - page_size - 1;
2372                 }
2373             }
2374             break;
2375         case '?':
2376             if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
2377                 box(helpwin, 0, 0);
2378                 color_legend(helpwin, FALSE);
2379                 wGetchar(helpwin);
2380                 delwin(helpwin);
2381             }
2382             break;
2383         default:
2384             beep();
2385             continue;
2386         }
2387     }
2388
2389     erase();
2390     endwin();
2391
2392     free(numbered);
2393 }
2394
2395 #if USE_WIDEC_SUPPORT
2396 /* generate a color test pattern */
2397 static void
2398 wide_color_test(void)
2399 {
2400     int i;
2401     int top = 0, width;
2402     int base_row = 0;
2403     int grid_top = top + 3;
2404     int page_size = (LINES - grid_top);
2405     int pairs_max = (unsigned short) (-1);
2406     int colors_max = COLORS;
2407     int col_limit;
2408     int row_limit;
2409     int per_row;
2410     char *numbered = 0;
2411     const char *hello;
2412     bool done = FALSE;
2413     bool opt_acsc = FALSE;
2414     bool opt_bold = FALSE;
2415     bool opt_revs = FALSE;
2416     bool opt_wide = FALSE;
2417     bool opt_nums = FALSE;
2418     bool opt_xchr = FALSE;
2419     wchar_t *buffer = 0;
2420     WINDOW *helpwin;
2421
2422     numbered = (char *) calloc((size_t) (COLS + 1), sizeof(char));
2423     buffer = (wchar_t *) calloc((size_t) (COLS + 1), sizeof(wchar_t));
2424     done = ((COLS < 16) || (numbered == 0) || (buffer == 0));
2425
2426     /*
2427      * Because the number of colors is usually a power of two, we also use
2428      * a power of two for the number of colors shown per line (to be tidy).
2429      */
2430     for (col_limit = 1; col_limit * 2 < COLS; col_limit *= 2) ;
2431
2432     while (!done) {
2433         int shown = 0;
2434
2435         pairs_max = (unsigned short) (-1);
2436         if (colors_max * colors_max <= COLOR_PAIRS) {
2437             int limit = (colors_max - min_colors) * (colors_max - min_colors);
2438             if (pairs_max > limit)
2439                 pairs_max = limit;
2440         } else {
2441             if (pairs_max > COLOR_PAIRS)
2442                 pairs_max = COLOR_PAIRS;
2443         }
2444
2445         if (opt_wide) {
2446             width = 4;
2447             hello = "Test";
2448             per_row = (col_limit / ((colors_max > 8) ? 4 : 8));
2449         } else {
2450             width = 8;
2451             hello = "Hello";
2452             per_row = (col_limit / 8);
2453         }
2454         per_row -= min_colors;
2455
2456         if (opt_xchr) {
2457             make_fullwidth_text(buffer, hello);
2458             width *= 2;
2459             per_row /= 2;
2460         } else {
2461             make_narrow_text(buffer, hello);
2462         }
2463
2464         row_limit = (pairs_max + per_row - 1) / per_row;
2465
2466         move(0, 0);
2467         (void) printw("There are %d color pairs and %d colors",
2468                       pairs_max, COLORS);
2469         if (colors_max != COLORS)
2470             (void) printw(" (using %d colors)", colors_max);
2471         if (min_colors)
2472             (void) addstr(" besides 'default'");
2473
2474         clrtobot();
2475         MvPrintw(top + 1, 0,
2476                  "%dx%d matrix of foreground/background colors, bold *%s*\n",
2477                  row_limit,
2478                  per_row,
2479                  opt_bold ? "on" : "off");
2480
2481         /* show color names/numbers across the top */
2482         for (i = 0; i < per_row; i++)
2483             show_color_name(top + 2, (i + 1) * width, i + min_colors, opt_wide);
2484
2485         /* show a grid of colors, with color names/ numbers on the left */
2486         for (i = (base_row * per_row); i < pairs_max; i++) {
2487             int row = grid_top + (i / per_row) - base_row;
2488             int col = (i % per_row + 1) * width;
2489             NCURSES_PAIRS_T pair = (NCURSES_PAIRS_T) i;
2490
2491             if ((i / per_row) > row_limit)
2492                 break;
2493
2494             if (row >= 0 && move(row, col) != ERR) {
2495                 init_pair(pair, InxToFG(i), InxToBG(i));
2496                 (void) color_set(pair, NULL);
2497                 if (opt_acsc)
2498                     attr_on(A_ALTCHARSET, NULL);
2499                 if (opt_bold)
2500                     attr_on(A_BOLD, NULL);
2501                 if (opt_revs)
2502                     attr_on(A_REVERSE, NULL);
2503
2504                 if (opt_nums) {
2505                     sprintf(numbered, "{%02X}", i);
2506                     if (opt_xchr) {
2507                         make_fullwidth_text(buffer, numbered);
2508                     } else {
2509                         make_narrow_text(buffer, numbered);
2510                     }
2511                 }
2512                 addnwstr(buffer, width);
2513                 (void) attr_set(A_NORMAL, 0, NULL);
2514
2515                 if ((i % per_row) == 0 && InxToFG(i) == min_colors) {
2516                     show_color_name(row, 0, InxToBG(i), opt_wide);
2517                 }
2518                 ++shown;
2519             } else if (shown) {
2520                 break;
2521             }
2522         }
2523
2524         switch (wGetchar(stdscr)) {
2525         case 'a':
2526             opt_acsc = FALSE;
2527             break;
2528         case 'A':
2529             opt_acsc = TRUE;
2530             break;
2531         case 'b':
2532             opt_bold = FALSE;
2533             break;
2534         case 'B':
2535             opt_bold = TRUE;
2536             break;
2537         case 'c':
2538             colors_max = color_cycle(colors_max, -1);
2539             break;
2540         case 'C':
2541             colors_max = color_cycle(colors_max, 1);
2542             break;
2543         case 'n':
2544             opt_nums = FALSE;
2545             break;
2546         case 'N':
2547             opt_nums = TRUE;
2548             break;
2549         case 'r':
2550             opt_revs = FALSE;
2551             break;
2552         case 'R':
2553             opt_revs = TRUE;
2554             break;
2555         case case_QUIT:
2556             done = TRUE;
2557             continue;
2558         case 'w':
2559             set_color_test(opt_wide, FALSE);
2560             break;
2561         case 'W':
2562             set_color_test(opt_wide, TRUE);
2563             break;
2564         case 'x':
2565             opt_xchr = FALSE;
2566             break;
2567         case 'X':
2568             opt_xchr = TRUE;
2569             break;
2570         case CTRL('p'):
2571         case KEY_UP:
2572             if (base_row <= 0) {
2573                 beep();
2574             } else {
2575                 base_row -= 1;
2576             }
2577             break;
2578         case CTRL('n'):
2579         case KEY_DOWN:
2580             if (base_row + page_size >= row_limit) {
2581                 beep();
2582             } else {
2583                 base_row += 1;
2584             }
2585             break;
2586         case CTRL('b'):
2587         case KEY_PREVIOUS:
2588         case KEY_PPAGE:
2589             if (base_row <= 0) {
2590                 beep();
2591             } else {
2592                 base_row -= (page_size - 1);
2593                 if (base_row < 0)
2594                     base_row = 0;
2595             }
2596             break;
2597         case CTRL('f'):
2598         case KEY_NEXT:
2599         case KEY_NPAGE:
2600             if (base_row + page_size >= row_limit) {
2601                 beep();
2602             } else {
2603                 base_row += page_size - 1;
2604                 if (base_row + page_size >= row_limit) {
2605                     base_row = row_limit - page_size - 1;
2606                 }
2607             }
2608             break;
2609         case '?':
2610             if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
2611                 box(helpwin, 0, 0);
2612                 color_legend(helpwin, TRUE);
2613                 wGetchar(helpwin);
2614                 delwin(helpwin);
2615             }
2616             break;
2617         default:
2618             beep();
2619             continue;
2620         }
2621     }
2622
2623     erase();
2624     endwin();
2625
2626     free(numbered);
2627     free(buffer);
2628 }
2629 #endif /* USE_WIDEC_SUPPORT */
2630
2631 static void
2632 change_color(NCURSES_PAIRS_T current, int field, int value, int usebase)
2633 {
2634     NCURSES_COLOR_T red, green, blue;
2635
2636     color_content(current, &red, &green, &blue);
2637
2638     switch (field) {
2639     case 0:
2640         red = (NCURSES_COLOR_T) (usebase ? (red + value) : value);
2641         break;
2642     case 1:
2643         green = (NCURSES_COLOR_T) (usebase ? (green + value) : value);
2644         break;
2645     case 2:
2646         blue = (NCURSES_COLOR_T) (usebase ? (blue + value) : value);
2647         break;
2648     }
2649
2650     if (init_color(current, red, green, blue) == ERR)
2651         beep();
2652 }
2653
2654 static void
2655 init_all_colors(void)
2656 {
2657     NCURSES_PAIRS_T c;
2658
2659     for (c = 0; c < COLORS; ++c)
2660         init_color(c,
2661                    all_colors[c].red,
2662                    all_colors[c].green,
2663                    all_colors[c].blue);
2664 }
2665
2666 #define scaled_rgb(n) ((255 * (n)) / 1000)
2667
2668 static void
2669 color_edit(void)
2670 /* display the color test pattern, without trying to edit colors */
2671 {
2672     int i;
2673     int current = 0;
2674     int this_c = 0, value = 0, field = 0;
2675     int last_c;
2676     int top_color = 0;
2677     int page_size = (LINES - 6);
2678
2679     init_all_colors();
2680     refresh();
2681
2682     for (i = 0; i < max_colors; i++)
2683         init_pair((NCURSES_PAIRS_T) i,
2684                   (NCURSES_COLOR_T) COLOR_WHITE,
2685                   (NCURSES_COLOR_T) i);
2686
2687     MvPrintw(LINES - 2, 0, "Number: %d", value);
2688
2689     do {
2690         NCURSES_COLOR_T red, green, blue;
2691
2692         attron(A_BOLD);
2693         MvAddStr(0, 20, "Color RGB Value Editing");
2694         attroff(A_BOLD);
2695
2696         for (i = (NCURSES_COLOR_T) top_color;
2697              (i - top_color < page_size)
2698              && (i < max_colors); i++) {
2699             char numeric[80];
2700
2701             sprintf(numeric, "[%d]", i);
2702             MvPrintw(2 + i - top_color, 0, "%c %-8s:",
2703                      (i == current ? '>' : ' '),
2704                      (i < (int) SIZEOF(the_color_names)
2705                       ? the_color_names[i] : numeric));
2706             (void) attrset(AttrArg(COLOR_PAIR(i), 0));
2707             addstr("        ");
2708             (void) attrset(A_NORMAL);
2709
2710             color_content((NCURSES_PAIRS_T) i, &red, &green, &blue);
2711             addstr("   R = ");
2712             if (current == i && field == 0)
2713                 attron(A_STANDOUT);
2714             printw("%04d", (int) red);
2715             if (current == i && field == 0)
2716                 (void) attrset(A_NORMAL);
2717             addstr(", G = ");
2718             if (current == i && field == 1)
2719                 attron(A_STANDOUT);
2720             printw("%04d", (int) green);
2721             if (current == i && field == 1)
2722                 (void) attrset(A_NORMAL);
2723             addstr(", B = ");
2724             if (current == i && field == 2)
2725                 attron(A_STANDOUT);
2726             printw("%04d", (int) blue);
2727             if (current == i && field == 2)
2728                 (void) attrset(A_NORMAL);
2729             (void) attrset(A_NORMAL);
2730             printw(" ( %3d %3d %3d )",
2731                    (int) scaled_rgb(red),
2732                    (int) scaled_rgb(green),
2733                    (int) scaled_rgb(blue));
2734         }
2735
2736         MvAddStr(LINES - 3, 0,
2737                  "Use up/down to select a color, left/right to change fields.");
2738         MvAddStr(LINES - 2, 0,
2739                  "Modify field by typing nnn=, nnn-, or nnn+.  ? for help.");
2740
2741         move(2 + current - top_color, 0);
2742
2743         last_c = this_c;
2744         this_c = Getchar();
2745         if (this_c < 256 && isdigit(this_c) && !isdigit(last_c))
2746             value = 0;
2747
2748         switch (this_c) {
2749         case CTRL('b'):
2750         case KEY_PPAGE:
2751             if (current > 0)
2752                 current -= (page_size - 1);
2753             else
2754                 beep();
2755             break;
2756
2757         case CTRL('f'):
2758         case KEY_NPAGE:
2759             if (current < (max_colors - 1))
2760                 current += (page_size - 1);
2761             else
2762                 beep();
2763             break;
2764
2765         case CTRL('p'):
2766         case KEY_UP:
2767             current = (current == 0 ? (max_colors - 1) : current - 1);
2768             break;
2769
2770         case CTRL('n'):
2771         case KEY_DOWN:
2772             current = (current == (max_colors - 1) ? 0 : current + 1);
2773             break;
2774
2775         case KEY_RIGHT:
2776             field = (field == 2 ? 0 : field + 1);
2777             break;
2778
2779         case KEY_LEFT:
2780             field = (field == 0 ? 2 : field - 1);
2781             break;
2782
2783         case '0':
2784         case '1':
2785         case '2':
2786         case '3':
2787         case '4':
2788         case '5':
2789         case '6':
2790         case '7':
2791         case '8':
2792         case '9':
2793             value = value * 10 + (this_c - '0');
2794             break;
2795
2796         case '+':
2797             change_color((NCURSES_PAIRS_T) current, field, value, 1);
2798             break;
2799
2800         case '-':
2801             change_color((NCURSES_PAIRS_T) current, field, -value, 1);
2802             break;
2803
2804         case '=':
2805             change_color((NCURSES_PAIRS_T) current, field, value, 0);
2806             break;
2807
2808         case '?':
2809             erase();
2810             P("                      RGB Value Editing Help");
2811             P("");
2812             P("You are in the RGB value editor.  Use the arrow keys to select one of");
2813             P("the fields in one of the RGB triples of the current colors; the one");
2814             P("currently selected will be reverse-video highlighted.");
2815             P("");
2816             P("To change a field, enter the digits of the new value; they are echoed");
2817             P("as entered.  Finish by typing `='.  The change will take effect instantly.");
2818             P("To increment or decrement a value, use the same procedure, but finish");
2819             P("with a `+' or `-'.");
2820             P("");
2821             P("Press 'm' to invoke the top-level menu with the current color settings.");
2822             P("To quit, do ESC");
2823
2824             Pause();
2825             erase();
2826             break;
2827
2828         case 'm':
2829             endwin();
2830             main_menu(FALSE);
2831             for (i = 0; i < max_colors; i++)
2832                 init_pair((NCURSES_PAIRS_T) i,
2833                           (NCURSES_COLOR_T) COLOR_WHITE,
2834                           (NCURSES_COLOR_T) i);
2835             refresh();
2836             break;
2837
2838         case case_QUIT:
2839             break;
2840
2841         default:
2842             beep();
2843             break;
2844         }
2845
2846         if (current < 0)
2847             current = 0;
2848         if (current >= max_colors)
2849             current = max_colors - 1;
2850         if (current < top_color)
2851             top_color = current;
2852         if (current - top_color >= page_size)
2853             top_color = current - (page_size - 1);
2854
2855         MvPrintw(LINES - 1, 0, "Number: %d", value);
2856         clrtoeol();
2857     } while
2858         (!isQuit(this_c));
2859
2860     erase();
2861
2862     /*
2863      * ncurses does not reset each color individually when calling endwin().
2864      */
2865     init_all_colors();
2866
2867     endwin();
2868 }
2869
2870 /****************************************************************************
2871  *
2872  * Alternate character-set stuff
2873  *
2874  ****************************************************************************/
2875 static bool
2876 cycle_attr(int ch, unsigned *at_code, chtype *attr, ATTR_TBL * list, unsigned limit)
2877 {
2878     bool result = TRUE;
2879
2880     switch (ch) {
2881     case 'v':
2882         if ((*at_code += 1) >= limit)
2883             *at_code = 0;
2884         break;
2885     case 'V':
2886         if (*at_code == 0)
2887             *at_code = limit - 1;
2888         else
2889             *at_code -= 1;
2890         break;
2891     default:
2892         result = FALSE;
2893         break;
2894     }
2895     if (result)
2896         *attr = list[*at_code].attr;
2897     return result;
2898 }
2899
2900 static bool
2901 cycle_colors(int ch, int *fg, int *bg, NCURSES_PAIRS_T *pair)
2902 {
2903     bool result = FALSE;
2904
2905     if (use_colors) {
2906         result = TRUE;
2907         switch (ch) {
2908         case 'F':
2909             if ((*fg -= 1) < 0)
2910                 *fg = COLORS - 1;
2911             break;
2912         case 'f':
2913             if ((*fg += 1) >= COLORS)
2914                 *fg = 0;
2915             break;
2916         case 'B':
2917             if ((*bg -= 1) < 0)
2918                 *bg = COLORS - 1;
2919             break;
2920         case 'b':
2921             if ((*bg += 1) >= COLORS)
2922                 *bg = 0;
2923             break;
2924         default:
2925             result = FALSE;
2926             break;
2927         }
2928         if (result) {
2929             *pair = (NCURSES_PAIRS_T) (*fg != COLOR_BLACK || *bg != COLOR_BLACK);
2930             if (*pair != 0) {
2931                 *pair = 1;
2932                 if (init_pair(*pair,
2933                               (NCURSES_COLOR_T) *fg,
2934                               (NCURSES_COLOR_T) *bg) == ERR) {
2935                     result = FALSE;
2936                 }
2937             }
2938         }
2939     }
2940     return result;
2941 }
2942
2943 /****************************************************************************
2944  *
2945  * Soft-key label test
2946  *
2947  ****************************************************************************/
2948
2949 #if USE_SOFTKEYS
2950
2951 #define SLK_HELP 17
2952 #define SLK_WORK (SLK_HELP + 3)
2953
2954 static void
2955 slk_help(void)
2956 {
2957     static const char *table[] =
2958     {
2959         "Available commands are:"
2960         ,""
2961         ,"^L         -- repaint this message and activate soft keys"
2962         ,"a/d        -- activate/disable soft keys"
2963         ,"c          -- set centered format for labels"
2964         ,"l          -- set left-justified format for labels"
2965         ,"r          -- set right-justified format for labels"
2966         ,"[12345678] -- set label; labels are numbered 1 through 8"
2967         ,"e          -- erase stdscr (should not erase labels)"
2968         ,"s          -- test scrolling of shortened screen"
2969         ,"v/V        -- cycle through video attributes"
2970 #if HAVE_SLK_COLOR
2971         ,"F/f/B/b    -- cycle through foreground/background colors"
2972 #endif
2973         ,"ESC        -- return to main menu"
2974         ,""
2975         ,"Note: if activating the soft keys causes your terminal to scroll up"
2976         ,"one line, your terminal auto-scrolls when anything is written to the"
2977         ,"last screen position.  The ncurses code does not yet handle this"
2978         ,"gracefully."
2979     };
2980     unsigned j;
2981
2982     move(2, 0);
2983     for (j = 0; j < SIZEOF(table); ++j) {
2984         P(table[j]);
2985     }
2986     refresh();
2987 }
2988
2989 #if HAVE_SLK_COLOR
2990 static void
2991 call_slk_color(int fg, int bg)
2992 {
2993     init_pair(1, (NCURSES_COLOR_T) bg, (NCURSES_COLOR_T) fg);
2994     slk_color(1);
2995     MvPrintw(SLK_WORK, 0, "Colors %d/%d\n", fg, bg);
2996     clrtoeol();
2997     slk_touch();
2998     slk_noutrefresh();
2999     refresh();
3000 }
3001 #endif
3002
3003 static void
3004 slk_test(void)
3005 /* exercise the soft keys */
3006 {
3007     int c, fmt = 1;
3008     char buf[9];
3009     char *s;
3010     chtype attr = A_NORMAL;
3011     unsigned at_code = 0;
3012 #if HAVE_SLK_COLOR
3013     int fg = COLOR_BLACK;
3014     int bg = COLOR_WHITE;
3015     NCURSES_PAIRS_T pair = 0;
3016 #endif
3017     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
3018     unsigned my_size = init_attr_list(my_list, termattrs());
3019
3020     c = CTRL('l');
3021 #if HAVE_SLK_COLOR
3022     if (use_colors) {
3023         call_slk_color(fg, bg);
3024     }
3025 #endif
3026
3027     do {
3028         move(0, 0);
3029         switch (c) {
3030         case CTRL('l'):
3031             erase();
3032             attron(A_BOLD);
3033             MvAddStr(0, 20, "Soft Key Exerciser");
3034             attroff(A_BOLD);
3035
3036             slk_help();
3037             /* fall through */
3038
3039         case 'a':
3040             slk_restore();
3041             break;
3042
3043         case 'e':
3044             wclear(stdscr);
3045             break;
3046
3047         case 's':
3048             MvPrintw(SLK_WORK, 0, "Press Q to stop the scrolling-test: ");
3049             while ((c = Getchar()) != 'Q' && (c != ERR))
3050                 addch((chtype) c);
3051             break;
3052
3053         case 'd':
3054             slk_clear();
3055             break;
3056
3057         case 'l':
3058             fmt = 0;
3059             break;
3060
3061         case 'c':
3062             fmt = 1;
3063             break;
3064
3065         case 'r':
3066             fmt = 2;
3067             break;
3068
3069         case '1':
3070         case '2':
3071         case '3':
3072         case '4':
3073         case '5':
3074         case '6':
3075         case '7':
3076         case '8':
3077             MvAddStr(SLK_WORK, 0, "Please enter the label value: ");
3078             strcpy(buf, "");
3079             if ((s = slk_label(c - '0')) != 0) {
3080                 strncpy(buf, s, (size_t) 8);
3081             }
3082             wGetstring(stdscr, buf, 8);
3083             slk_set((c - '0'), buf, fmt);
3084             slk_refresh();
3085             move(SLK_WORK, 0);
3086             clrtobot();
3087             break;
3088
3089         case case_QUIT:
3090             goto done;
3091
3092 #if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
3093         case KEY_RESIZE:
3094             wnoutrefresh(stdscr);
3095             break;
3096 #endif
3097
3098         default:
3099             if (cycle_attr(c, &at_code, &attr, my_list, my_size)) {
3100                 slk_attrset(attr);
3101                 slk_touch();
3102                 slk_noutrefresh();
3103                 break;
3104             }
3105 #if HAVE_SLK_COLOR
3106             if (cycle_colors(c, &fg, &bg, &pair)) {
3107                 if (use_colors) {
3108                     call_slk_color(fg, bg);
3109                 } else {
3110                     beep();
3111                 }
3112                 break;
3113             }
3114 #endif
3115             beep();
3116             break;
3117         }
3118     } while (!isQuit(c = Getchar()));
3119
3120   done:
3121     slk_clear();
3122     erase();
3123     endwin();
3124 }
3125
3126 #if USE_WIDEC_SUPPORT
3127 #define SLKLEN 8
3128 static void
3129 wide_slk_test(void)
3130 /* exercise the soft keys */
3131 {
3132     int c, fmt = 1;
3133     wchar_t buf[SLKLEN + 1];
3134     char *s;
3135     chtype attr = A_NORMAL;
3136     unsigned at_code = 0;
3137     int fg = COLOR_BLACK;
3138     int bg = COLOR_WHITE;
3139     NCURSES_PAIRS_T pair = 0;
3140     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
3141     unsigned my_size = init_attr_list(my_list, term_attrs());
3142
3143     c = CTRL('l');
3144     if (use_colors) {
3145         call_slk_color(fg, bg);
3146     }
3147     do {
3148         move(0, 0);
3149         switch (c) {
3150         case CTRL('l'):
3151             erase();
3152             attr_on(WA_BOLD, NULL);
3153             MvAddStr(0, 20, "Soft Key Exerciser");
3154             attr_off(WA_BOLD, NULL);
3155
3156             slk_help();
3157             /* fall through */
3158
3159         case 'a':
3160             slk_restore();
3161             break;
3162
3163         case 'e':
3164             wclear(stdscr);
3165             break;
3166
3167         case 's':
3168             MvPrintw(SLK_WORK, 0, "Press Q to stop the scrolling-test: ");
3169             while ((c = Getchar()) != 'Q' && (c != ERR))
3170                 addch((chtype) c);
3171             break;
3172
3173         case 'd':
3174             slk_clear();
3175             break;
3176
3177         case 'l':
3178             fmt = 0;
3179             break;
3180
3181         case 'c':
3182             fmt = 1;
3183             break;
3184
3185         case 'r':
3186             fmt = 2;
3187             break;
3188
3189         case '1':
3190         case '2':
3191         case '3':
3192         case '4':
3193         case '5':
3194         case '6':
3195         case '7':
3196         case '8':
3197             MvAddStr(SLK_WORK, 0, "Please enter the label value: ");
3198             *buf = 0;
3199             if ((s = slk_label(c - '0')) != 0) {
3200                 char *temp = strdup(s);
3201                 size_t used = strlen(temp);
3202                 size_t want = SLKLEN;
3203                 size_t test;
3204 #ifndef state_unused
3205                 mbstate_t state;
3206 #endif
3207
3208                 buf[0] = L'\0';
3209                 while (want > 0 && used != 0) {
3210                     const char *base = s;
3211                     reset_mbytes(state);
3212                     test = count_mbytes(base, 0, &state);
3213                     if (test == (size_t) -1) {
3214                         temp[--used] = 0;
3215                     } else if (test > want) {
3216                         temp[--used] = 0;
3217                     } else {
3218                         reset_mbytes(state);
3219                         trans_mbytes(buf, base, want, &state);
3220                         break;
3221                     }
3222                 }
3223                 free(temp);
3224             }
3225             wGet_wstring(stdscr, buf, SLKLEN);
3226             slk_wset((c - '0'), buf, fmt);
3227             slk_refresh();
3228             move(SLK_WORK, 0);
3229             clrtobot();
3230             break;
3231
3232         case case_QUIT:
3233             goto done;
3234
3235         case 'F':
3236             if (use_colors) {
3237                 fg = (NCURSES_COLOR_T) ((fg + 1) % COLORS);
3238                 call_slk_color(fg, bg);
3239             }
3240             break;
3241         case 'B':
3242             if (use_colors) {
3243                 bg = (NCURSES_COLOR_T) ((bg + 1) % COLORS);
3244                 call_slk_color(fg, bg);
3245             }
3246             break;
3247 #if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
3248         case KEY_RESIZE:
3249             wnoutrefresh(stdscr);
3250             break;
3251 #endif
3252         default:
3253             if (cycle_attr(c, &at_code, &attr, my_list, my_size)) {
3254                 slk_attr_set(attr, (NCURSES_COLOR_T) (fg || bg), NULL);
3255                 slk_touch();
3256                 slk_noutrefresh();
3257                 break;
3258             }
3259 #if HAVE_SLK_COLOR
3260             if (cycle_colors(c, &fg, &bg, &pair)) {
3261                 if (use_colors) {
3262                     call_slk_color(fg, bg);
3263                 } else {
3264                     beep();
3265                 }
3266                 break;
3267             }
3268 #endif
3269             beep();
3270             break;
3271         }
3272     } while (!isQuit(c = Getchar()));
3273
3274   done:
3275     slk_clear();
3276     erase();
3277     endwin();
3278 }
3279 #endif
3280 #endif /* SLK_INIT */
3281
3282 static void
3283 show_256_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3284 {
3285     unsigned first = 0;
3286     unsigned last = 255;
3287     unsigned code;
3288     int count;
3289
3290     erase();
3291     attron(A_BOLD);
3292     MvPrintw(0, 20, "Display of Character Codes %#0x to %#0x",
3293              first, last);
3294     attroff(A_BOLD);
3295     refresh();
3296
3297     for (code = first; code <= last; ++code) {
3298         int row = (int) (2 + (code / 16));
3299         int col = (int) (5 * (code % 16));
3300         IGNORE_RC(mvaddch(row, col, colored_chtype(code, attr, pair)));
3301         for (count = 1; count < repeat; ++count) {
3302             addch(colored_chtype(code, attr, pair));
3303         }
3304     }
3305
3306 }
3307
3308 /*
3309  * Show a slice of 32 characters, allowing those to be repeated up to the
3310  * screen's width.
3311  *
3312  * ISO 6429:  codes 0x80 to 0x9f may be control characters that cause the
3313  * terminal to perform functions.  The remaining codes can be graphic.
3314  */
3315 static void
3316 show_upper_chars(int base, int pagesize, int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3317 {
3318     unsigned code;
3319     unsigned first = (unsigned) base;
3320     unsigned last = first + (unsigned) pagesize - 2;
3321     bool C1 = (first == 128);
3322     int reply;
3323
3324     erase();
3325     attron(A_BOLD);
3326     MvPrintw(0, 20, "Display of %s Character Codes %d to %d",
3327              C1 ? "C1" : "GR", first, last);
3328     attroff(A_BOLD);
3329     refresh();
3330
3331     for (code = first; code <= last; code++) {
3332         int count = repeat;
3333         int row = 2 + ((int) (code - first) % (pagesize / 2));
3334         int col = ((int) (code - first) / (pagesize / 2)) * COLS / 2;
3335         char tmp[80];
3336         sprintf(tmp, "%3u (0x%x)", code, code);
3337         MvPrintw(row, col, "%*s: ", COLS / 4, tmp);
3338
3339         do {
3340             if (C1)
3341                 nodelay(stdscr, TRUE);
3342             echochar(colored_chtype(code, attr, pair));
3343             if (C1) {
3344                 /* (yes, this _is_ crude) */
3345                 while ((reply = Getchar()) != ERR) {
3346                     addch(UChar(reply));
3347                     napms(10);
3348                 }
3349                 nodelay(stdscr, FALSE);
3350             }
3351         } while (--count > 0);
3352     }
3353 }
3354
3355 #define PC_COLS 4
3356
3357 static void
3358 show_pc_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3359 {
3360     unsigned code;
3361
3362     erase();
3363     attron(A_BOLD);
3364     MvPrintw(0, 20, "Display of PC Character Codes");
3365     attroff(A_BOLD);
3366     refresh();
3367
3368     for (code = 0; code < 16; ++code) {
3369         MvPrintw(2, (int) code * PC_COLS + 8, "%X", code);
3370     }
3371     for (code = 0; code < 256; code++) {
3372         int count = repeat;
3373         int row = 3 + (int) (code / 16) + (code >= 128);
3374         int col = 8 + (int) (code % 16) * PC_COLS;
3375         if ((code % 16) == 0)
3376             MvPrintw(row, 0, "0x%02x:", code);
3377         move(row, col);
3378         do {
3379             switch (code) {
3380             case '\n':
3381             case '\r':
3382             case '\b':
3383             case '\f':
3384             case '\033':
3385             case 0x9b:
3386                 /*
3387                  * Skip the ones that do not work.
3388                  */
3389                 break;
3390             default:
3391                 addch(colored_chtype(code, A_ALTCHARSET | attr, pair));
3392                 break;
3393             }
3394         } while (--count > 0);
3395     }
3396 }
3397
3398 static void
3399 show_box_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3400 {
3401     (void) repeat;
3402
3403     attr |= (attr_t) COLOR_PAIR(pair);
3404
3405     erase();
3406     attron(A_BOLD);
3407     MvAddStr(0, 20, "Display of the ACS Line-Drawing Set");
3408     attroff(A_BOLD);
3409     refresh();
3410     /* *INDENT-OFF* */
3411     wborder(stdscr,
3412             colored_chtype(ACS_VLINE,    attr, pair),
3413             colored_chtype(ACS_VLINE,    attr, pair),
3414             colored_chtype(ACS_HLINE,    attr, pair),
3415             colored_chtype(ACS_HLINE,    attr, pair),
3416             colored_chtype(ACS_ULCORNER, attr, pair),
3417             colored_chtype(ACS_URCORNER, attr, pair),
3418             colored_chtype(ACS_LLCORNER, attr, pair),
3419             colored_chtype(ACS_LRCORNER, attr, pair));
3420     MvHLine(LINES / 2, 0,        colored_chtype(ACS_HLINE, attr, pair), COLS);
3421     MvVLine(0,         COLS / 2, colored_chtype(ACS_VLINE, attr, pair), LINES);
3422     MvAddCh(0,         COLS / 2, colored_chtype(ACS_TTEE,  attr, pair));
3423     MvAddCh(LINES / 2, COLS / 2, colored_chtype(ACS_PLUS,  attr, pair));
3424     MvAddCh(LINES - 1, COLS / 2, colored_chtype(ACS_BTEE,  attr, pair));
3425     MvAddCh(LINES / 2, 0,        colored_chtype(ACS_LTEE,  attr, pair));
3426     MvAddCh(LINES / 2, COLS - 1, colored_chtype(ACS_RTEE,  attr, pair));
3427     /* *INDENT-ON* */
3428
3429 }
3430
3431 static int
3432 show_1_acs(int n, int repeat, const char *name, chtype code)
3433 {
3434     const int height = 16;
3435     int row = 2 + (n % height);
3436     int col = (n / height) * COLS / 2;
3437
3438     MvPrintw(row, col, "%*s : ", COLS / 4, name);
3439     do {
3440         addch(code);
3441     } while (--repeat > 0);
3442     return n + 1;
3443 }
3444
3445 static void
3446 show_acs_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3447 /* display the ACS character set */
3448 {
3449     int n;
3450
3451 #define BOTH(name) #name, colored_chtype(name, attr, (chtype) pair)
3452
3453     erase();
3454     attron(A_BOLD);
3455     MvAddStr(0, 20, "Display of the ACS Character Set");
3456     attroff(A_BOLD);
3457     refresh();
3458
3459     n = show_1_acs(0, repeat, BOTH(ACS_ULCORNER));
3460     n = show_1_acs(n, repeat, BOTH(ACS_URCORNER));
3461     n = show_1_acs(n, repeat, BOTH(ACS_LLCORNER));
3462     n = show_1_acs(n, repeat, BOTH(ACS_LRCORNER));
3463
3464     n = show_1_acs(n, repeat, BOTH(ACS_LTEE));
3465     n = show_1_acs(n, repeat, BOTH(ACS_RTEE));
3466     n = show_1_acs(n, repeat, BOTH(ACS_TTEE));
3467     n = show_1_acs(n, repeat, BOTH(ACS_BTEE));
3468
3469     n = show_1_acs(n, repeat, BOTH(ACS_HLINE));
3470     n = show_1_acs(n, repeat, BOTH(ACS_VLINE));
3471
3472     /*
3473      * HPUX's ACS definitions are broken here.  Just give up.
3474      */
3475 #if !(defined(__hpux) && !defined(NCURSES_VERSION))
3476     n = show_1_acs(n, repeat, BOTH(ACS_LARROW));
3477     n = show_1_acs(n, repeat, BOTH(ACS_RARROW));
3478     n = show_1_acs(n, repeat, BOTH(ACS_UARROW));
3479     n = show_1_acs(n, repeat, BOTH(ACS_DARROW));
3480
3481     n = show_1_acs(n, repeat, BOTH(ACS_BLOCK));
3482     n = show_1_acs(n, repeat, BOTH(ACS_BOARD));
3483     n = show_1_acs(n, repeat, BOTH(ACS_LANTERN));
3484     n = show_1_acs(n, repeat, BOTH(ACS_BULLET));
3485     n = show_1_acs(n, repeat, BOTH(ACS_CKBOARD));
3486     n = show_1_acs(n, repeat, BOTH(ACS_DEGREE));
3487     n = show_1_acs(n, repeat, BOTH(ACS_DIAMOND));
3488     n = show_1_acs(n, repeat, BOTH(ACS_PLMINUS));
3489     n = show_1_acs(n, repeat, BOTH(ACS_PLUS));
3490
3491     n = show_1_acs(n, repeat, BOTH(ACS_GEQUAL));
3492     n = show_1_acs(n, repeat, BOTH(ACS_NEQUAL));
3493     n = show_1_acs(n, repeat, BOTH(ACS_LEQUAL));
3494
3495     n = show_1_acs(n, repeat, BOTH(ACS_STERLING));
3496     n = show_1_acs(n, repeat, BOTH(ACS_PI));
3497     n = show_1_acs(n, repeat, BOTH(ACS_S1));
3498     n = show_1_acs(n, repeat, BOTH(ACS_S3));
3499     n = show_1_acs(n, repeat, BOTH(ACS_S7));
3500     (void) show_1_acs(n, repeat, BOTH(ACS_S9));
3501 #endif
3502 }
3503
3504 static void
3505 acs_display(void)
3506 {
3507     int c = 'a';
3508     int pagesize = 32;
3509     char *term = getenv("TERM");
3510     const char *pch_kludge = ((term != 0 && strstr(term, "linux"))
3511                               ? "p=PC, "
3512                               : "");
3513     chtype attr = A_NORMAL;
3514     int digit = 0;
3515     int repeat = 1;
3516     int fg = COLOR_BLACK;
3517     int bg = COLOR_BLACK;
3518     unsigned at_code = 0;
3519     NCURSES_PAIRS_T pair = 0;
3520     void (*last_show_acs) (int, attr_t, NCURSES_PAIRS_T) = 0;
3521     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
3522     unsigned my_size = init_attr_list(my_list, termattrs());
3523
3524     do {
3525         switch (c) {
3526         case CTRL('L'):
3527             Repaint();
3528             break;
3529         case 'a':
3530             ToggleAcs(last_show_acs, show_acs_chars);
3531             break;
3532         case 'p':
3533             if (*pch_kludge)
3534                 ToggleAcs(last_show_acs, show_pc_chars);
3535             else
3536                 beep();
3537             break;
3538         case 'w':
3539             if (pagesize == 32) {
3540                 pagesize = 256;
3541             } else {
3542                 pagesize = 32;
3543             }
3544             break;
3545         case 'x':
3546             ToggleAcs(last_show_acs, show_box_chars);
3547             break;
3548         case '0':
3549         case '1':
3550         case '2':
3551         case '3':
3552             digit = (c - '0');
3553             last_show_acs = 0;
3554             break;
3555         case '-':
3556             if (digit > 0) {
3557                 --digit;
3558                 last_show_acs = 0;
3559             } else {
3560                 beep();
3561             }
3562             break;
3563         case '+':
3564             if (digit < 3) {
3565                 ++digit;
3566                 last_show_acs = 0;
3567             } else {
3568                 beep();
3569             }
3570             break;
3571         case '>':
3572             if (repeat < (COLS / 4))
3573                 ++repeat;
3574             break;
3575         case '<':
3576             if (repeat > 1)
3577                 --repeat;
3578             break;
3579         default:
3580             if (cycle_attr(c, &at_code, &attr, my_list, my_size)
3581                 || cycle_colors(c, &fg, &bg, &pair)) {
3582                 break;
3583             } else {
3584                 beep();
3585             }
3586             break;
3587         }
3588         if (pagesize != 32) {
3589             show_256_chars(repeat, attr, pair);
3590         } else if (last_show_acs != 0) {
3591             last_show_acs(repeat, attr, pair);
3592         } else {
3593             show_upper_chars(digit * pagesize + 128, pagesize, repeat, attr, pair);
3594         }
3595
3596         MvPrintw(LINES - 3, 0,
3597                  "Note: ANSI terminals may not display C1 characters.");
3598         MvPrintw(LINES - 2, 0,
3599                  "Select: a=ACS, w=all x=box, %s0=C1, 1-3,+/- non-ASCII, </> repeat, ESC=quit",
3600                  pch_kludge);
3601         if (use_colors) {
3602             MvPrintw(LINES - 1, 0,
3603                      "v/V, f/F, b/B cycle through video attributes (%s) and color %d/%d.",
3604                      my_list[at_code].name,
3605                      fg, bg);
3606         } else {
3607             MvPrintw(LINES - 1, 0,
3608                      "v/V cycles through video attributes (%s).",
3609                      my_list[at_code].name);
3610         }
3611         refresh();
3612     } while (!isQuit(c = Getchar()));
3613
3614     Pause();
3615     erase();
3616     endwin();
3617 }
3618
3619 #if USE_WIDEC_SUPPORT
3620 static cchar_t *
3621 merge_wide_attr(cchar_t *dst, const cchar_t *src, attr_t attr, NCURSES_PAIRS_T pair)
3622 {
3623     int count;
3624
3625     *dst = *src;
3626     do {
3627         TEST_CCHAR(src, count, {
3628             attr |= (test_attrs & A_ALTCHARSET);
3629             setcchar(dst, test_wch, attr, pair, NULL);
3630         }
3631         , {
3632             ;
3633         });
3634     } while (0);
3635     return dst;
3636 }
3637
3638 /*
3639  * Header/legend take up no more than 8 lines, leaving 16 lines on a 24-line
3640  * display.  If there are no repeats, we could normally display 16 lines of 64
3641  * characters (1024 total).  However, taking repeats and double-width cells
3642  * into account, use 256 characters for the page.
3643  */
3644 static void
3645 show_paged_widechars(int base,
3646                      int pagesize,
3647                      int repeat,
3648                      int space,
3649                      attr_t attr,
3650                      NCURSES_PAIRS_T pair)
3651 {
3652     int first = base * pagesize;
3653     int last = first + pagesize - 1;
3654     int per_line = 16;
3655     cchar_t temp;
3656     wchar_t code;
3657     wchar_t codes[10];
3658
3659     erase();
3660     attron(A_BOLD);
3661     MvPrintw(0, 20, "Display of Character Codes %#x to %#x", first, last);
3662     attroff(A_BOLD);
3663
3664     for (code = (wchar_t) first; (int) code <= last; code++) {
3665         int row = (2 + ((int) code - first) / per_line);
3666         int col = 5 * ((int) code % per_line);
3667         int count;
3668
3669         memset(&codes, 0, sizeof(codes));
3670         codes[0] = code;
3671         setcchar(&temp, codes, attr, pair, 0);
3672         move(row, col);
3673         if (wcwidth(code) == 0 && code != 0) {
3674             addch((chtype) space |
3675                   (A_REVERSE ^ attr) |
3676                   (attr_t) COLOR_PAIR(pair));
3677         }
3678         add_wch(&temp);
3679         for (count = 1; count < repeat; ++count) {
3680             add_wch(&temp);
3681         }
3682     }
3683 }
3684
3685 static void
3686 show_upper_widechars(int first, int repeat, int space, attr_t attr, NCURSES_PAIRS_T pair)
3687 {
3688     cchar_t temp;
3689     wchar_t code;
3690     int last = first + 31;
3691
3692     erase();
3693     attron(A_BOLD);
3694     MvPrintw(0, 20, "Display of Character Codes %d to %d", first, last);
3695     attroff(A_BOLD);
3696
3697     for (code = (wchar_t) first; (int) code <= last; code++) {
3698         int row = 2 + ((code - first) % 16);
3699         int col = ((code - first) / 16) * COLS / 2;
3700         wchar_t codes[10];
3701         char tmp[80];
3702         int count = repeat;
3703         int y, x;
3704
3705         sprintf(tmp, "%3ld (0x%lx)", (long) code, (long) code);
3706         MvPrintw(row, col, "%*s: ", COLS / 4, tmp);
3707
3708         memset(&codes, 0, sizeof(codes));
3709         codes[0] = code;
3710         setcchar(&temp, codes, attr, pair, 0);
3711
3712         do {
3713             /*
3714              * Give non-spacing characters something to combine with.  If we
3715              * don't, they'll bunch up in a heap on the space after the ":".
3716              * Mark them with reverse-video to make them simpler to find on
3717              * the display.
3718              */
3719             if (wcwidth(code) == 0) {
3720                 addch((chtype) space |
3721                       (A_REVERSE ^ attr) |
3722                       (attr_t) COLOR_PAIR(pair));
3723             }
3724             /*
3725              * This uses echo_wchar(), for comparison with the normal 'f'
3726              * test (and to make a test-case for echo_wchar()).  The screen
3727              * may flicker because the erase() at the top of the function
3728              * is met by the builtin refresh() in echo_wchar().
3729              */
3730             echo_wchar(&temp);
3731             /*
3732              * The repeat-count may make text wrap - avoid that.
3733              */
3734             getyx(stdscr, y, x);
3735             (void) y;
3736             if (x >= col + (COLS / 2) - 2)
3737                 break;
3738         } while (--count > 0);
3739     }
3740 }
3741
3742 static int
3743 show_1_wacs(int n, int repeat, const char *name, const cchar_t *code)
3744 {
3745     const int height = 16;
3746     int row = 2 + (n % height);
3747     int col = (n / height) * COLS / 2;
3748
3749     MvPrintw(row, col, "%*s : ", COLS / 4, name);
3750     while (--repeat >= 0) {
3751         add_wch(code);
3752     }
3753     return n + 1;
3754 }
3755
3756 #define MERGE_ATTR(wch) merge_wide_attr(&temp, wch, attr, pair)
3757
3758 static void
3759 show_wacs_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3760 /* display the wide-ACS character set */
3761 {
3762     cchar_t temp;
3763
3764     int n;
3765
3766 /*#define BOTH2(name) #name, &(name) */
3767 #define BOTH2(name) #name, MERGE_ATTR(name)
3768
3769     erase();
3770     attron(A_BOLD);
3771     MvAddStr(0, 20, "Display of the Wide-ACS Character Set");
3772     attroff(A_BOLD);