test/ncurses.c

   1 /****************************************************************************
   2  * Copyright (c) 1998-2013,2014 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.401 2014/06/21 18:37:29 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_of(int ch)
 307 {
 308     return (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_of(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++ = 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_of(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)
 640 {
 641     memset(flags, FALSE, NUM_GETCH_FLAGS);
 642     flags[UChar('k')] = (win == stdscr);
 643     flags[UChar('m')] = TRUE;
 644
 645     setup_getch(win, flags);
 646 }
 647
 648 static void
 649 wgetch_help(WINDOW *win, GetchFlags flags)
 650 {
 651     static const char *help[] =
 652     {
 653         "e  -- toggle echo mode"
 654         ,"g  -- triggers a getstr test"
 655         ,"k  -- toggle keypad/literal mode"
 656         ,"m  -- toggle meta (7-bit/8-bit) mode"
 657         ,"^q -- quit"
 658         ,"s  -- shell out\n"
 659         ,"w  -- create a new window"
 660 #ifdef SIGTSTP
 661         ,"z  -- suspend this process"
 662 #endif
 663     };
 664     int y, x;
 665     unsigned chk = ((SIZEOF(help) + 1) / 2);
 666     unsigned n;
 667
 668     getyx(win, y, x);
 669     move(0, 0);
 670     printw("Type any key to see its %s value.  Also:\n",
 671            flags['k'] ? "keypad" : "literal");
 672     for (n = 0; n < SIZEOF(help); ++n) {
 673         int row = 1 + (int) (n % chk);
 674         int col = (n >= chk) ? COLS / 2 : 0;
 675         int flg = ((strstr(help[n], "toggle") != 0)
 676                    && (flags[UChar(*help[n])] != FALSE));
 677         if (flg)
 678             (void) standout();
 679         MvPrintw(row, col, "%s", help[n]);
 680         if (col == 0)
 681             clrtoeol();
 682         if (flg)
 683             (void) standend();
 684     }
 685     wrefresh(stdscr);
 686     wmove(win, y, x);
 687 }
 688
 689 static void
 690 wgetch_wrap(WINDOW *win, int first_y)
 691 {
 692     int last_y = getmaxy(win) - 1;
 693     int y = getcury(win) + 1;
 694
 695     if (y >= last_y)
 696         y = first_y;
 697     wmove(win, y, 0);
 698     wclrtoeol(win);
 699 }
 700
 701 #if defined(KEY_RESIZE) && HAVE_WRESIZE
 702 typedef struct {
 703     WINDOW *text;
 704     WINDOW *frame;
 705 } WINSTACK;
 706
 707 static WINSTACK *winstack = 0;
 708 static unsigned len_winstack = 0;
 709
 710 static void
 711 forget_boxes(void)
 712 {
 713     if (winstack != 0) {
 714         free(winstack);
 715     }
 716     winstack = 0;
 717     len_winstack = 0;
 718 }
 719
 720 static void
 721 remember_boxes(unsigned level, WINDOW *txt_win, WINDOW *box_win)
 722 {
 723     unsigned need = (level + 1) * 2;
 724
 725     assert(level < (unsigned) COLS);
 726
 727     if (winstack == 0) {
 728         len_winstack = 20;
 729         winstack = typeMalloc(WINSTACK, len_winstack);
 730     } else if (need >= len_winstack) {
 731         len_winstack = need;
 732         winstack = typeRealloc(WINSTACK, len_winstack, winstack);
 733     }
 734     if (!winstack)
 735         failed("remember_boxes");
 736     winstack[level].text = txt_win;
 737     winstack[level].frame = box_win;
 738 }
 739
 740 #if USE_SOFTKEYS && (defined(NCURSES_VERSION_PATCH) && NCURSES_VERSION_PATCH < 20071229) && NCURSES_EXT_FUNCS
 741 static void
 742 slk_repaint(void)
 743 {
 744     /* this chunk is now done in resize_term() */
 745     slk_touch();
 746     slk_clear();
 747     slk_noutrefresh();
 748 }
 749
 750 #else
 751 #define slk_repaint()           /* nothing */
 752 #endif
 753
 754 #if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
 755 /*
 756  * For wgetch_test(), we create pairs of windows - one for a box, one for text.
 757  * Resize both and paint the box in the parent.
 758  */
 759 static void
 760 resize_boxes(unsigned level, WINDOW *win)
 761 {
 762     unsigned n;
 763     int base = 5;
 764     int high = LINES - base;
 765     int wide = COLS;
 766
 767     touchwin(stdscr);
 768     wnoutrefresh(stdscr);
 769
 770     slk_repaint();
 771
 772     for (n = 0; n < level; ++n) {
 773         wresize(winstack[n].frame, high, wide);
 774         wresize(winstack[n].text, high - 2, wide - 2);
 775         high -= 2;
 776         wide -= 2;
 777         werase(winstack[n].text);
 778         box(winstack[n].frame, 0, 0);
 779         wnoutrefresh(winstack[n].frame);
 780         wprintw(winstack[n].text,
 781                 "size %dx%d\n",
 782                 getmaxy(winstack[n].text),
 783                 getmaxx(winstack[n].text));
 784         wnoutrefresh(winstack[n].text);
 785         if (winstack[n].text == win)
 786             break;
 787     }
 788     doupdate();
 789 }
 790 #endif /* resize_boxes */
 791 #else
 792 #define forget_boxes()          /* nothing */
 793 #define remember_boxes(level,text,frame)        /* nothing */
 794 #endif
 795
 796 /*
 797  * Return-code is OK/ERR or a keyname.
 798  */
 799 static const char *
 800 ok_keyname(int code)
 801 {
 802     return ((code == OK) ? "OK" : ((code == ERR) ? "ERR" : keyname(code)));
 803 }
 804
 805 static void
 806 wgetch_test(unsigned level, WINDOW *win, int delay)
 807 {
 808     char buf[BUFSIZ];
 809     int first_y, first_x;
 810     int c;
 811     int incount = 0;
 812     GetchFlags flags;
 813     bool blocking = (delay < 0);
 814
 815     init_getch(win, flags);
 816     wtimeout(win, delay);
 817     getyx(win, first_y, first_x);
 818
 819     wgetch_help(win, flags);
 820     wsetscrreg(win, first_y, getmaxy(win) - 1);
 821     scrollok(win, TRUE);
 822
 823     for (;;) {
 824         while ((c = wGetchar(win)) == ERR) {
 825             incount++;
 826             if (blocking) {
 827                 (void) wprintw(win, "%05d: input error", incount);
 828                 break;
 829             } else {
 830                 (void) wprintw(win, "%05d: input timed out", incount);
 831             }
 832             wgetch_wrap(win, first_y);
 833         }
 834         if (c == ERR && blocking) {
 835             wprintw(win, "ERR");
 836             wgetch_wrap(win, first_y);
 837         } else if (isQuit(c)) {
 838             break;
 839         } else if (c == 'e') {
 840             flags[UChar('e')] = !flags[UChar('e')];
 841             setup_getch(win, flags);
 842             wgetch_help(win, flags);
 843         } else if (c == 'g') {
 844             waddstr(win, "getstr test: ");
 845             echo();
 846             c = wgetnstr(win, buf, sizeof(buf) - 1);
 847             noecho();
 848             wprintw(win, "I saw %d characters:\n\t`%s' (%s).",
 849                     (int) strlen(buf), buf,
 850                     ok_keyname(c));
 851             wclrtoeol(win);
 852             wgetch_wrap(win, first_y);
 853         } else if (c == 'k') {
 854             flags[UChar('k')] = !flags[UChar('k')];
 855             setup_getch(win, flags);
 856             wgetch_help(win, flags);
 857         } else if (c == 'm') {
 858             flags[UChar('m')] = !flags[UChar('m')];
 859             setup_getch(win, flags);
 860             wgetch_help(win, flags);
 861         } else if (c == 's') {
 862             ShellOut(TRUE);
 863         } else if (c == 'w') {
 864             int high = getmaxy(win) - 1 - first_y + 1;
 865             int wide = getmaxx(win) - first_x;
 866             int old_y, old_x;
 867             int new_y = first_y + getbegy(win);
 868             int new_x = first_x + getbegx(win);
 869
 870             getyx(win, old_y, old_x);
 871             if (high > 2 && wide > 2) {
 872                 WINDOW *wb = newwin(high, wide, new_y, new_x);
 873                 WINDOW *wi = newwin(high - 2, wide - 2, new_y + 1, new_x + 1);
 874
 875                 box(wb, 0, 0);
 876                 wrefresh(wb);
 877                 wmove(wi, 0, 0);
 878                 remember_boxes(level, wi, wb);
 879                 wgetch_test(level + 1, wi, delay);
 880                 delwin(wi);
 881                 delwin(wb);
 882
 883                 wgetch_help(win, flags);
 884                 wmove(win, old_y, old_x);
 885                 touchwin(win);
 886                 wrefresh(win);
 887                 doupdate();
 888             }
 889 #ifdef SIGTSTP
 890         } else if (c == 'z') {
 891             kill(getpid(), SIGTSTP);
 892 #endif
 893         } else {
 894             wprintw(win, "Key pressed: %04o ", c);
 895 #ifdef NCURSES_MOUSE_VERSION
 896             if (c == KEY_MOUSE) {
 897                 show_mouse(win);
 898             } else
 899 #endif /* NCURSES_MOUSE_VERSION */
 900             if (c >= KEY_MIN) {
 901 #if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
 902                 if (c == KEY_RESIZE) {
 903                     resize_boxes(level, win);
 904                 }
 905 #endif
 906                 (void) waddstr(win, keyname(c));
 907             } else if (c >= 0x80) {
 908                 unsigned c2 = (unsigned) c;
 909 #if !(defined(NCURSES_VERSION) || defined(_XOPEN_CURSES))
 910                 /* at least Solaris SVR4 curses breaks unctrl(128), etc. */
 911                 c2 &= 0x7f;
 912 #endif
 913                 if (isprint(c))
 914                     (void) wprintw(win, "%c", UChar(c));
 915                 else if (c2 != UChar(c))
 916                     (void) wprintw(win, "M-%s", unctrl(c2));
 917                 else
 918                     (void) wprintw(win, "%s", unctrl(c2));
 919                 waddstr(win, " (high-half character)");
 920             } else {
 921                 if (isprint(c))
 922                     (void) wprintw(win, "%c (ASCII printable character)", c);
 923                 else
 924                     (void) wprintw(win, "%s (ASCII control character)",
 925                                    unctrl(UChar(c)));
 926             }
 927             wgetch_wrap(win, first_y);
 928         }
 929     }
 930
 931     wtimeout(win, -1);
 932
 933     if (!level)
 934         init_getch(win, flags);
 935 }
 936
 937 static int
 938 begin_getch_test(void)
 939 {
 940     char buf[BUFSIZ];
 941     int delay;
 942
 943     refresh();
 944
 945 #ifdef NCURSES_MOUSE_VERSION
 946     mousemask(ALL_MOUSE_EVENTS, (mmask_t *) 0);
 947 #endif
 948
 949     (void) printw("Delay in 10ths of a second (<CR> for blocking input)? ");
 950     echo();
 951     getnstr(buf, sizeof(buf) - 1);
 952     noecho();
 953     nonl();
 954
 955     if (isdigit(UChar(buf[0]))) {
 956         delay = atoi(buf) * 100;
 957     } else {
 958         delay = -1;
 959     }
 960     raw();
 961     move(5, 0);
 962     return delay;
 963 }
 964
 965 static void
 966 finish_getch_test(void)
 967 {
 968 #ifdef NCURSES_MOUSE_VERSION
 969     mousemask(0, (mmask_t *) 0);
 970 #endif
 971     erase();
 972     noraw();
 973     nl();
 974     endwin();
 975 }
 976
 977 static void
 978 getch_test(void)
 979 {
 980     int delay = begin_getch_test();
 981
 982     slk_restore();
 983     wgetch_test(0, stdscr, delay);
 984     forget_boxes();
 985     finish_getch_test();
 986     slk_clear();
 987 }
 988
 989 #if USE_WIDEC_SUPPORT
 990 /*
 991  * For wget_wch_test(), we create pairs of windows - one for a box, one for text.
 992  * Resize both and paint the box in the parent.
 993  */
 994 #if defined(KEY_RESIZE) && HAVE_WRESIZE
 995 static void
 996 resize_wide_boxes(unsigned level, WINDOW *win)
 997 {
 998     unsigned n;
 999     int base = 5;
1000     int high = LINES - base;
1001     int wide = COLS;
1002
1003     touchwin(stdscr);
1004     wnoutrefresh(stdscr);
1005
1006     slk_repaint();
1007
1008     for (n = 0; n < level; ++n) {
1009         wresize(winstack[n].frame, high, wide);
1010         wresize(winstack[n].text, high - 2, wide - 2);
1011         high -= 2;
1012         wide -= 2;
1013         werase(winstack[n].text);
1014         box_set(winstack[n].frame, 0, 0);
1015         wnoutrefresh(winstack[n].frame);
1016         wprintw(winstack[n].text,
1017                 "size %dx%d\n",
1018                 getmaxy(winstack[n].text),
1019                 getmaxx(winstack[n].text));
1020         wnoutrefresh(winstack[n].text);
1021         if (winstack[n].text == win)
1022             break;
1023     }
1024     doupdate();
1025 }
1026 #endif /* KEY_RESIZE */
1027
1028 static char *
1029 wcstos(const wchar_t *src)
1030 {
1031     int need;
1032     char *result = 0;
1033     const wchar_t *tmp = src;
1034 #ifndef state_unused
1035     mbstate_t state;
1036 #endif
1037
1038     reset_wchars(state);
1039     if ((need = (int) count_wchars(tmp, 0, &state)) > 0) {
1040         unsigned have = (unsigned) need;
1041         if ((result = typeCalloc(char, have + 1)) != 0) {
1042             tmp = src;
1043             if (trans_wchars(result, tmp, have, &state) != have) {
1044                 free(result);
1045                 result = 0;
1046             }
1047         } else {
1048             failed("wcstos");
1049         }
1050     }
1051     return result;
1052 }
1053
1054 static void
1055 wget_wch_test(unsigned level, WINDOW *win, int delay)
1056 {
1057     wchar_t wchar_buf[BUFSIZ];
1058     wint_t wint_buf[BUFSIZ];
1059     int first_y, first_x;
1060     wint_t c;
1061     int incount = 0;
1062     GetchFlags flags;
1063     bool blocking = (delay < 0);
1064     int code;
1065     char *temp;
1066
1067     init_getch(win, flags);
1068     wtimeout(win, delay);
1069     getyx(win, first_y, first_x);
1070
1071     wgetch_help(win, flags);
1072     wsetscrreg(win, first_y, getmaxy(win) - 1);
1073     scrollok(win, TRUE);
1074
1075     for (;;) {
1076         while ((code = wGet_wchar(win, &c)) == ERR) {
1077             incount++;
1078             if (blocking) {
1079                 (void) wprintw(win, "%05d: input error", incount);
1080                 break;
1081             } else {
1082                 (void) wprintw(win, "%05d: input timed out", incount);
1083             }
1084             wgetch_wrap(win, first_y);
1085         }
1086         if (code == ERR && blocking) {
1087             wprintw(win, "ERR");
1088             wgetch_wrap(win, first_y);
1089         } else if (isQuit((int) c)) {
1090             break;
1091         } else if (c == 'e') {
1092             flags[UChar('e')] = !flags[UChar('e')];
1093             setup_getch(win, flags);
1094             wgetch_help(win, flags);
1095         } else if (c == 'g') {
1096             waddstr(win, "getstr test: ");
1097             echo();
1098             code = wgetn_wstr(win, wint_buf, BUFSIZ - 1);
1099             noecho();
1100             if (code == ERR) {
1101                 wprintw(win, "wgetn_wstr returns an error.");
1102             } else {
1103                 int n;
1104                 for (n = 0; (wchar_buf[n] = (wchar_t) wint_buf[n]) != 0; ++n) {
1105                     ;
1106                 }
1107                 if ((temp = wcstos(wchar_buf)) != 0) {
1108                     wprintw(win, "I saw %d characters:\n\t`%s'.",
1109                             (int) wcslen(wchar_buf), temp);
1110                     free(temp);
1111                 } else {
1112                     wprintw(win, "I saw %d characters (cannot convert).",
1113                             (int) wcslen(wchar_buf));
1114                 }
1115             }
1116             wclrtoeol(win);
1117             wgetch_wrap(win, first_y);
1118         } else if (c == 'k') {
1119             flags[UChar('k')] = !flags[UChar('k')];
1120             setup_getch(win, flags);
1121             wgetch_help(win, flags);
1122         } else if (c == 'm') {
1123             flags[UChar('m')] = !flags[UChar('m')];
1124             setup_getch(win, flags);
1125             wgetch_help(win, flags);
1126         } else if (c == 's') {
1127             ShellOut(TRUE);
1128         } else if (c == 'w') {
1129             int high = getmaxy(win) - 1 - first_y + 1;
1130             int wide = getmaxx(win) - first_x;
1131             int old_y, old_x;
1132             int new_y = first_y + getbegy(win);
1133             int new_x = first_x + getbegx(win);
1134
1135             getyx(win, old_y, old_x);
1136             if (high > 2 && wide > 2) {
1137                 WINDOW *wb = newwin(high, wide, new_y, new_x);
1138                 WINDOW *wi = newwin(high - 2, wide - 2, new_y + 1, new_x + 1);
1139
1140                 box_set(wb, 0, 0);
1141                 wrefresh(wb);
1142                 wmove(wi, 0, 0);
1143                 remember_boxes(level, wi, wb);
1144                 wget_wch_test(level + 1, wi, delay);
1145                 delwin(wi);
1146                 delwin(wb);
1147
1148                 wgetch_help(win, flags);
1149                 wmove(win, old_y, old_x);
1150                 touchwin(win);
1151                 wrefresh(win);
1152             }
1153 #ifdef SIGTSTP
1154         } else if (c == 'z') {
1155             kill(getpid(), SIGTSTP);
1156 #endif
1157         } else {
1158             wprintw(win, "Key pressed: %04o ", (int) c);
1159 #ifdef NCURSES_MOUSE_VERSION
1160             if (c == KEY_MOUSE) {
1161                 show_mouse(win);
1162             } else
1163 #endif /* NCURSES_MOUSE_VERSION */
1164             if (code == KEY_CODE_YES) {
1165 #if defined(KEY_RESIZE) && HAVE_WRESIZE
1166                 if (c == KEY_RESIZE) {
1167                     resize_wide_boxes(level, win);
1168                 }
1169 #endif
1170                 (void) waddstr(win, keyname((wchar_t) c));
1171             } else {
1172                 (void) waddstr(win, key_name((wchar_t) c));
1173                 if (c < 256 && iscntrl(c)) {
1174                     (void) wprintw(win, " (control character)");
1175                 } else {
1176                     (void) wprintw(win, " = %#x (printable character)",
1177                                    (unsigned) c);
1178                 }
1179             }
1180             wgetch_wrap(win, first_y);
1181         }
1182     }
1183
1184     wtimeout(win, -1);
1185
1186     if (!level)
1187         init_getch(win, flags);
1188 }
1189
1190 static void
1191 get_wch_test(void)
1192 {
1193     int delay = begin_getch_test();
1194
1195     slk_restore();
1196     wget_wch_test(0, stdscr, delay);
1197     forget_boxes();
1198     finish_getch_test();
1199     slk_clear();
1200 }
1201 #endif
1202
1203 /****************************************************************************
1204  *
1205  * Character attributes test
1206  *
1207  ****************************************************************************/
1208
1209 #if HAVE_SETUPTERM || HAVE_TGETENT
1210 #define get_ncv() TIGETNUM("ncv","NC")
1211 #define get_xmc() TIGETNUM("xmc","sg")
1212 #else
1213 #define get_ncv() -1
1214 #define get_xmc() -1
1215 #endif
1216
1217 #if !HAVE_TERMATTRS
1218 static chtype
1219 my_termattrs(void)
1220 {
1221     static int first = TRUE;
1222     static chtype result = 0;
1223
1224     if (first) {
1225 #if !HAVE_TIGETSTR
1226         char buffer[4096];
1227         char parsed[4096];
1228         char *area_pointer = parsed;
1229
1230         tgetent(buffer, getenv("TERM"));
1231 #endif
1232
1233         if (TIGETSTR("smso", "so"))
1234             result |= A_STANDOUT;
1235         if (TIGETSTR("smul", "us"))
1236             result |= A_UNDERLINE;
1237         if (TIGETSTR("rev", "mr"))
1238             result |= A_REVERSE;
1239         if (TIGETSTR("blink", "mb"))
1240             result |= A_BLINK;
1241         if (TIGETSTR("dim", "mh"))
1242             result |= A_DIM;
1243         if (TIGETSTR("bold", "md"))
1244             result |= A_BOLD;
1245         if (TIGETSTR("smacs", "ac"))
1246             result |= A_ALTCHARSET;
1247
1248         first = FALSE;
1249     }
1250     return result;
1251 }
1252 #define termattrs() my_termattrs()
1253 #endif
1254
1255 #define MAX_ATTRSTRING 31
1256 #define LEN_ATTRSTRING 26
1257
1258 static char attr_test_string[MAX_ATTRSTRING + 1];
1259
1260 static void
1261 attr_legend(WINDOW *helpwin)
1262 {
1263     int row = 1;
1264     int col = 1;
1265
1266     MvWPrintw(helpwin, row++, col,
1267               "ESC to exit.");
1268     MvWPrintw(helpwin, row++, col,
1269               "^L repaints.");
1270     ++row;
1271     MvWPrintw(helpwin, row++, col,
1272               "Modify the test strings:");
1273     MvWPrintw(helpwin, row++, col,
1274               "  A digit sets gaps on each side of displayed attributes");
1275     MvWPrintw(helpwin, row++, col,
1276               "  </> shifts the text left/right. ");
1277     ++row;
1278     MvWPrintw(helpwin, row++, col,
1279               "Toggles:");
1280     if (use_colors) {
1281         MvWPrintw(helpwin, row++, col,
1282                   "  f/F/b/F toggle foreground/background background color");
1283         MvWPrintw(helpwin, row++, col,
1284                   "  t/T     toggle text/background color attribute");
1285     }
1286     MvWPrintw(helpwin, row++, col,
1287               "  a/A     toggle ACS (alternate character set) mapping");
1288     MvWPrintw(helpwin, row, col,
1289               "  v/V     toggle video attribute to combine with each line");
1290 }
1291
1292 static void
1293 show_color_attr(int fg, int bg, int tx)
1294 {
1295     if (use_colors) {
1296         printw("  Colors (fg %d, bg %d", fg, bg);
1297         if (tx >= 0)
1298             printw(", text %d", tx);
1299         printw("),");
1300     }
1301 }
1302
1303 static bool
1304 cycle_color_attr(int ch, NCURSES_COLOR_T *fg, NCURSES_COLOR_T *bg, NCURSES_COLOR_T *tx)
1305 {
1306     bool error = FALSE;
1307
1308     if (use_colors) {
1309         switch (ch) {
1310         case 'f':
1311             *fg = (NCURSES_COLOR_T) (*fg + 1);
1312             break;
1313         case 'F':
1314             *fg = (NCURSES_COLOR_T) (*fg - 1);
1315             break;
1316         case 'b':
1317             *bg = (NCURSES_COLOR_T) (*bg + 1);
1318             break;
1319         case 'B':
1320             *bg = (NCURSES_COLOR_T) (*bg - 1);
1321             break;
1322         case 't':
1323             *tx = (NCURSES_COLOR_T) (*tx + 1);
1324             break;
1325         case 'T':
1326             *tx = (NCURSES_COLOR_T) (*tx - 1);
1327             break;
1328         default:
1329             beep();
1330             error = TRUE;
1331             break;
1332         }
1333         if (*fg >= COLORS)
1334             *fg = (NCURSES_COLOR_T) min_colors;
1335         if (*fg < min_colors)
1336             *fg = (NCURSES_COLOR_T) (COLORS - 1);
1337         if (*bg >= COLORS)
1338             *bg = (NCURSES_COLOR_T) min_colors;
1339         if (*bg < min_colors)
1340             *bg = (NCURSES_COLOR_T) (COLORS - 1);
1341         if (*tx >= COLORS)
1342             *tx = -1;
1343         if (*tx < -1)
1344             *tx = (NCURSES_COLOR_T) (COLORS - 1);
1345     } else {
1346         beep();
1347         error = TRUE;
1348     }
1349     return error;
1350 }
1351
1352 static void
1353 adjust_attr_string(int adjust)
1354 {
1355     int first = ((int) UChar(attr_test_string[0])) + adjust;
1356     int last = first + LEN_ATTRSTRING;
1357
1358     if (first >= ' ' && last <= '~') {  /* 32..126 */
1359         int j, k;
1360         for (j = 0, k = first; j < MAX_ATTRSTRING && k <= last; ++j, ++k) {
1361             attr_test_string[j] = (char) k;
1362             if (((k + 1 - first) % 5) == 0) {
1363                 if (++j >= MAX_ATTRSTRING)
1364                     break;
1365                 attr_test_string[j] = ' ';
1366             }
1367         }
1368         while (j < MAX_ATTRSTRING)
1369             attr_test_string[j++] = ' ';
1370         attr_test_string[j] = '\0';
1371     } else {
1372         beep();
1373     }
1374 }
1375
1376 static void
1377 init_attr_string(void)
1378 {
1379     attr_test_string[0] = 'a';
1380     adjust_attr_string(0);
1381 }
1382
1383 static int
1384 show_attr(int row, int skip, bool arrow, chtype attr, const char *name)
1385 {
1386     int ncv = get_ncv();
1387     chtype test = attr & (chtype) (~A_ALTCHARSET);
1388
1389     if (arrow)
1390         MvPrintw(row, 5, "-->");
1391     MvPrintw(row, 8, "%s mode:", name);
1392     MvPrintw(row, 24, "|");
1393     if (skip)
1394         printw("%*s", skip, " ");
1395     /*
1396      * Just for testing, write text using the alternate character set one
1397      * character at a time (to pass its rendition directly), and use the
1398      * string operation for the other attributes.
1399      */
1400     if (attr & A_ALTCHARSET) {
1401         const char *s;
1402         chtype ch;
1403
1404         for (s = attr_test_string; *s != '\0'; ++s) {
1405             ch = UChar(*s);
1406             addch(ch | attr);
1407         }
1408     } else {
1409         (void) attrset(attr);
1410         addstr(attr_test_string);
1411         attroff(attr);
1412     }
1413     if (skip)
1414         printw("%*s", skip, " ");
1415     printw("|");
1416     if (test != A_NORMAL) {
1417         if (!(termattrs() & test)) {
1418             printw(" (N/A)");
1419         } else {
1420             if (ncv > 0 && stdscr && (getbkgd(stdscr) & A_COLOR)) {
1421                 static const chtype table[] =
1422                 {
1423                     A_STANDOUT,
1424                     A_UNDERLINE,
1425                     A_REVERSE,
1426                     A_BLINK,
1427                     A_DIM,
1428                     A_BOLD,
1429 #ifdef A_INVIS
1430                     A_INVIS,
1431 #endif
1432 #ifdef A_ITALIC
1433                     A_ITALIC,
1434 #endif
1435                     A_PROTECT,
1436                     A_ALTCHARSET
1437                 };
1438                 unsigned n;
1439                 bool found = FALSE;
1440                 for (n = 0; n < SIZEOF(table); n++) {
1441                     if ((table[n] & attr) != 0
1442                         && ((1 << n) & ncv) != 0) {
1443                         found = TRUE;
1444                         break;
1445                     }
1446                 }
1447                 if (found)
1448                     printw(" (NCV)");
1449             }
1450             if ((termattrs() & test) != test)
1451                 printw(" (Part)");
1452         }
1453     }
1454     return row + 2;
1455 }
1456
1457 typedef struct {
1458     attr_t attr;
1459     NCURSES_CONST char *name;
1460 } ATTR_TBL;
1461 /* *INDENT-OFF* */
1462 static const ATTR_TBL attrs_to_test[] = {
1463     { A_STANDOUT,       "STANDOUT" },
1464     { A_REVERSE,        "REVERSE" },
1465     { A_BOLD,           "BOLD" },
1466     { A_UNDERLINE,      "UNDERLINE" },
1467     { A_DIM,            "DIM" },
1468     { A_BLINK,          "BLINK" },
1469     { A_PROTECT,        "PROTECT" },
1470 #ifdef A_INVIS
1471     { A_INVIS,          "INVISIBLE" },
1472 #endif
1473 #ifdef A_ITALIC
1474     { A_ITALIC,         "ITALIC" },
1475 #endif
1476     { A_NORMAL,         "NORMAL" },
1477 };
1478 /* *INDENT-ON* */
1479
1480 static unsigned
1481 init_attr_list(ATTR_TBL * target, attr_t attrs)
1482 {
1483     unsigned result = 0;
1484     size_t n;
1485
1486     for (n = 0; n < SIZEOF(attrs_to_test); ++n) {
1487         attr_t test = attrs_to_test[n].attr;
1488         if (test == A_NORMAL || (test & attrs) != 0) {
1489             target[result++] = attrs_to_test[n];
1490         }
1491     }
1492     return result;
1493 }
1494
1495 static bool
1496 attr_getc(int *skip,
1497           NCURSES_COLOR_T *fg,
1498           NCURSES_COLOR_T *bg,
1499           NCURSES_COLOR_T *tx,
1500           int *ac,
1501           unsigned *kc,
1502           unsigned limit)
1503 {
1504     bool result = TRUE;
1505     bool error = FALSE;
1506     WINDOW *helpwin;
1507
1508     do {
1509         int ch = Getchar();
1510
1511         error = FALSE;
1512         if (ch < 256 && isdigit(ch)) {
1513             *skip = (ch - '0');
1514         } else {
1515             switch (ch) {
1516             case CTRL('L'):
1517                 Repaint();
1518                 break;
1519             case '?':
1520                 if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
1521                     box(helpwin, 0, 0);
1522                     attr_legend(helpwin);
1523                     wGetchar(helpwin);
1524                     delwin(helpwin);
1525                 }
1526                 break;
1527             case 'a':
1528                 *ac = 0;
1529                 break;
1530             case 'A':
1531                 *ac = A_ALTCHARSET;
1532                 break;
1533             case 'v':
1534                 if (*kc == 0)
1535                     *kc = limit - 1;
1536                 else
1537                     *kc -= 1;
1538                 break;
1539             case 'V':
1540                 *kc += 1;
1541                 if (*kc >= limit)
1542                     *kc = 0;
1543                 break;
1544             case '<':
1545                 adjust_attr_string(-1);
1546                 break;
1547             case '>':
1548                 adjust_attr_string(1);
1549                 break;
1550             case case_QUIT:
1551                 result = FALSE;
1552                 break;
1553             default:
1554                 error = cycle_color_attr(ch, fg, bg, tx);
1555                 break;
1556             }
1557         }
1558     } while (error);
1559     return result;
1560 }
1561
1562 static void
1563 attr_test(void)
1564 /* test text attributes */
1565 {
1566     int n;
1567     int skip = get_xmc();
1568     NCURSES_COLOR_T fg = COLOR_BLACK;   /* color pair 0 is special */
1569     NCURSES_COLOR_T bg = COLOR_BLACK;
1570     NCURSES_COLOR_T tx = -1;
1571     int ac = 0;
1572     unsigned j, k;
1573     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
1574     unsigned my_size = init_attr_list(my_list, termattrs());
1575
1576     if (my_size > 1) {
1577         if (skip < 0)
1578             skip = 0;
1579
1580         n = skip;               /* make it easy */
1581         k = my_size - 1;
1582         init_attr_string();
1583
1584         do {
1585             int row = 2;
1586             chtype normal = A_NORMAL | BLANK;
1587             chtype extras = (chtype) ac;
1588
1589             if (use_colors) {
1590                 NCURSES_PAIRS_T pair = 0;
1591                 if ((fg != COLOR_BLACK) || (bg != COLOR_BLACK)) {
1592                     pair = 1;
1593                     if (init_pair(pair, fg, bg) == ERR) {
1594                         beep();
1595                     } else {
1596                         normal |= (chtype) COLOR_PAIR(pair);
1597                     }
1598                 }
1599                 if (tx >= 0) {
1600                     pair = 2;
1601                     if (init_pair(pair, tx, bg) == ERR) {
1602                         beep();
1603                     } else {
1604                         extras |= (chtype) COLOR_PAIR(pair);
1605                     }
1606                 }
1607             }
1608             bkgd(normal);
1609             bkgdset(normal);
1610             erase();
1611
1612             box(stdscr, 0, 0);
1613             MvAddStr(0, 20, "Character attribute test display");
1614
1615             for (j = 0; j < my_size; ++j) {
1616                 bool arrow = (j == k);
1617                 row = show_attr(row, n, arrow,
1618                                 extras |
1619                                 my_list[j].attr |
1620                                 my_list[k].attr,
1621                                 my_list[j].name);
1622             }
1623
1624             MvPrintw(row, 8,
1625                      "This terminal does %shave the magic-cookie glitch",
1626                      get_xmc() > -1 ? "" : "not ");
1627             MvPrintw(row + 1, 8, "Enter '?' for help.");
1628             show_color_attr(fg, bg, tx);
1629             printw("  ACS (%d)", ac != 0);
1630
1631             refresh();
1632         } while (attr_getc(&n, &fg, &bg, &tx, &ac, &k, my_size));
1633
1634         bkgdset(A_NORMAL | BLANK);
1635         erase();
1636         endwin();
1637     } else {
1638         Cannot("does not support video attributes.");
1639     }
1640 }
1641
1642 #if USE_WIDEC_SUPPORT
1643 static wchar_t wide_attr_test_string[MAX_ATTRSTRING + 1];
1644
1645 static void
1646 wide_adjust_attr_string(int adjust)
1647 {
1648     int first = ((int) UChar(wide_attr_test_string[0])) + adjust;
1649     int last = first + LEN_ATTRSTRING;
1650
1651     if (first >= ' ' && last <= '~') {  /* 32..126 */
1652         int j, k;
1653         for (j = 0, k = first; j < MAX_ATTRSTRING && k <= last; ++j, ++k) {
1654             wide_attr_test_string[j] = k;
1655             if (((k + 1 - first) % 5) == 0) {
1656                 if (++j >= MAX_ATTRSTRING)
1657                     break;
1658                 wide_attr_test_string[j] = ' ';
1659             }
1660         }
1661         while (j < MAX_ATTRSTRING)
1662             wide_attr_test_string[j++] = ' ';
1663         wide_attr_test_string[j] = '\0';
1664     } else {
1665         beep();
1666     }
1667 }
1668
1669 static void
1670 wide_init_attr_string(void)
1671 {
1672     wide_attr_test_string[0] = 'a';
1673     wide_adjust_attr_string(0);
1674 }
1675
1676 static void
1677 set_wide_background(NCURSES_PAIRS_T pair)
1678 {
1679     cchar_t normal;
1680     wchar_t blank[2];
1681
1682     blank[0] = ' ';
1683     blank[1] = 0;
1684     setcchar(&normal, blank, A_NORMAL, pair, 0);
1685     bkgrnd(&normal);
1686     bkgrndset(&normal);
1687 }
1688
1689 static attr_t
1690 get_wide_background(void)
1691 {
1692     attr_t result = A_NORMAL;
1693     attr_t attr;
1694     cchar_t ch;
1695     NCURSES_PAIRS_T pair;
1696     wchar_t wch[10];
1697
1698     memset(&ch, 0, sizeof(ch));
1699     if (getbkgrnd(&ch) != ERR) {
1700         if (getcchar(&ch, wch, &attr, &pair, 0) != ERR) {
1701             result = attr;
1702         }
1703     }
1704     return result;
1705 }
1706
1707 static int
1708 wide_show_attr(int row,
1709                int skip,
1710                bool arrow,
1711                chtype attr,
1712                NCURSES_PAIRS_T pair,
1713                const char *name)
1714 {
1715     int ncv = get_ncv();
1716     chtype test = attr & ~WA_ALTCHARSET;
1717
1718     if (arrow)
1719         MvPrintw(row, 5, "-->");
1720     MvPrintw(row, 8, "%s mode:", name);
1721     MvPrintw(row, 24, "|");
1722     if (skip)
1723         printw("%*s", skip, " ");
1724
1725     /*
1726      * Just for testing, write text using the alternate character set one
1727      * character at a time (to pass its rendition directly), and use the
1728      * string operation for the other attributes.
1729      */
1730     if (attr & WA_ALTCHARSET) {
1731         const wchar_t *s;
1732         cchar_t ch;
1733
1734         for (s = wide_attr_test_string; *s != L'\0'; ++s) {
1735             wchar_t fill[2];
1736             fill[0] = *s;
1737             fill[1] = L'\0';
1738             setcchar(&ch, fill, attr, pair, 0);
1739             add_wch(&ch);
1740         }
1741     } else {
1742         attr_t old_attr = 0;
1743         NCURSES_PAIRS_T old_pair = 0;
1744
1745         (void) (attr_get) (&old_attr, &old_pair, 0);
1746         (void) attr_set(attr, pair, 0);
1747         addwstr(wide_attr_test_string);
1748         (void) attr_set(old_attr, old_pair, 0);
1749     }
1750     if (skip)
1751         printw("%*s", skip, " ");
1752     printw("|");
1753     if (test != A_NORMAL) {
1754         if (!(term_attrs() & test)) {
1755             printw(" (N/A)");
1756         } else {
1757             if (ncv > 0 && (get_wide_background() & A_COLOR)) {
1758                 static const attr_t table[] =
1759                 {
1760                     WA_STANDOUT,
1761                     WA_UNDERLINE,
1762                     WA_REVERSE,
1763                     WA_BLINK,
1764                     WA_DIM,
1765                     WA_BOLD,
1766                     WA_INVIS,
1767                     WA_PROTECT,
1768                     WA_ALTCHARSET
1769                 };
1770                 unsigned n;
1771                 bool found = FALSE;
1772                 for (n = 0; n < SIZEOF(table); n++) {
1773                     if ((table[n] & attr) != 0
1774                         && ((1 << n) & ncv) != 0) {
1775                         found = TRUE;
1776                         break;
1777                     }
1778                 }
1779                 if (found)
1780                     printw(" (NCV)");
1781             }
1782             if ((term_attrs() & test) != test)
1783                 printw(" (Part)");
1784         }
1785     }
1786     return row + 2;
1787 }
1788
1789 static bool
1790 wide_attr_getc(int *skip,
1791                NCURSES_COLOR_T *fg, NCURSES_COLOR_T *bg,
1792                NCURSES_COLOR_T *tx, int *ac,
1793                unsigned *kc, unsigned limit)
1794 {
1795     bool result = TRUE;
1796     bool error = FALSE;
1797     WINDOW *helpwin;
1798
1799     do {
1800         int ch = Getchar();
1801
1802         error = FALSE;
1803         if (ch < 256 && isdigit(ch)) {
1804             *skip = (ch - '0');
1805         } else {
1806             switch (ch) {
1807             case CTRL('L'):
1808                 Repaint();
1809                 break;
1810             case '?':
1811                 if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
1812                     box_set(helpwin, 0, 0);
1813                     attr_legend(helpwin);
1814                     wGetchar(helpwin);
1815                     delwin(helpwin);
1816                 }
1817                 break;
1818             case 'a':
1819                 *ac = 0;
1820                 break;
1821             case 'A':
1822                 *ac = A_ALTCHARSET;
1823                 break;
1824             case 'v':
1825                 if (*kc == 0)
1826                     *kc = limit - 1;
1827                 else
1828                     *kc -= 1;
1829                 break;
1830             case 'V':
1831                 *kc += 1;
1832                 if (*kc >= limit)
1833                     *kc = 0;
1834                 break;
1835             case '<':
1836                 wide_adjust_attr_string(-1);
1837                 break;
1838             case '>':
1839                 wide_adjust_attr_string(1);
1840                 break;
1841             case case_QUIT:
1842                 result = FALSE;
1843                 break;
1844             default:
1845                 error = cycle_color_attr(ch, fg, bg, tx);
1846                 break;
1847             }
1848         }
1849     } while (error);
1850     return result;
1851 }
1852
1853 static void
1854 wide_attr_test(void)
1855 /* test text attributes using wide-character calls */
1856 {
1857     int n;
1858     int skip = get_xmc();
1859     NCURSES_COLOR_T fg = COLOR_BLACK;   /* color pair 0 is special */
1860     NCURSES_COLOR_T bg = COLOR_BLACK;
1861     NCURSES_COLOR_T tx = -1;
1862     int ac = 0;
1863     unsigned j, k;
1864     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
1865     unsigned my_size = init_attr_list(my_list, term_attrs());
1866
1867     if (my_size > 1) {
1868         if (skip < 0)
1869             skip = 0;
1870
1871         n = skip;               /* make it easy */
1872         k = my_size - 1;
1873         wide_init_attr_string();
1874
1875         do {
1876             int row = 2;
1877             NCURSES_PAIRS_T pair = 0;
1878             NCURSES_PAIRS_T extras = 0;
1879
1880             if (use_colors) {
1881                 pair = (NCURSES_PAIRS_T) (fg != COLOR_BLACK || bg != COLOR_BLACK);
1882                 if (pair != 0) {
1883                     pair = 1;
1884                     if (init_pair(pair, fg, bg) == ERR) {
1885                         beep();
1886                     }
1887                 }
1888                 extras = pair;
1889                 if (tx >= 0) {
1890                     extras = 2;
1891                     if (init_pair(extras, tx, bg) == ERR) {
1892                         beep();
1893                     }
1894                 }
1895             }
1896             set_wide_background(pair);
1897             erase();
1898
1899             box_set(stdscr, 0, 0);
1900             MvAddStr(0, 20, "Character attribute test display");
1901
1902             for (j = 0; j < my_size; ++j) {
1903                 row = wide_show_attr(row, n, j == k,
1904                                      ((attr_t) ac |
1905                                       my_list[j].attr |
1906                                       my_list[k].attr),
1907                                      extras,
1908                                      my_list[j].name);
1909             }
1910
1911             MvPrintw(row, 8,
1912                      "This terminal does %shave the magic-cookie glitch",
1913                      get_xmc() > -1 ? "" : "not ");
1914             MvPrintw(row + 1, 8, "Enter '?' for help.");
1915             show_color_attr(fg, bg, tx);
1916             printw("  ACS (%d)", ac != 0);
1917
1918             refresh();
1919         } while (wide_attr_getc(&n, &fg, &bg, &tx, &ac, &k, my_size));
1920
1921         set_wide_background(0);
1922         erase();
1923         endwin();
1924     } else {
1925         Cannot("does not support extended video attributes.");
1926     }
1927 }
1928 #endif
1929
1930 /****************************************************************************
1931  *
1932  * Color support tests
1933  *
1934  ****************************************************************************/
1935
1936 static NCURSES_CONST char *the_color_names[] =
1937 {
1938     "black",
1939     "red",
1940     "green",
1941     "yellow",
1942     "blue",
1943     "magenta",
1944     "cyan",
1945     "white",
1946     "BLACK",
1947     "RED",
1948     "GREEN",
1949     "YELLOW",
1950     "BLUE",
1951     "MAGENTA",
1952     "CYAN",
1953     "WHITE"
1954 };
1955
1956 static void
1957 show_color_name(int y, int x, int color, bool wide)
1958 {
1959     if (move(y, x) != ERR) {
1960         char temp[80];
1961         int width = 8;
1962
1963         if (wide) {
1964             sprintf(temp, "%02d", color);
1965             width = 4;
1966         } else if (color >= 8) {
1967             sprintf(temp, "[%02d]", color);
1968         } else if (color < 0) {
1969             strcpy(temp, "default");
1970         } else {
1971             sprintf(temp, "%.*s", 16, the_color_names[color]);
1972         }
1973         printw("%-*.*s", width, width, temp);
1974     }
1975 }
1976
1977 static void
1978 color_legend(WINDOW *helpwin, bool wide)
1979 {
1980     int row = 1;
1981     int col = 1;
1982
1983     MvWPrintw(helpwin, row++, col,
1984               "ESC to exit.");
1985     ++row;
1986     MvWPrintw(helpwin, row++, col,
1987               "Use up/down arrow to scroll through the display if it is");
1988     MvWPrintw(helpwin, row++, col,
1989               "longer than one screen. Control/N and Control/P can be used");
1990     MvWPrintw(helpwin, row++, col,
1991               "in place of up/down arrow.  Use pageup/pagedown to scroll a");
1992     MvWPrintw(helpwin, row++, col,
1993               "full screen; control/B and control/F can be used here.");
1994     ++row;
1995     MvWPrintw(helpwin, row++, col,
1996               "Toggles:");
1997     MvWPrintw(helpwin, row++, col,
1998               "  a/A     toggle altcharset off/on");
1999     MvWPrintw(helpwin, row++, col,
2000               "  b/B     toggle bold off/on");
2001     if (has_colors()) {
2002         MvWPrintw(helpwin, row++, col,
2003                   "  c/C     cycle used-colors through 8,16,...,COLORS");
2004     }
2005     MvWPrintw(helpwin, row++, col,
2006               "  n/N     toggle text/number on/off");
2007     MvWPrintw(helpwin, row++, col,
2008               "  r/R     toggle reverse on/off");
2009     MvWPrintw(helpwin, row++, col,
2010               "  w/W     toggle width between 8/16 colors");
2011 #if USE_WIDEC_SUPPORT
2012     if (wide) {
2013         MvWPrintw(helpwin, row++, col,
2014                   "Wide characters:");
2015         MvWPrintw(helpwin, row, col,
2016                   "  x/X     toggle text between ASCII and wide-character");
2017     }
2018 #else
2019     (void) wide;
2020 #endif
2021 }
2022
2023 #define set_color_test(name, value) if (name != value) { name = value; base_row = 0; }
2024
2025 static int
2026 color_cycle(int current, int step)
2027 {
2028     int result = current;
2029     if (step < 0) {
2030         if (current <= 8) {
2031             result = COLORS;
2032         } else {
2033             result = 8;
2034             if ((result * 2) > COLORS) {
2035                 result = COLORS;
2036             } else {
2037                 while ((result * 2) < current) {
2038                     result *= 2;
2039                 }
2040             }
2041         }
2042     } else {
2043         if (current >= COLORS) {
2044             result = 8;
2045         } else {
2046             result *= 2;
2047         }
2048         if (result > COLORS)
2049             result = COLORS;
2050     }
2051     return result;
2052 }
2053
2054 /* generate a color test pattern */
2055 static void
2056 color_test(void)
2057 {
2058     NCURSES_PAIRS_T i;
2059     int top = 0, width;
2060     int base_row = 0;
2061     int grid_top = top + 3;
2062     int page_size = (LINES - grid_top);
2063     int pairs_max;
2064     int colors_max = COLORS;
2065     int row_limit;
2066     int per_row;
2067     char numbered[80];
2068     const char *hello;
2069     bool done = FALSE;
2070     bool opt_acsc = FALSE;
2071     bool opt_bold = FALSE;
2072     bool opt_revs = FALSE;
2073     bool opt_nums = FALSE;
2074     bool opt_wide = FALSE;
2075     WINDOW *helpwin;
2076
2077     while (!done) {
2078         int shown = 0;
2079
2080         pairs_max = PAIR_NUMBER(A_COLOR) + 1;
2081         if (colors_max * colors_max <= COLOR_PAIRS) {
2082             int limit = (colors_max - min_colors) * (colors_max - min_colors);
2083             if (pairs_max > limit)
2084                 pairs_max = limit;
2085         } else {
2086             if (pairs_max > COLOR_PAIRS)
2087                 pairs_max = COLOR_PAIRS;
2088         }
2089
2090         /* this assumes an 80-column line */
2091         if (opt_wide) {
2092             width = 4;
2093             hello = "Test";
2094             per_row = (colors_max > 8) ? 16 : 8;
2095         } else {
2096             width = 8;
2097             hello = "Hello";
2098             per_row = 8;
2099         }
2100         per_row -= min_colors;
2101
2102         row_limit = (pairs_max + per_row - 1) / per_row;
2103
2104         move(0, 0);
2105         (void) printw("There are %d color pairs and %d colors",
2106                       pairs_max, COLORS);
2107         if (colors_max != COLORS)
2108             (void) printw(" (using %d colors)", colors_max);
2109         if (min_colors)
2110             (void) addstr(" besides 'default'");
2111
2112         clrtobot();
2113         MvPrintw(top + 1, 0,
2114                  "%dx%d matrix of foreground/background colors, bold *%s*\n",
2115                  row_limit,
2116                  per_row,
2117                  opt_bold ? "on" : "off");
2118
2119         /* show color names/numbers across the top */
2120         for (i = 0; i < per_row; i++)
2121             show_color_name(top + 2, (i + 1) * width, i + min_colors, opt_wide);
2122
2123         /* show a grid of colors, with color names/ numbers on the left */
2124         for (i = (NCURSES_PAIRS_T) (base_row * per_row); i < pairs_max; i++) {
2125             int row = grid_top + (i / per_row) - base_row;
2126             int col = (i % per_row + 1) * width;
2127             NCURSES_PAIRS_T pair = i;
2128
2129 #define InxToFG(i) (NCURSES_COLOR_T) ((i % (colors_max - min_colors)) + min_colors)
2130 #define InxToBG(i) (NCURSES_COLOR_T) ((i / (colors_max - min_colors)) + min_colors)
2131             if (row >= 0 && move(row, col) != ERR) {
2132                 NCURSES_COLOR_T fg = InxToFG(i);
2133                 NCURSES_COLOR_T bg = InxToBG(i);
2134
2135                 init_pair(pair, fg, bg);
2136                 attron((attr_t) COLOR_PAIR(pair));
2137                 if (opt_acsc)
2138                     attron((attr_t) A_ALTCHARSET);
2139                 if (opt_bold)
2140                     attron((attr_t) A_BOLD);
2141                 if (opt_revs)
2142                     attron((attr_t) A_REVERSE);
2143
2144                 if (opt_nums) {
2145                     sprintf(numbered, "{%02X}", (int) i);
2146                     hello = numbered;
2147                 }
2148                 printw("%-*.*s", width, width, hello);
2149                 (void) attrset(A_NORMAL);
2150
2151                 if ((i % per_row) == 0 && InxToFG(i) == min_colors) {
2152                     show_color_name(row, 0, InxToBG(i), opt_wide);
2153                 }
2154                 ++shown;
2155             } else if (shown) {
2156                 break;
2157             }
2158         }
2159
2160         switch (wGetchar(stdscr)) {
2161         case 'a':
2162             opt_acsc = FALSE;
2163             break;
2164         case 'A':
2165             opt_acsc = TRUE;
2166             break;
2167         case 'b':
2168             opt_bold = FALSE;
2169             break;
2170         case 'B':
2171             opt_bold = TRUE;
2172             break;
2173         case 'c':
2174             colors_max = color_cycle(colors_max, -1);
2175             break;
2176         case 'C':
2177             colors_max = color_cycle(colors_max, 1);
2178             break;
2179         case 'n':
2180             opt_nums = FALSE;
2181             break;
2182         case 'N':
2183             opt_nums = TRUE;
2184             break;
2185         case 'r':
2186             opt_revs = FALSE;
2187             break;
2188         case 'R':
2189             opt_revs = TRUE;
2190             break;
2191         case case_QUIT:
2192             done = TRUE;
2193             continue;
2194         case 'w':
2195             set_color_test(opt_wide, FALSE);
2196             break;
2197         case 'W':
2198             set_color_test(opt_wide, TRUE);
2199             break;
2200         case CTRL('p'):
2201         case KEY_UP:
2202             if (base_row <= 0) {
2203                 beep();
2204             } else {
2205                 base_row -= 1;
2206             }
2207             break;
2208         case CTRL('n'):
2209         case KEY_DOWN:
2210             if (base_row + page_size >= row_limit) {
2211                 beep();
2212             } else {
2213                 base_row += 1;
2214             }
2215             break;
2216         case CTRL('b'):
2217         case KEY_PREVIOUS:
2218         case KEY_PPAGE:
2219             if (base_row <= 0) {
2220                 beep();
2221             } else {
2222                 base_row -= (page_size - 1);
2223                 if (base_row < 0)
2224                     base_row = 0;
2225             }
2226             break;
2227         case CTRL('f'):
2228         case KEY_NEXT:
2229         case KEY_NPAGE:
2230             if (base_row + page_size >= row_limit) {
2231                 beep();
2232             } else {
2233                 base_row += page_size - 1;
2234                 if (base_row + page_size >= row_limit) {
2235                     base_row = row_limit - page_size - 1;
2236                 }
2237             }
2238             break;
2239         case '?':
2240             if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
2241                 box(helpwin, 0, 0);
2242                 color_legend(helpwin, FALSE);
2243                 wGetchar(helpwin);
2244                 delwin(helpwin);
2245             }
2246             break;
2247         default:
2248             beep();
2249             continue;
2250         }
2251     }
2252
2253     erase();
2254     endwin();
2255 }
2256
2257 #if USE_WIDEC_SUPPORT
2258 /* generate a color test pattern */
2259 static void
2260 wide_color_test(void)
2261 {
2262     int i;
2263     int top = 0, width;
2264     int base_row = 0;
2265     int grid_top = top + 3;
2266     int page_size = (LINES - grid_top);
2267     int pairs_max = (unsigned short) (-1);
2268     int colors_max = COLORS;
2269     int row_limit;
2270     int per_row;
2271     char numbered[80];
2272     const char *hello;
2273     bool done = FALSE;
2274     bool opt_acsc = FALSE;
2275     bool opt_bold = FALSE;
2276     bool opt_revs = FALSE;
2277     bool opt_wide = FALSE;
2278     bool opt_nums = FALSE;
2279     bool opt_xchr = FALSE;
2280     wchar_t buffer[80];
2281     WINDOW *helpwin;
2282
2283     while (!done) {
2284         int shown = 0;
2285
2286         pairs_max = (unsigned short) (-1);
2287         if (colors_max * colors_max <= COLOR_PAIRS) {
2288             int limit = (colors_max - min_colors) * (colors_max - min_colors);
2289             if (pairs_max > limit)
2290                 pairs_max = limit;
2291         } else {
2292             if (pairs_max > COLOR_PAIRS)
2293                 pairs_max = COLOR_PAIRS;
2294         }
2295
2296         /* this assumes an 80-column line */
2297         if (opt_wide) {
2298             width = 4;
2299             hello = "Test";
2300             per_row = (colors_max > 8) ? 16 : 8;
2301         } else {
2302             width = 8;
2303             hello = "Hello";
2304             per_row = 8;
2305         }
2306         per_row -= min_colors;
2307
2308         if (opt_xchr) {
2309             make_fullwidth_text(buffer, hello);
2310             width *= 2;
2311             per_row /= 2;
2312         } else {
2313             make_narrow_text(buffer, hello);
2314         }
2315
2316         row_limit = (pairs_max + per_row - 1) / per_row;
2317
2318         move(0, 0);
2319         (void) printw("There are %d color pairs and %d colors",
2320                       pairs_max, COLORS);
2321         if (colors_max != COLORS)
2322             (void) printw(" (using %d colors)", colors_max);
2323         if (min_colors)
2324             (void) addstr(" besides 'default'");
2325
2326         clrtobot();
2327         MvPrintw(top + 1, 0,
2328                  "%dx%d matrix of foreground/background colors, bold *%s*\n",
2329                  row_limit,
2330                  per_row,
2331                  opt_bold ? "on" : "off");
2332
2333         /* show color names/numbers across the top */
2334         for (i = 0; i < per_row; i++)
2335             show_color_name(top + 2, (i + 1) * width, i + min_colors, opt_wide);
2336
2337         /* show a grid of colors, with color names/ numbers on the left */
2338         for (i = (base_row * per_row); i < pairs_max; i++) {
2339             int row = grid_top + (i / per_row) - base_row;
2340             int col = (i % per_row + 1) * width;
2341             NCURSES_PAIRS_T pair = (NCURSES_PAIRS_T) i;
2342
2343             if (row >= 0 && move(row, col) != ERR) {
2344                 init_pair(pair, InxToFG(i), InxToBG(i));
2345                 (void) color_set(pair, NULL);
2346                 if (opt_acsc)
2347                     attr_on((attr_t) A_ALTCHARSET, NULL);
2348                 if (opt_bold)
2349                     attr_on((attr_t) A_BOLD, NULL);
2350                 if (opt_revs)
2351                     attr_on((attr_t) A_REVERSE, NULL);
2352
2353                 if (opt_nums) {
2354                     sprintf(numbered, "{%02X}", i);
2355                     if (opt_xchr) {
2356                         make_fullwidth_text(buffer, numbered);
2357                     } else {
2358                         make_narrow_text(buffer, numbered);
2359                     }
2360                 }
2361                 addnwstr(buffer, width);
2362                 (void) attr_set(A_NORMAL, 0, NULL);
2363
2364                 if ((i % per_row) == 0 && InxToFG(i) == min_colors) {
2365                     show_color_name(row, 0, InxToBG(i), opt_wide);
2366                 }
2367                 ++shown;
2368             } else if (shown) {
2369                 break;
2370             }
2371         }
2372
2373         switch (wGetchar(stdscr)) {
2374         case 'a':
2375             opt_acsc = FALSE;
2376             break;
2377         case 'A':
2378             opt_acsc = TRUE;
2379             break;
2380         case 'b':
2381             opt_bold = FALSE;
2382             break;
2383         case 'B':
2384             opt_bold = TRUE;
2385             break;
2386         case 'c':
2387             colors_max = color_cycle(colors_max, -1);
2388             break;
2389         case 'C':
2390             colors_max = color_cycle(colors_max, 1);
2391             break;
2392         case 'n':
2393             opt_nums = FALSE;
2394             break;
2395         case 'N':
2396             opt_nums = TRUE;
2397             break;
2398         case 'r':
2399             opt_revs = FALSE;
2400             break;
2401         case 'R':
2402             opt_revs = TRUE;
2403             break;
2404         case case_QUIT:
2405             done = TRUE;
2406             continue;
2407         case 'w':
2408             set_color_test(opt_wide, FALSE);
2409             break;
2410         case 'W':
2411             set_color_test(opt_wide, TRUE);
2412             break;
2413         case 'x':
2414             opt_xchr = FALSE;
2415             break;
2416         case 'X':
2417             opt_xchr = TRUE;
2418             break;
2419         case CTRL('p'):
2420         case KEY_UP:
2421             if (base_row <= 0) {
2422                 beep();
2423             } else {
2424                 base_row -= 1;
2425             }
2426             break;
2427         case CTRL('n'):
2428         case KEY_DOWN:
2429             if (base_row + page_size >= row_limit) {
2430                 beep();
2431             } else {
2432                 base_row += 1;
2433             }
2434             break;
2435         case CTRL('b'):
2436         case KEY_PREVIOUS:
2437         case KEY_PPAGE:
2438             if (base_row <= 0) {
2439                 beep();
2440             } else {
2441                 base_row -= (page_size - 1);
2442                 if (base_row < 0)
2443                     base_row = 0;
2444             }
2445             break;
2446         case CTRL('f'):
2447         case KEY_NEXT:
2448         case KEY_NPAGE:
2449             if (base_row + page_size >= row_limit) {
2450                 beep();
2451             } else {
2452                 base_row += page_size - 1;
2453                 if (base_row + page_size >= row_limit) {
2454                     base_row = row_limit - page_size - 1;
2455                 }
2456             }
2457             break;
2458         case '?':
2459             if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
2460                 box(helpwin, 0, 0);
2461                 color_legend(helpwin, TRUE);
2462                 wGetchar(helpwin);
2463                 delwin(helpwin);
2464             }
2465             break;
2466         default:
2467             beep();
2468             continue;
2469         }
2470     }
2471
2472     erase();
2473     endwin();
2474 }
2475 #endif /* USE_WIDEC_SUPPORT */
2476
2477 static void
2478 change_color(NCURSES_PAIRS_T current, int field, int value, int usebase)
2479 {
2480     NCURSES_COLOR_T red, green, blue;
2481
2482     color_content(current, &red, &green, &blue);
2483
2484     switch (field) {
2485     case 0:
2486         red = (NCURSES_COLOR_T) (usebase ? (red + value) : value);
2487         break;
2488     case 1:
2489         green = (NCURSES_COLOR_T) (usebase ? (green + value) : value);
2490         break;
2491     case 2:
2492         blue = (NCURSES_COLOR_T) (usebase ? (blue + value) : value);
2493         break;
2494     }
2495
2496     if (init_color(current, red, green, blue) == ERR)
2497         beep();
2498 }
2499
2500 static void
2501 init_all_colors(void)
2502 {
2503     NCURSES_PAIRS_T c;
2504
2505     for (c = 0; c < COLORS; ++c)
2506         init_color(c,
2507                    all_colors[c].red,
2508                    all_colors[c].green,
2509                    all_colors[c].blue);
2510 }
2511
2512 #define scaled_rgb(n) ((255 * (n)) / 1000)
2513
2514 static void
2515 color_edit(void)
2516 /* display the color test pattern, without trying to edit colors */
2517 {
2518     int i;
2519     int current = 0;
2520     int this_c = 0, value = 0, field = 0;
2521     int last_c;
2522     int top_color = 0;
2523     int page_size = (LINES - 6);
2524
2525     init_all_colors();
2526     refresh();
2527
2528     for (i = 0; i < max_colors; i++)
2529         init_pair((NCURSES_PAIRS_T) i,
2530                   (NCURSES_COLOR_T) COLOR_WHITE,
2531                   (NCURSES_COLOR_T) i);
2532
2533     MvPrintw(LINES - 2, 0, "Number: %d", value);
2534
2535     do {
2536         NCURSES_COLOR_T red, green, blue;
2537
2538         attron(A_BOLD);
2539         MvAddStr(0, 20, "Color RGB Value Editing");
2540         attroff(A_BOLD);
2541
2542         for (i = (NCURSES_COLOR_T) top_color;
2543              (i - top_color < page_size)
2544              && (i < max_colors); i++) {
2545             char numeric[80];
2546
2547             sprintf(numeric, "[%d]", i);
2548             MvPrintw(2 + i - top_color, 0, "%c %-8s:",
2549                      (i == current ? '>' : ' '),
2550                      (i < (int) SIZEOF(the_color_names)
2551                       ? the_color_names[i] : numeric));
2552             (void) attrset((attr_t) COLOR_PAIR(i));
2553             addstr("        ");
2554             (void) attrset(A_NORMAL);
2555
2556             color_content((NCURSES_PAIRS_T) i, &red, &green, &blue);
2557             addstr("   R = ");
2558             if (current == i && field == 0)
2559                 attron(A_STANDOUT);
2560             printw("%04d", (int) red);
2561             if (current == i && field == 0)
2562                 (void) attrset(A_NORMAL);
2563             addstr(", G = ");
2564             if (current == i && field == 1)
2565                 attron(A_STANDOUT);
2566             printw("%04d", (int) green);
2567             if (current == i && field == 1)
2568                 (void) attrset(A_NORMAL);
2569             addstr(", B = ");
2570             if (current == i && field == 2)
2571                 attron(A_STANDOUT);
2572             printw("%04d", (int) blue);
2573             if (current == i && field == 2)
2574                 (void) attrset(A_NORMAL);
2575             (void) attrset(A_NORMAL);
2576             printw(" ( %3d %3d %3d )",
2577                    (int) scaled_rgb(red),
2578                    (int) scaled_rgb(green),
2579                    (int) scaled_rgb(blue));
2580         }
2581
2582         MvAddStr(LINES - 3, 0,
2583                  "Use up/down to select a color, left/right to change fields.");
2584         MvAddStr(LINES - 2, 0,
2585                  "Modify field by typing nnn=, nnn-, or nnn+.  ? for help.");
2586
2587         move(2 + current - top_color, 0);
2588
2589         last_c = this_c;
2590         this_c = Getchar();
2591         if (this_c < 256 && isdigit(this_c) && !isdigit(last_c))
2592             value = 0;
2593
2594         switch (this_c) {
2595         case CTRL('b'):
2596         case KEY_PPAGE:
2597             if (current > 0)
2598                 current -= (page_size - 1);
2599             else
2600                 beep();
2601             break;
2602
2603         case CTRL('f'):
2604         case KEY_NPAGE:
2605             if (current < (max_colors - 1))
2606                 current += (page_size - 1);
2607             else
2608                 beep();
2609             break;
2610
2611         case CTRL('p'):
2612         case KEY_UP:
2613             current = (current == 0 ? (max_colors - 1) : current - 1);
2614             break;
2615
2616         case CTRL('n'):
2617         case KEY_DOWN:
2618             current = (current == (max_colors - 1) ? 0 : current + 1);
2619             break;
2620
2621         case KEY_RIGHT:
2622             field = (field == 2 ? 0 : field + 1);
2623             break;
2624
2625         case KEY_LEFT:
2626             field = (field == 0 ? 2 : field - 1);
2627             break;
2628
2629         case '0':
2630         case '1':
2631         case '2':
2632         case '3':
2633         case '4':
2634         case '5':
2635         case '6':
2636         case '7':
2637         case '8':
2638         case '9':
2639             value = value * 10 + (this_c - '0');
2640             break;
2641
2642         case '+':
2643             change_color((NCURSES_PAIRS_T) current, field, value, 1);
2644             break;
2645
2646         case '-':
2647             change_color((NCURSES_PAIRS_T) current, field, -value, 1);
2648             break;
2649
2650         case '=':
2651             change_color((NCURSES_PAIRS_T) current, field, value, 0);
2652             break;
2653
2654         case '?':
2655             erase();
2656             P("                      RGB Value Editing Help");
2657             P("");
2658             P("You are in the RGB value editor.  Use the arrow keys to select one of");
2659             P("the fields in one of the RGB triples of the current colors; the one");
2660             P("currently selected will be reverse-video highlighted.");
2661             P("");
2662             P("To change a field, enter the digits of the new value; they are echoed");
2663             P("as entered.  Finish by typing `='.  The change will take effect instantly.");
2664             P("To increment or decrement a value, use the same procedure, but finish");
2665             P("with a `+' or `-'.");
2666             P("");
2667             P("Press 'm' to invoke the top-level menu with the current color settings.");
2668             P("To quit, do ESC");
2669
2670             Pause();
2671             erase();
2672             break;
2673
2674         case 'm':
2675             endwin();
2676             main_menu(FALSE);
2677             for (i = 0; i < max_colors; i++)
2678                 init_pair((NCURSES_PAIRS_T) i,
2679                           (NCURSES_COLOR_T) COLOR_WHITE,
2680                           (NCURSES_COLOR_T) i);
2681             refresh();
2682             break;
2683
2684         case case_QUIT:
2685             break;
2686
2687         default:
2688             beep();
2689             break;
2690         }
2691
2692         if (current < 0)
2693             current = 0;
2694         if (current >= max_colors)
2695             current = max_colors - 1;
2696         if (current < top_color)
2697             top_color = current;
2698         if (current - top_color >= page_size)
2699             top_color = current - (page_size - 1);
2700
2701         MvPrintw(LINES - 1, 0, "Number: %d", value);
2702         clrtoeol();
2703     } while
2704         (!isQuit(this_c));
2705
2706     erase();
2707
2708     /*
2709      * ncurses does not reset each color individually when calling endwin().
2710      */
2711     init_all_colors();
2712
2713     endwin();
2714 }
2715
2716 /****************************************************************************
2717  *
2718  * Alternate character-set stuff
2719  *
2720  ****************************************************************************/
2721 static bool
2722 cycle_attr(int ch, unsigned *at_code, chtype *attr, ATTR_TBL * list, unsigned limit)
2723 {
2724     bool result = TRUE;
2725
2726     switch (ch) {
2727     case 'v':
2728         if ((*at_code += 1) >= limit)
2729             *at_code = 0;
2730         break;
2731     case 'V':
2732         if (*at_code == 0)
2733             *at_code = limit - 1;
2734         else
2735             *at_code -= 1;
2736         break;
2737     default:
2738         result = FALSE;
2739         break;
2740     }
2741     if (result)
2742         *attr = list[*at_code].attr;
2743     return result;
2744 }
2745
2746 static bool
2747 cycle_colors(int ch, int *fg, int *bg, NCURSES_PAIRS_T *pair)
2748 {
2749     bool result = FALSE;
2750
2751     if (use_colors) {
2752         result = TRUE;
2753         switch (ch) {
2754         case 'F':
2755             if ((*fg -= 1) < 0)
2756                 *fg = COLORS - 1;
2757             break;
2758         case 'f':
2759             if ((*fg += 1) >= COLORS)
2760                 *fg = 0;
2761             break;
2762         case 'B':
2763             if ((*bg -= 1) < 0)
2764                 *bg = COLORS - 1;
2765             break;
2766         case 'b':
2767             if ((*bg += 1) >= COLORS)
2768                 *bg = 0;
2769             break;
2770         default:
2771             result = FALSE;
2772             break;
2773         }
2774         if (result) {
2775             *pair = (NCURSES_PAIRS_T) (*fg != COLOR_BLACK || *bg != COLOR_BLACK);
2776             if (*pair != 0) {
2777                 *pair = 1;
2778                 if (init_pair(*pair,
2779                               (NCURSES_COLOR_T) *fg,
2780                               (NCURSES_COLOR_T) *bg) == ERR) {
2781                     result = FALSE;
2782                 }
2783             }
2784         }
2785     }
2786     return result;
2787 }
2788
2789 /****************************************************************************
2790  *
2791  * Soft-key label test
2792  *
2793  ****************************************************************************/
2794
2795 #if USE_SOFTKEYS
2796
2797 #define SLK_HELP 17
2798 #define SLK_WORK (SLK_HELP + 3)
2799
2800 static void
2801 slk_help(void)
2802 {
2803     static const char *table[] =
2804     {
2805         "Available commands are:"
2806         ,""
2807         ,"^L         -- repaint this message and activate soft keys"
2808         ,"a/d        -- activate/disable soft keys"
2809         ,"c          -- set centered format for labels"
2810         ,"l          -- set left-justified format for labels"
2811         ,"r          -- set right-justified format for labels"
2812         ,"[12345678] -- set label; labels are numbered 1 through 8"
2813         ,"e          -- erase stdscr (should not erase labels)"
2814         ,"s          -- test scrolling of shortened screen"
2815         ,"v/V        -- cycle through video attributes"
2816 #if HAVE_SLK_COLOR
2817         ,"F/f/B/b    -- cycle through foreground/background colors"
2818 #endif
2819         ,"ESC        -- return to main menu"
2820         ,""
2821         ,"Note: if activating the soft keys causes your terminal to scroll up"
2822         ,"one line, your terminal auto-scrolls when anything is written to the"
2823         ,"last screen position.  The ncurses code does not yet handle this"
2824         ,"gracefully."
2825     };
2826     unsigned j;
2827
2828     move(2, 0);
2829     for (j = 0; j < SIZEOF(table); ++j) {
2830         P(table[j]);
2831     }
2832     refresh();
2833 }
2834
2835 #if HAVE_SLK_COLOR
2836 static void
2837 call_slk_color(int fg, int bg)
2838 {
2839     init_pair(1, (NCURSES_COLOR_T) bg, (NCURSES_COLOR_T) fg);
2840     slk_color(1);
2841     MvPrintw(SLK_WORK, 0, "Colors %d/%d\n", fg, bg);
2842     clrtoeol();
2843     slk_touch();
2844     slk_noutrefresh();
2845     refresh();
2846 }
2847 #endif
2848
2849 static void
2850 slk_test(void)
2851 /* exercise the soft keys */
2852 {
2853     int c, fmt = 1;
2854     char buf[9];
2855     char *s;
2856     chtype attr = A_NORMAL;
2857     unsigned at_code = 0;
2858 #if HAVE_SLK_COLOR
2859     int fg = COLOR_BLACK;
2860     int bg = COLOR_WHITE;
2861     NCURSES_PAIRS_T pair = 0;
2862 #endif
2863     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
2864     unsigned my_size = init_attr_list(my_list, termattrs());
2865
2866     c = CTRL('l');
2867 #if HAVE_SLK_COLOR
2868     if (use_colors) {
2869         call_slk_color(fg, bg);
2870     }
2871 #endif
2872
2873     do {
2874         move(0, 0);
2875         switch (c) {
2876         case CTRL('l'):
2877             erase();
2878             attron(A_BOLD);
2879             MvAddStr(0, 20, "Soft Key Exerciser");
2880             attroff(A_BOLD);
2881
2882             slk_help();
2883             /* fall through */
2884
2885         case 'a':
2886             slk_restore();
2887             break;
2888
2889         case 'e':
2890             wclear(stdscr);
2891             break;
2892
2893         case 's':
2894             MvPrintw(SLK_WORK, 0, "Press Q to stop the scrolling-test: ");
2895             while ((c = Getchar()) != 'Q' && (c != ERR))
2896                 addch((chtype) c);
2897             break;
2898
2899         case 'd':
2900             slk_clear();
2901             break;
2902
2903         case 'l':
2904             fmt = 0;
2905             break;
2906
2907         case 'c':
2908             fmt = 1;
2909             break;
2910
2911         case 'r':
2912             fmt = 2;
2913             break;
2914
2915         case '1':
2916         case '2':
2917         case '3':
2918         case '4':
2919         case '5':
2920         case '6':
2921         case '7':
2922         case '8':
2923             MvAddStr(SLK_WORK, 0, "Please enter the label value: ");
2924             strcpy(buf, "");
2925             if ((s = slk_label(c - '0')) != 0) {
2926                 strncpy(buf, s, (size_t) 8);
2927             }
2928             wGetstring(stdscr, buf, 8);
2929             slk_set((c - '0'), buf, fmt);
2930             slk_refresh();
2931             move(SLK_WORK, 0);
2932             clrtobot();
2933             break;
2934
2935         case case_QUIT:
2936             goto done;
2937
2938 #if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
2939         case KEY_RESIZE:
2940             wnoutrefresh(stdscr);
2941             break;
2942 #endif
2943
2944         default:
2945             if (cycle_attr(c, &at_code, &attr, my_list, my_size)) {
2946                 slk_attrset(attr);
2947                 slk_touch();
2948                 slk_noutrefresh();
2949                 break;
2950             }
2951 #if HAVE_SLK_COLOR
2952             if (cycle_colors(c, &fg, &bg, &pair)) {
2953                 if (use_colors) {
2954                     call_slk_color(fg, bg);
2955                 } else {
2956                     beep();
2957                 }
2958                 break;
2959             }
2960 #endif
2961             beep();
2962             break;
2963         }
2964     } while (!isQuit(c = Getchar()));
2965
2966   done:
2967     slk_clear();
2968     erase();
2969     endwin();
2970 }
2971
2972 #if USE_WIDEC_SUPPORT
2973 #define SLKLEN 8
2974 static void
2975 wide_slk_test(void)
2976 /* exercise the soft keys */
2977 {
2978     int c, fmt = 1;
2979     wchar_t buf[SLKLEN + 1];
2980     char *s;
2981     chtype attr = A_NORMAL;
2982     unsigned at_code = 0;
2983     int fg = COLOR_BLACK;
2984     int bg = COLOR_WHITE;
2985     NCURSES_PAIRS_T pair = 0;
2986     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
2987     unsigned my_size = init_attr_list(my_list, term_attrs());
2988
2989     c = CTRL('l');
2990     if (use_colors) {
2991         call_slk_color(fg, bg);
2992     }
2993     do {
2994         move(0, 0);
2995         switch (c) {
2996         case CTRL('l'):
2997             erase();
2998             attr_on(WA_BOLD, NULL);
2999             MvAddStr(0, 20, "Soft Key Exerciser");
3000             attr_off(WA_BOLD, NULL);
3001
3002             slk_help();
3003             /* fall through */
3004
3005         case 'a':
3006             slk_restore();
3007             break;
3008
3009         case 'e':
3010             wclear(stdscr);
3011             break;
3012
3013         case 's':
3014             MvPrintw(SLK_WORK, 0, "Press Q to stop the scrolling-test: ");
3015             while ((c = Getchar()) != 'Q' && (c != ERR))
3016                 addch((chtype) c);
3017             break;
3018
3019         case 'd':
3020             slk_clear();
3021             break;
3022
3023         case 'l':
3024             fmt = 0;
3025             break;
3026
3027         case 'c':
3028             fmt = 1;
3029             break;
3030
3031         case 'r':
3032             fmt = 2;
3033             break;
3034
3035         case '1':
3036         case '2':
3037         case '3':
3038         case '4':
3039         case '5':
3040         case '6':
3041         case '7':
3042         case '8':
3043             MvAddStr(SLK_WORK, 0, "Please enter the label value: ");
3044             *buf = 0;
3045             if ((s = slk_label(c - '0')) != 0) {
3046                 char *temp = strdup(s);
3047                 size_t used = strlen(temp);
3048                 size_t want = SLKLEN;
3049                 size_t test;
3050 #ifndef state_unused
3051                 mbstate_t state;
3052 #endif
3053
3054                 buf[0] = L'\0';
3055                 while (want > 0 && used != 0) {
3056                     const char *base = s;
3057                     reset_mbytes(state);
3058                     test = count_mbytes(base, 0, &state);
3059                     if (test == (size_t) -1) {
3060                         temp[--used] = 0;
3061                     } else if (test > want) {
3062                         temp[--used] = 0;
3063                     } else {
3064                         reset_mbytes(state);
3065                         trans_mbytes(buf, base, want, &state);
3066                         break;
3067                     }
3068                 }
3069                 free(temp);
3070             }
3071             wGet_wstring(stdscr, buf, SLKLEN);
3072             slk_wset((c - '0'), buf, fmt);
3073             slk_refresh();
3074             move(SLK_WORK, 0);
3075             clrtobot();
3076             break;
3077
3078         case case_QUIT:
3079             goto done;
3080
3081         case 'F':
3082             if (use_colors) {
3083                 fg = (NCURSES_COLOR_T) ((fg + 1) % COLORS);
3084                 call_slk_color(fg, bg);
3085             }
3086             break;
3087         case 'B':
3088             if (use_colors) {
3089                 bg = (NCURSES_COLOR_T) ((bg + 1) % COLORS);
3090                 call_slk_color(fg, bg);
3091             }
3092             break;
3093 #if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
3094         case KEY_RESIZE:
3095             wnoutrefresh(stdscr);
3096             break;
3097 #endif
3098         default:
3099             if (cycle_attr(c, &at_code, &attr, my_list, my_size)) {
3100                 slk_attr_set(attr, (NCURSES_COLOR_T) (fg || bg), NULL);
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 #endif
3126 #endif /* SLK_INIT */
3127
3128 static void
3129 show_256_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3130 {
3131     unsigned first = 0;
3132     unsigned last = 255;
3133     unsigned code;
3134     int count;
3135
3136     erase();
3137     attron(A_BOLD);
3138     MvPrintw(0, 20, "Display of Character Codes %#0x to %#0x",
3139              first, last);
3140     attroff(A_BOLD);
3141     refresh();
3142
3143     for (code = first; code <= last; ++code) {
3144         int row = (int) (2 + (code / 16));
3145         int col = (int) (5 * (code % 16));
3146         IGNORE_RC(mvaddch(row, col, colored_chtype(code, attr, pair)));
3147         for (count = 1; count < repeat; ++count) {
3148             addch(colored_chtype(code, attr, pair));
3149         }
3150     }
3151
3152 }
3153
3154 /*
3155  * Show a slice of 32 characters, allowing those to be repeated up to the
3156  * screen's width.
3157  *
3158  * ISO 6429:  codes 0x80 to 0x9f may be control characters that cause the
3159  * terminal to perform functions.  The remaining codes can be graphic.
3160  */
3161 static void
3162 show_upper_chars(int base, int pagesize, int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3163 {
3164     unsigned code;
3165     unsigned first = (unsigned) base;
3166     unsigned last = first + (unsigned) pagesize - 2;
3167     bool C1 = (first == 128);
3168     int reply;
3169
3170     erase();
3171     attron(A_BOLD);
3172     MvPrintw(0, 20, "Display of %s Character Codes %d to %d",
3173              C1 ? "C1" : "GR", first, last);
3174     attroff(A_BOLD);
3175     refresh();
3176
3177     for (code = first; code <= last; code++) {
3178         int count = repeat;
3179         int row = 2 + ((int) (code - first) % (pagesize / 2));
3180         int col = ((int) (code - first) / (pagesize / 2)) * COLS / 2;
3181         char tmp[80];
3182         sprintf(tmp, "%3u (0x%x)", code, code);
3183         MvPrintw(row, col, "%*s: ", COLS / 4, tmp);
3184
3185         do {
3186             if (C1)
3187                 nodelay(stdscr, TRUE);
3188             echochar(colored_chtype(code, attr, pair));
3189             if (C1) {
3190                 /* (yes, this _is_ crude) */
3191                 while ((reply = Getchar()) != ERR) {
3192                     addch(UChar(reply));
3193                     napms(10);
3194                 }
3195                 nodelay(stdscr, FALSE);
3196             }
3197         } while (--count > 0);
3198     }
3199 }
3200
3201 #define PC_COLS 4
3202
3203 static void
3204 show_pc_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3205 {
3206     unsigned code;
3207
3208     erase();
3209     attron(A_BOLD);
3210     MvPrintw(0, 20, "Display of PC Character Codes");
3211     attroff(A_BOLD);
3212     refresh();
3213
3214     for (code = 0; code < 16; ++code) {
3215         MvPrintw(2, (int) code * PC_COLS + 8, "%X", code);
3216     }
3217     for (code = 0; code < 256; code++) {
3218         int count = repeat;
3219         int row = 3 + (int) (code / 16) + (code >= 128);
3220         int col = 8 + (int) (code % 16) * PC_COLS;
3221         if ((code % 16) == 0)
3222             MvPrintw(row, 0, "0x%02x:", code);
3223         move(row, col);
3224         do {
3225             switch (code) {
3226             case '\n':
3227             case '\r':
3228             case '\b':
3229             case '\f':
3230             case '\033':
3231             case 0x9b:
3232                 /*
3233                  * Skip the ones that do not work.
3234                  */
3235                 break;
3236             default:
3237                 addch(colored_chtype(code, A_ALTCHARSET | attr, pair));
3238                 break;
3239             }
3240         } while (--count > 0);
3241     }
3242 }
3243
3244 static void
3245 show_box_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3246 {
3247     (void) repeat;
3248
3249     attr |= (attr_t) COLOR_PAIR(pair);
3250
3251     erase();
3252     attron(A_BOLD);
3253     MvAddStr(0, 20, "Display of the ACS Line-Drawing Set");
3254     attroff(A_BOLD);
3255     refresh();
3256     /* *INDENT-OFF* */
3257     wborder(stdscr,
3258             colored_chtype(ACS_VLINE,    attr, pair),
3259             colored_chtype(ACS_VLINE,    attr, pair),
3260             colored_chtype(ACS_HLINE,    attr, pair),
3261             colored_chtype(ACS_HLINE,    attr, pair),
3262             colored_chtype(ACS_ULCORNER, attr, pair),
3263             colored_chtype(ACS_URCORNER, attr, pair),
3264             colored_chtype(ACS_LLCORNER, attr, pair),
3265             colored_chtype(ACS_LRCORNER, attr, pair));
3266     MvHLine(LINES / 2, 0,        colored_chtype(ACS_HLINE, attr, pair), COLS);
3267     MvVLine(0,         COLS / 2, colored_chtype(ACS_VLINE, attr, pair), LINES);
3268     MvAddCh(0,         COLS / 2, colored_chtype(ACS_TTEE,  attr, pair));
3269     MvAddCh(LINES / 2, COLS / 2, colored_chtype(ACS_PLUS,  attr, pair));
3270     MvAddCh(LINES - 1, COLS / 2, colored_chtype(ACS_BTEE,  attr, pair));
3271     MvAddCh(LINES / 2, 0,        colored_chtype(ACS_LTEE,  attr, pair));
3272     MvAddCh(LINES / 2, COLS - 1, colored_chtype(ACS_RTEE,  attr, pair));
3273     /* *INDENT-ON* */
3274
3275 }
3276
3277 static int
3278 show_1_acs(int n, int repeat, const char *name, chtype code)
3279 {
3280     const int height = 16;
3281     int row = 2 + (n % height);
3282     int col = (n / height) * COLS / 2;
3283
3284     MvPrintw(row, col, "%*s : ", COLS / 4, name);
3285     do {
3286         addch(code);
3287     } while (--repeat > 0);
3288     return n + 1;
3289 }
3290
3291 static void
3292 show_acs_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3293 /* display the ACS character set */
3294 {
3295     int n;
3296
3297 #define BOTH(name) #name, colored_chtype(name, attr, (chtype) pair)
3298
3299     erase();
3300     attron(A_BOLD);
3301     MvAddStr(0, 20, "Display of the ACS Character Set");
3302     attroff(A_BOLD);
3303     refresh();
3304
3305     n = show_1_acs(0, repeat, BOTH(ACS_ULCORNER));
3306     n = show_1_acs(n, repeat, BOTH(ACS_URCORNER));
3307     n = show_1_acs(n, repeat, BOTH(ACS_LLCORNER));
3308     n = show_1_acs(n, repeat, BOTH(ACS_LRCORNER));
3309
3310     n = show_1_acs(n, repeat, BOTH(ACS_LTEE));
3311     n = show_1_acs(n, repeat, BOTH(ACS_RTEE));
3312     n = show_1_acs(n, repeat, BOTH(ACS_TTEE));
3313     n = show_1_acs(n, repeat, BOTH(ACS_BTEE));
3314
3315     n = show_1_acs(n, repeat, BOTH(ACS_HLINE));
3316     n = show_1_acs(n, repeat, BOTH(ACS_VLINE));
3317
3318     /*
3319      * HPUX's ACS definitions are broken here.  Just give up.
3320      */
3321 #if !(defined(__hpux) && !defined(NCURSES_VERSION))
3322     n = show_1_acs(n, repeat, BOTH(ACS_LARROW));
3323     n = show_1_acs(n, repeat, BOTH(ACS_RARROW));
3324     n = show_1_acs(n, repeat, BOTH(ACS_UARROW));
3325     n = show_1_acs(n, repeat, BOTH(ACS_DARROW));
3326
3327     n = show_1_acs(n, repeat, BOTH(ACS_BLOCK));
3328     n = show_1_acs(n, repeat, BOTH(ACS_BOARD));
3329     n = show_1_acs(n, repeat, BOTH(ACS_LANTERN));
3330     n = show_1_acs(n, repeat, BOTH(ACS_BULLET));
3331     n = show_1_acs(n, repeat, BOTH(ACS_CKBOARD));
3332     n = show_1_acs(n, repeat, BOTH(ACS_DEGREE));
3333     n = show_1_acs(n, repeat, BOTH(ACS_DIAMOND));
3334     n = show_1_acs(n, repeat, BOTH(ACS_PLMINUS));
3335     n = show_1_acs(n, repeat, BOTH(ACS_PLUS));
3336
3337     n = show_1_acs(n, repeat, BOTH(ACS_GEQUAL));
3338     n = show_1_acs(n, repeat, BOTH(ACS_NEQUAL));
3339     n = show_1_acs(n, repeat, BOTH(ACS_LEQUAL));
3340
3341     n = show_1_acs(n, repeat, BOTH(ACS_STERLING));
3342     n = show_1_acs(n, repeat, BOTH(ACS_PI));
3343     n = show_1_acs(n, repeat, BOTH(ACS_S1));
3344     n = show_1_acs(n, repeat, BOTH(ACS_S3));
3345     n = show_1_acs(n, repeat, BOTH(ACS_S7));
3346     (void) show_1_acs(n, repeat, BOTH(ACS_S9));
3347 #endif
3348 }
3349
3350 static void
3351 acs_display(void)
3352 {
3353     int c = 'a';
3354     int pagesize = 32;
3355     char *term = getenv("TERM");
3356     const char *pch_kludge = ((term != 0 && strstr(term, "linux"))
3357                               ? "p=PC, "
3358                               : "");
3359     chtype attr = A_NORMAL;
3360     int digit = 0;
3361     int repeat = 1;
3362     int fg = COLOR_BLACK;
3363     int bg = COLOR_BLACK;
3364     unsigned at_code = 0;
3365     NCURSES_PAIRS_T pair = 0;
3366     void (*last_show_acs) (int, attr_t, NCURSES_PAIRS_T) = 0;
3367     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
3368     unsigned my_size = init_attr_list(my_list, termattrs());
3369
3370     do {
3371         switch (c) {
3372         case CTRL('L'):
3373             Repaint();
3374             break;
3375         case 'a':
3376             ToggleAcs(last_show_acs, show_acs_chars);
3377             break;
3378         case 'p':
3379             if (*pch_kludge)
3380                 ToggleAcs(last_show_acs, show_pc_chars);
3381             else
3382                 beep();
3383             break;
3384         case 'w':
3385             if (pagesize == 32) {
3386                 pagesize = 256;
3387             } else {
3388                 pagesize = 32;
3389             }
3390             break;
3391         case 'x':
3392             ToggleAcs(last_show_acs, show_box_chars);
3393             break;
3394         case '0':
3395         case '1':
3396         case '2':
3397         case '3':
3398             digit = (c - '0');
3399             last_show_acs = 0;
3400             break;
3401         case '-':
3402             if (digit > 0) {
3403                 --digit;
3404                 last_show_acs = 0;
3405             } else {
3406                 beep();
3407             }
3408             break;
3409         case '+':
3410             if (digit < 3) {
3411                 ++digit;
3412                 last_show_acs = 0;
3413             } else {
3414                 beep();
3415             }
3416             break;
3417         case '>':
3418             if (repeat < (COLS / 4))
3419                 ++repeat;
3420             break;
3421         case '<':
3422             if (repeat > 1)
3423                 --repeat;
3424             break;
3425         default:
3426             if (cycle_attr(c, &at_code, &attr, my_list, my_size)
3427                 || cycle_colors(c, &fg, &bg, &pair)) {
3428                 break;
3429             } else {
3430                 beep();
3431             }
3432             break;
3433         }
3434         if (pagesize != 32) {
3435             show_256_chars(repeat, attr, pair);
3436         } else if (last_show_acs != 0) {
3437             last_show_acs(repeat, attr, pair);
3438         } else {
3439             show_upper_chars(digit * pagesize + 128, pagesize, repeat, attr, pair);
3440         }
3441
3442         MvPrintw(LINES - 3, 0,
3443                  "Note: ANSI terminals may not display C1 characters.");
3444         MvPrintw(LINES - 2, 0,
3445                  "Select: a=ACS, w=all x=box, %s0=C1, 1-3,+/- non-ASCII, </> repeat, ESC=quit",
3446                  pch_kludge);
3447         if (use_colors) {
3448             MvPrintw(LINES - 1, 0,
3449                      "v/V, f/F, b/B cycle through video attributes (%s) and color %d/%d.",
3450                      my_list[at_code].name,
3451                      fg, bg);
3452         } else {
3453             MvPrintw(LINES - 1, 0,
3454                      "v/V cycles through video attributes (%s).",
3455                      my_list[at_code].name);
3456         }
3457         refresh();
3458     } while (!isQuit(c = Getchar()));
3459
3460     Pause();
3461     erase();
3462     endwin();
3463 }
3464
3465 #if USE_WIDEC_SUPPORT
3466 static cchar_t *
3467 merge_wide_attr(cchar_t *dst, const cchar_t *src, attr_t attr, NCURSES_PAIRS_T pair)
3468 {
3469     int count;
3470
3471     *dst = *src;
3472     do {
3473         TEST_CCHAR(src, count, {
3474             attr |= (test_attrs & A_ALTCHARSET);
3475             setcchar(dst, test_wch, attr, pair, NULL);
3476         }
3477         , {
3478             ;
3479         });
3480     } while (0);
3481     return dst;
3482 }
3483
3484 /*
3485  * Header/legend take up no more than 8 lines, leaving 16 lines on a 24-line
3486  * display.  If there are no repeats, we could normally display 16 lines of 64
3487  * characters (1024 total).  However, taking repeats and double-width cells
3488  * into account, use 256 characters for the page.
3489  */
3490 static void
3491 show_paged_widechars(int base,
3492                      int pagesize,
3493                      int repeat,
3494                      int space,
3495                      attr_t attr,
3496                      NCURSES_PAIRS_T pair)
3497 {
3498     int first = base * pagesize;
3499     int last = first + pagesize - 1;
3500     int per_line = 16;
3501     cchar_t temp;
3502     wchar_t code;
3503     wchar_t codes[10];
3504
3505     erase();
3506     attron(A_BOLD);
3507     MvPrintw(0, 20, "Display of Character Codes %#x to %#x", first, last);
3508     attroff(A_BOLD);
3509
3510     for (code = first; (int) code <= last; code++) {
3511         int row = (2 + ((int) code - first) / per_line);
3512         int col = 5 * ((int) code % per_line);
3513         int count;
3514
3515         memset(&codes, 0, sizeof(codes));
3516         codes[0] = code;
3517         setcchar(&temp, codes, attr, pair, 0);
3518         move(row, col);
3519         if (wcwidth(code) == 0 && code != 0) {
3520             addch((chtype) space |
3521                   (A_REVERSE ^ attr) |
3522                   (attr_t) COLOR_PAIR(pair));
3523         }
3524         add_wch(&temp);
3525         for (count = 1; count < repeat; ++count) {
3526             add_wch(&temp);
3527         }
3528     }
3529 }
3530
3531 static void
3532 show_upper_widechars(int first, int repeat, int space, attr_t attr, NCURSES_PAIRS_T pair)
3533 {
3534     cchar_t temp;
3535     wchar_t code;
3536     int last = first + 31;
3537
3538     erase();
3539     attron(A_BOLD);
3540     MvPrintw(0, 20, "Display of Character Codes %d to %d", first, last);
3541     attroff(A_BOLD);
3542
3543     for (code = first; (int) code <= last; code++) {
3544         int row = 2 + ((code - first) % 16);
3545         int col = ((code - first) / 16) * COLS / 2;
3546         wchar_t codes[10];
3547         char tmp[80];
3548         int count = repeat;
3549         int y, x;
3550
3551         sprintf(tmp, "%3ld (0x%lx)", (long) code, (long) code);
3552         MvPrintw(row, col, "%*s: ", COLS / 4, tmp);
3553
3554         memset(&codes, 0, sizeof(codes));
3555         codes[0] = code;
3556         setcchar(&temp, codes, attr, pair, 0);
3557
3558         do {
3559             /*
3560              * Give non-spacing characters something to combine with.  If we
3561              * don't, they'll bunch up in a heap on the space after the ":".
3562              * Mark them with reverse-video to make them simpler to find on
3563              * the display.
3564              */
3565             if (wcwidth(code) == 0) {
3566                 addch((chtype) space |
3567                       (A_REVERSE ^ attr) |
3568                       (attr_t) COLOR_PAIR(pair));
3569             }
3570             /*
3571              * This uses echo_wchar(), for comparison with the normal 'f'
3572              * test (and to make a test-case for echo_wchar()).  The screen
3573              * may flicker because the erase() at the top of the function
3574              * is met by the builtin refresh() in echo_wchar().
3575              */
3576             echo_wchar(&temp);
3577             /*
3578              * The repeat-count may make text wrap - avoid that.
3579              */
3580             getyx(stdscr, y, x);
3581             (void) y;
3582             if (x >= col + (COLS / 2) - 2)
3583                 break;
3584         } while (--count > 0);
3585     }
3586 }
3587
3588 static int
3589 show_1_wacs(int n, int repeat, const char *name, const cchar_t *code)
3590 {
3591     const int height = 16;
3592     int row = 2 + (n % height);
3593     int col = (n / height) * COLS / 2;
3594
3595     MvPrintw(row, col, "%*s : ", COLS / 4, name);
3596     while (--repeat >= 0) {
3597         add_wch(code);
3598     }
3599     return n + 1;
3600 }
3601
3602 #define MERGE_ATTR(wch) merge_wide_attr(&temp, wch, attr, pair)
3603
3604 static void
3605 show_wacs_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3606 /* display the wide-ACS character set */
3607 {
3608     cchar_t temp;
3609
3610     int n;
3611
3612 /*#define BOTH2(name) #name, &(name) */
3613 #define BOTH2(name) #name, MERGE_ATTR(name)
3614
3615     erase();
3616     attron(A_BOLD);
3617     MvAddStr(0, 20, "Display of the Wide-ACS Character Set");
3618     attroff(A_BOLD);
3619     refresh();
3620
3621     n = show_1_wacs(0, repeat, BOTH2(WACS_ULCORNER));
3622     n = show_1_wacs(n, repeat, BOTH2(WACS_URCORNER));
3623     n = show_1_wacs(n, repeat, BOTH2(WACS_LLCORNER));
3624     n = show_1_wacs(n, repeat, BOTH2(WACS_LRCORNER));
3625
3626     n = show_1_wacs(n, repeat, BOTH2(WACS_LTEE));
3627     n = show_1_wacs(n, repeat, BOTH2(WACS_RTEE));
3628     n = show_1_wacs(n, repeat, BOTH2(WACS_TTEE));
3629     n = show_1_wacs(n, repeat, BOTH2(WACS_BTEE));
3630
3631     n = show_1_wacs(n, repeat, BOTH2(WACS_HLINE));
3632     n = show_1_wacs(n, repeat, BOTH2(WACS_VLINE));
3633
3634     n = show_1_wacs(n, repeat, BOTH2(WACS_LARROW));
3635     n = show_1_wacs(n, repeat, BOTH2(WACS_RARROW));
3636     n = show_1_wacs(n, repeat, BOTH2(WACS_UARROW));
3637     n = show_1_wacs(n, repeat, BOTH2(WACS_DARROW));
3638
3639     n = show_1_wacs(n, repeat, BOTH2(WACS_BLOCK));
3640     n = show_1_wacs(n, repeat, BOTH2(WACS_BOARD));
3641     n = show_1_wacs(n, repeat, BOTH2(WACS_LANTERN));
3642     n = show_1_wacs(n, repeat, BOTH2(WACS_BULLET));
3643     n = show_1_wacs(n, repeat, BOTH2(WACS_CKBOARD));
3644     n = show_1_wacs(n, repeat, BOTH2(WACS_DEGREE));
3645     n = show_1_wacs(n, repeat, BOTH2(WACS_DIAMOND));
3646     n = show_1_wacs(n, repeat, BOTH2(WACS_PLMINUS));
3647     n = show_1_wacs(n, repeat, BOTH2(WACS_PLUS));
3648
3649 #ifdef CURSES_WACS_ARRAY
3650     n = show_1_wacs(n, repeat, BOTH2(WACS_GEQUAL));
3651     n = show_1_wacs(n, repeat, BOTH2(WACS_NEQUAL));
3652     n = show_1_wacs(n, repeat, BOTH2(WACS_LEQUAL));
3653
3654     n = show_1_wacs(n, repeat, BOTH2(WACS_STERLING));
3655     n = show_1_wacs(n, repeat, BOTH2(WACS_PI));
3656     n = show_1_wacs(n, repeat, BOTH2(WACS_S1));
3657     n = show_1_wacs(n, repeat, BOTH2(WACS_S3));
3658     n = show_1_wacs(n, repeat, BOTH2(WACS_S7));
3659     (void) show_1_wacs(n, repeat, BOTH2(WACS_S9));
3660 #endif
3661 }
3662
3663 #ifdef WACS_D_PLUS
3664 static void
3665 show_wacs_chars_double(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3666 /* display the wide-ACS character set */
3667 {
3668     cchar_t temp;
3669
3670     int n;
3671
3672 /*#define BOTH2(name) #name, &(name) */
3673 #define BOTH2(name) #name, MERGE_ATTR(name)
3674
3675     erase();
3676     attron(A_BOLD);
3677     MvAddStr(0, 20, "Display of the Wide-ACS Character Set");
3678     attroff(A_BOLD);
3679     refresh();
3680
3681     n = show_1_wacs(0, repeat, BOTH2(WACS_D_ULCORNER));
3682     n = show_1_wacs(n, repeat, BOTH2(WACS_D_URCORNER));
3683     n = show_1_wacs(n, repeat, BOTH2(WACS_D_LLCORNER));
3684     n = show_1_wacs(n, repeat, BOTH2(WACS_D_LRCORNER));
3685
3686     n = show_1_wacs(n, repeat, BOTH2(WACS_D_LTEE));
3687     n = show_1_wacs(n, repeat, BOTH2(WACS_D_RTEE));
3688     n = show_1_wacs(n, repeat, BOTH2(WACS_D_TTEE));
3689     n = show_1_wacs(n, repeat, BOTH2(WACS_D_BTEE));
3690
3691     n = show_1_wacs(n, repeat, BOTH2(WACS_D_HLINE));
3692     n = show_1_wacs(n, repeat, BOTH2(WACS_D_VLINE));
3693
3694     n = show_1_wacs(n, repeat, BOTH2(WACS_LARROW));
3695     n = show_1_wacs(n, repeat, BOTH2(WACS_RARROW));
3696     n = show_1_wacs(n, repeat, BOTH2(WACS_UARROW));
3697     n = show_1_wacs(n, repeat, BOTH2(WACS_DARROW));
3698
3699     n = show_1_wacs(n, repeat, BOTH2(WACS_BLOCK));
3700     n = show_1_wacs(n, repeat, BOTH2(WACS_BOARD));
3701     n = show_1_wacs(n, repeat, BOTH2(WACS_LANTERN));
3702     n = show_1_wacs(n, repeat, BOTH2(WACS_BULLET));
3703     n = show_1_wacs(n, repeat, BOTH2(WACS_CKBOARD));
3704     n = show_1_wacs(n, repeat, BOTH2(WACS_DEGREE));
3705     n = show_1_wacs(n, repeat, BOTH2(WACS_DIAMOND));
3706     n = show_1_wacs(n, repeat, BOTH2(WACS_PLMINUS));
3707     n = show_1_wacs(n, repeat, BOTH2(WACS_PLUS));
3708
3709 #ifdef CURSES_WACS_ARRAY
3710     n = show_1_wacs(n, repeat, BOTH2(WACS_GEQUAL));
3711     n = show_1_wacs(n, repeat, BOTH2(WACS_NEQUAL));
3712     n = show_1_wacs(n, repeat, BOTH2(WACS_LEQUAL));
3713
3714     n = show_1_wacs(n, repeat, BOTH2(WACS_STERLING));
3715     n = show_1_wacs(n, repeat, BOTH2(WACS_PI));
3716     n = show_1_wacs(n, repeat, BOTH2(WACS_S1));
3717     n = show_1_wacs(n, repeat, BOTH2(WACS_S3));
3718     n = show_1_wacs(n, repeat, BOTH2(WACS_S7));
3719     (void) show_1_wacs(n, repeat, BOTH2(WACS_S9));
3720 #endif
3721 }
3722 #endif
3723
3724 #ifdef WACS_T_PLUS
3725 static void
3726 show_wacs_chars_thick(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3727 /* display the wide-ACS character set */
3728 {
3729     cchar_t temp;
3730
3731     int n;
3732
3733 /*#define BOTH2(name) #name, &(name) */
3734 #define BOTH2(name) #name, MERGE_ATTR(name)
3735
3736     erase();
3737     attron(A_BOLD);
3738     MvAddStr(0, 20, "Display of the Wide-ACS Character Set");
3739     attroff(A_BOLD);
3740     refresh();
3741
3742     n = show_1_wacs(0, repeat, BOTH2(WACS_T_ULCORNER));
3743     n = show_1_wacs(n, repeat, BOTH2(WACS_T_URCORNER));
3744     n = show_1_wacs(n, repeat, BOTH2(WACS_T_LLCORNER));
3745     n = show_1_wacs(n, repeat, BOTH2(WACS_T_LRCORNER));
3746
3747     n = show_1_wacs(n, repeat, BOTH2(WACS_T_LTEE));
3748     n = show_1_wacs(n, repeat, BOTH2(WACS_T_RTEE));
3749     n = show_1_wacs(n, repeat, BOTH2(WACS_T_TTEE));
3750     n = show_1_wacs(n, repeat, BOTH2(WACS_T_BTEE));
3751
3752     n = show_1_wacs(n, repeat, BOTH2(WACS_T_HLINE));
3753     n = show_1_wacs(n, repeat, BOTH2(WACS_T_VLINE));
3754
3755     n = show_1_wacs(n, repeat, BOTH2(WACS_LARROW));
3756     n = show_1_wacs(n, repeat, BOTH2(WACS_RARROW));
3757     n = show_1_wacs(n, repeat, BOTH2(WACS_UARROW));
3758     n = show_1_wacs(n, repeat, BOTH2(WACS_DARROW));
3759
3760     n = show_1_wacs(n, repeat, BOTH2(WACS_BLOCK));
3761     n = show_1_wacs(n, repeat, BOTH2(WACS_BOARD));
3762     n = show_1_wacs(n, repeat, BOTH2(WACS_LANTERN));
3763     n = show_1_wacs(n, repeat, BOTH2(WACS_BULLET));
3764     n = show_1_wacs(n, repeat, BOTH2(WACS_CKBOARD));
3765     n = show_1_wacs(n, repeat, BOTH2(WACS_DEGREE));
3766     n = show_1_wacs(n, repeat, BOTH2(WACS_DIAMOND));
3767     n = show_1_wacs(n, repeat, BOTH2(WACS_PLMINUS));
3768     n = show_1_wacs(n, repeat, BOTH2(WACS_PLUS));
3769
3770 #ifdef CURSES_WACS_ARRAY
3771     n = show_1_wacs(n, repeat, BOTH2(WACS_GEQUAL));
3772     n = show_1_wacs(n, repeat, BOTH2(WACS_NEQUAL));
3773     n = show_1_wacs(n, repeat, BOTH2(WACS_LEQUAL));
3774
3775     n = show_1_wacs(n, repeat, BOTH2(WACS_STERLING));
3776     n = show_1_wacs(n, repeat, BOTH2(WACS_PI));
3777     n = show_1_wacs(n, repeat, BOTH2(WACS_S1));
3778     n = show_1_wacs(n, repeat, BOTH2(WACS_S3));
3779     n = show_1_wacs(n, repeat, BOTH2(WACS_S7));
3780     (void) show_1_wacs(n, repeat, BOTH2(WACS_S9));
3781 #endif
3782 }
3783 #endif
3784
3785 #undef MERGE_ATTR
3786
3787 #define MERGE_ATTR(n,wch) merge_wide_attr(&temp[n], wch, attr, pair)
3788
3789 static void
3790 show_wbox_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3791 {
3792     cchar_t temp[8];
3793
3794     (void) repeat;
3795     erase();
3796     attron(A_BOLD);
3797     MvAddStr(0, 20, "Display of the Wide-ACS Line-Drawing Set");
3798     attroff(A_BOLD);
3799     refresh();
3800
3801     wborder_set(stdscr,
3802                 MERGE_ATTR(0, WACS_VLINE),
3803                 MERGE_ATTR(1, WACS_VLINE),
3804                 MERGE_ATTR(2, WACS_HLINE),
3805                 MERGE_ATTR(3, WACS_HLINE),
3806                 MERGE_ATTR(4, WACS_ULCORNER),
3807                 MERGE_ATTR(5, WACS_URCORNER),
3808                 MERGE_ATTR(6, WACS_LLCORNER),
3809                 MERGE_ATTR(7, WACS_LRCORNER));
3810     /* *INDENT-OFF* */
3811     (void) mvhline_set(LINES / 2, 0,        MERGE_ATTR(0, WACS_HLINE), COLS);
3812     (void) mvvline_set(0,         COLS / 2, MERGE_ATTR(0, WACS_VLINE), LINES);
3813     (void) mvadd_wch(0,           COLS / 2, MERGE_ATTR(0, WACS_TTEE));
3814     (void) mvadd_wch(LINES / 2,   COLS / 2, MERGE_ATTR(0, WACS_PLUS));
3815     (void) mvadd_wch(LINES - 1,   COLS / 2, MERGE_ATTR(0, WACS_BTEE));
3816     (void) mvadd_wch(LINES / 2,   0,        MERGE_ATTR(0, WACS_LTEE));
3817     (void) mvadd_wch(LINES / 2,   COLS - 1, MERGE_ATTR(0, WACS_RTEE));
3818     /* *INDENT-ON* */
3819
3820 }
3821
3822 #undef MERGE_ATTR
3823
3824 static int
3825 show_2_wacs(int n, const char *name, const char *code, attr_t attr, NCURSES_PAIRS_T pair)
3826 {
3827     const int height = 16;
3828     int row = 2 + (n % height);
3829     int col = (n / height) * COLS / 2;
3830     char temp[80];
3831
3832     MvPrintw(row, col, "%*s : ", COLS / 4, name);
3833     (void) attr_set(attr, pair, 0);
3834     addstr(strncpy(temp, code, 20));
3835     (void) attr_set(A_NORMAL, 0, 0);
3836     return n + 1;
3837 }
3838
3839 #define SHOW_UTF8(n, name, code) show_2_wacs(n, name, code, attr, pair)
3840
3841 static void
3842 show_utf8_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3843 {
3844     int n;
3845
3846     (void) repeat;
3847     erase();
3848     attron(A_BOLD);
3849     MvAddStr(0, 20, "Display of the Wide-ACS Character Set");
3850     attroff(A_BOLD);
3851     refresh();
3852     /* *INDENT-OFF* */
3853     n = SHOW_UTF8(0, "WACS_ULCORNER",   "\342\224\214");
3854     n = SHOW_UTF8(n, "WACS_URCORNER",   "\342\224\220");
3855     n = SHOW_UTF8(n, "WACS_LLCORNER",   "\342\224\224");
3856     n = SHOW_UTF8(n, "WACS_LRCORNER",   "\342\224\230");
3857
3858     n = SHOW_UTF8(n, "WACS_LTEE",       "\342\224\234");
3859     n = SHOW_UTF8(n, "WACS_RTEE",       "\342\224\244");
3860     n = SHOW_UTF8(n, "WACS_TTEE",       "\342\224\254");
3861     n = SHOW_UTF8(n, "WACS_BTEE",       "\342\224\264");
3862
3863     n = SHOW_UTF8(n, "WACS_HLINE",      "\342\224\200");
3864     n = SHOW_UTF8(n, "WACS_VLINE",      "\342\224\202");
3865
3866     n = SHOW_UTF8(n, "WACS_LARROW",     "\342\206\220");
3867     n = SHOW_UTF8(n, "WACS_RARROW",     "\342\206\222");
3868     n = SHOW_UTF8(n, "WACS_UARROW",     "\342\206\221");
3869     n = SHOW_UTF8(n, "WACS_DARROW",     "\342\206\223");
3870
3871     n = SHOW_UTF8(n, "WACS_BLOCK",      "\342\226\256");
3872     n = SHOW_UTF8(n, "WACS_BOARD",      "\342\226\222");
3873     n = SHOW_UTF8(n, "WACS_LANTERN",    "\342\230\203");
3874     n = SHOW_UTF8(n, "WACS_BULLET",     "\302\267");
3875     n = SHOW_UTF8(n, "WACS_CKBOARD",    "\342\226\222");
3876     n = SHOW_UTF8(n, "WACS_DEGREE",     "\302\260");
3877     n = SHOW_UTF8(n, "WACS_DIAMOND",    "\342\227\206");
3878     n = SHOW_UTF8(n, "WACS_PLMINUS",    "\302\261");
3879     n = SHOW_UTF8(n, "WACS_PLUS",       "\342\224\274");
3880     n = SHOW_UTF8(n, "WACS_GEQUAL",     "\342\211\245");
3881     n = SHOW_UTF8(n, "WACS_NEQUAL",     "\342\211\240");
3882     n = SHOW_UTF8(n, "WACS_LEQUAL",     "\342\211\244");
3883
3884     n = SHOW_UTF8(n, "WACS_STERLING",   "\302\243");
3885     n = SHOW_UTF8(n, "WACS_PI",         "\317\200");
3886     n = SHOW_UTF8(n, "WACS_S1",         "\342\216\272");
3887     n = SHOW_UTF8(n, "WACS_S3",         "\342\216\273");
3888     n = SHOW_UTF8(n, "WACS_S7",         "\342\216\274");
3889     (void) SHOW_UTF8(n, "WACS_S9",      "\342\216\275");
3890     /* *INDENT-ON* */
3891
3892 }
3893
3894 /* display the wide-ACS character set */
3895 static void
3896 wide_acs_display(void)
3897 {
3898     int c = 'a';
3899     int digit = 0;
3900     int repeat = 1;
3901     int space = ' ';
3902     int pagesize = 32;
3903     chtype attr = A_NORMAL;
3904     int fg = COLOR_BLACK;
3905     int bg = COLOR_BLACK;
3906     unsigned at_code = 0;
3907     NCURSES_PAIRS_T pair = 0;
3908     void (*last_show_wacs) (int, attr_t, NCURSES_PAIRS_T) = 0;
3909     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
3910     unsigned my_size = init_attr_list(my_list, term_attrs());
3911
3912     do {
3913         switch (c) {
3914         case CTRL('L'):
3915             Repaint();
3916             break;
3917         case 'a':
3918             ToggleAcs(last_show_wacs, show_wacs_chars);
3919             break;
3920 #ifdef WACS_D_PLUS
3921         case 'd':
3922             ToggleAcs(last_show_wacs, show_wacs_chars_double);
3923             break;
3924 #endif
3925 #ifdef WACS_T_PLUS
3926         case 't':
3927             ToggleAcs(last_show_wacs, show_wacs_chars_thick);
3928             break;
3929 #endif
3930         case 'w':
3931             if (pagesize == 32) {
3932                 pagesize = 256;
3933             } else {
3934                 pagesize = 32;
3935             }
3936             break;
3937         case 'x':
3938             ToggleAcs(last_show_wacs, show_wbox_chars);
3939             break;
3940         case 'u':
3941             ToggleAcs(last_show_wacs, show_utf8_chars);
3942             break;
3943         default:
3944             if (c < 256 && isdigit(c)) {
3945                 digit = (c - '0');
3946                 last_show_wacs = 0;
3947             } else if (c == '+') {
3948                 ++digit;
3949                 last_show_wacs = 0;
3950             } else if (c == '-' && digit > 0) {
3951                 --digit;
3952                 last_show_wacs = 0;
3953             } else if (c == '>' && repeat < (COLS / 4)) {
3954                 ++repeat;
3955             } else if (c == '<' && repeat > 1) {
3956                 --repeat;
3957             } else if (c == '_') {
3958                 space = (space == ' ') ? '_' : ' ';
3959                 last_show_wacs = 0;
3960             } else if (cycle_attr(c, &at_code, &attr, my_list, my_size)
3961                        || cycle_colors(c, &fg, &bg, &pair)) {
3962                 if (last_show_wacs != 0)
3963                     break;
3964             } else {
3965                 beep();
3966                 break;
3967             }
3968             break;
3969         }
3970         if (pagesize != 32) {
3971             show_paged_widechars(digit, pagesize, repeat, space, attr, pair);
3972         } else if (last_show_wacs != 0) {
3973             last_show_wacs(repeat, attr, pair);
3974         } else {
3975             show_upper_widechars(digit * 32 + 128, repeat, space, attr, pair);
3976         }
3977
3978         MvPrintw(LINES - 4, 0,
3979                  "Select: a/d/t WACS, w=all x=box, u UTF-8, ^L repaint");
3980         MvPrintw(LINES - 3, 2,
3981                  "0-9,+/- non-ASCII, </> repeat, _ space, ESC=quit");
3982         if (use_colors) {
3983             MvPrintw(LINES - 2, 2,
3984                      "v/V, f/F, b/B cycle through video attributes (%s) and color %d/%d.",
3985                      my_list[at_code].name,
3986                      fg, bg);
3987         } else {
3988             MvPrintw(LINES - 2, 2,
3989                      "v/V cycles through video attributes (%s).",
3990                      my_list[at_code].name);
3991         }
3992         refresh();
3993     } while (!isQuit(c = Getchar()));
3994
3995     Pause();
3996     erase();
3997     endwin();
3998 }
3999
4000 #endif
4001
4002 /*
4003  * Graphic-rendition test (adapted from vttest)
4004  */
4005 static void
4006 test_sgr_attributes(void)
4007 {
4008     int pass;
4009
4010     for (pass = 0; pass < 2; pass++) {
4011         chtype normal = ((pass == 0 ? A_NORMAL : A_REVERSE)) | BLANK;
4012
4013         /* Use non-default colors if possible to exercise bce a little */
4014         if (use_colors) {
4015             init_pair(1, COLOR_WHITE, COLOR_BLUE);
4016             normal |= (chtype) COLOR_PAIR(1);
4017         }
4018         bkgdset(normal);
4019         erase();
4020         MvPrintw(1, 20, "Graphic rendition test pattern:");
4021
4022         MvPrintw(4, 1, "vanilla");
4023
4024 #define set_sgr(mask) bkgdset((normal^(mask)));
4025         set_sgr(A_BOLD);
4026         MvPrintw(4, 40, "bold");
4027
4028         set_sgr(A_UNDERLINE);
4029         MvPrintw(6, 6, "underline");
4030
4031         set_sgr(A_BOLD | A_UNDERLINE);
4032         MvPrintw(6, 45, "bold underline");
4033
4034         set_sgr(A_BLINK);
4035         MvPrintw(8, 1, "blink");
4036
4037         set_sgr(A_BLINK | A_BOLD);
4038         MvPrintw(8, 40, "bold blink");
4039
4040         set_sgr(A_UNDERLINE | A_BLINK);
4041         MvPrintw(10, 6, "underline blink");
4042
4043         set_sgr(A_BOLD | A_UNDERLINE | A_BLINK);
4044         MvPrintw(10, 45, "bold underline blink");
4045
4046         set_sgr(A_REVERSE);
4047         MvPrintw(12, 1, "negative");
4048
4049         set_sgr(A_BOLD | A_REVERSE);
4050         MvPrintw(12, 40, "bold negative");
4051
4052         set_sgr(A_UNDERLINE | A_REVERSE);
4053         MvPrintw(14, 6, "underline negative");
4054
4055         set_sgr(A_BOLD | A_UNDERLINE | A_REVERSE);
4056         MvPrintw(14, 45, "bold underline negative");
4057
4058         set_sgr(A_BLINK | A_REVERSE);
4059         MvPrintw(16, 1, "blink negative");
4060
4061         set_sgr(A_BOLD | A_BLINK | A_REVERSE);
4062         MvPrintw(16, 40, "bold blink negative");
4063
4064         set_sgr(A_UNDERLINE | A_BLINK | A_REVERSE);
4065         MvPrintw(18, 6, "underline blink negative");
4066
4067         set_sgr(A_BOLD | A_UNDERLINE | A_BLINK | A_REVERSE);
4068         MvPrintw(18, 45, "bold underline blink negative");
4069
4070         bkgdset(normal);
4071         MvPrintw(LINES - 2, 1, "%s background. ", pass == 0 ? "Dark" :
4072                  "Light");
4073         clrtoeol();
4074         Pause();
4075     }
4076
4077     bkgdset(A_NORMAL | BLANK);
4078     erase();
4079     endwin();
4080 }
4081
4082 /****************************************************************************
4083  *
4084  * Windows and scrolling tester.
4085  *
4086  ****************************************************************************/
4087
4088 #define BOTLINES        4       /* number of line stolen from screen bottom */
4089
4090 typedef struct {
4091     int y, x;
4092 } pair;
4093
4094 #define FRAME struct frame
4095 FRAME
4096 {
4097     FRAME *next, *last;
4098     bool do_scroll;
4099     bool do_keypad;
4100     WINDOW *wind;
4101 };
4102
4103 #if defined(NCURSES_VERSION)
4104 #if (NCURSES_VERSION_PATCH < 20070331) && NCURSES_EXT_FUNCS
4105 #define is_keypad(win)   (win)->_use_keypad
4106 #define is_scrollok(win) (win)->_scroll
4107 #elif !defined(is_keypad)
4108 #define is_keypad(win)   FALSE
4109 #define is_scrollok(win) FALSE
4110 #endif
4111 #else
4112 #define is_keypad(win)   FALSE
4113 #define is_scrollok(win) FALSE
4114 #endif
4115
4116 static WINDOW *
4117 frame_win(FRAME * curp)
4118 {
4119     return (curp != 0) ? curp->wind : stdscr;
4120 }
4121
4122 /* We need to know if these flags are actually set, so don't look in FRAME.
4123  * These names are known to work with SVr4 curses as well as ncurses.  The
4124  * _use_keypad name does not work with Solaris 8.
4125  */
4126 static bool
4127 HaveKeypad(FRAME * curp)
4128 {
4129     WINDOW *win = frame_win(curp);
4130     (void) win;
4131     return is_keypad(win);
4132 }
4133
4134 static bool
4135 HaveScroll(FRAME * curp)
4136 {
4137     WINDOW *win = frame_win(curp);
4138     (void) win;
4139     return is_scrollok(win);
4140 }
4141
4142 static void
4143 newwin_legend(FRAME * curp)
4144 {
4145     static const struct {
4146         const char *msg;
4147         int code;
4148     } legend[] = {
4149         {
4150             "^C = create window", 0
4151         },
4152         {
4153             "^N = next window", 0
4154         },
4155         {
4156             "^P = previous window", 0
4157         },
4158         {
4159             "^F = scroll forward", 0
4160         },
4161         {
4162             "^B = scroll backward", 0
4163         },
4164         {
4165             "^K = keypad(%s)", 1
4166         },
4167         {
4168             "^S = scrollok(%s)", 2
4169         },
4170         {
4171             "^W = save window to file", 0
4172         },
4173         {
4174             "^R = restore window", 0
4175         },
4176 #if HAVE_WRESIZE
4177         {
4178             "^X = resize", 0
4179         },
4180 #endif
4181         {
4182             "^Q%s = exit", 3
4183         }
4184     };
4185     size_t n;
4186     int x;
4187     bool do_keypad = HaveKeypad(curp);
4188     bool do_scroll = HaveScroll(curp);
4189     char buf[BUFSIZ];
4190
4191     move(LINES - 4, 0);
4192     for (n = 0; n < SIZEOF(legend); n++) {
4193         switch (legend[n].code) {
4194         default:
4195             strcpy(buf, legend[n].msg);
4196             break;
4197         case 1:
4198             sprintf(buf, legend[n].msg, do_keypad ? "yes" : "no");
4199             break;
4200         case 2:
4201             sprintf(buf, legend[n].msg, do_scroll ? "yes" : "no");
4202             break;
4203         case 3:
4204             sprintf(buf, legend[n].msg, do_keypad ? "/ESC" : "");
4205             break;
4206         }
4207         x = getcurx(stdscr);
4208         addstr((COLS < (x + 3 + (int) strlen(buf))) ? "\n" : (n ? ", " : ""));
4209         addstr(buf);
4210     }
4211     clrtoeol();
4212 }
4213
4214 static void
4215 transient(FRAME * curp, NCURSES_CONST char *msg)
4216 {
4217     newwin_legend(curp);
4218     if (msg) {
4219         MvAddStr(LINES - 1, 0, msg);
4220         refresh();
4221         napms(1000);
4222     }
4223
4224     move(LINES - 1, 0);
4225     printw("%s characters are echoed, window should %sscroll.",
4226            HaveKeypad(curp) ? "Non-arrow" : "All other",
4227            HaveScroll(curp) ? "" : "not ");
4228     clrtoeol();
4229 }
4230
4231 static void
4232 newwin_report(FRAME * curp)
4233 /* report on the cursor's current position, then restore it */
4234 {
4235     WINDOW *win = frame_win(curp);
4236     int y, x;
4237
4238     if (win != stdscr)
4239         transient(curp, (char *) 0);
4240     getyx(win, y, x);
4241     move(LINES - 1, COLS - 17);
4242     printw("Y = %2d X = %2d", y, x);
4243     if (win != stdscr)
4244         refresh();
4245     else
4246         wmove(win, y, x);
4247 }
4248
4249 static pair *
4250 selectcell(int uli, int ulj, int lri, int lrj)
4251 /* arrows keys move cursor, return location at current on non-arrow key */
4252 {
4253     static pair res;            /* result cell */
4254     int si = lri - uli + 1;     /* depth of the select area */
4255     int sj = lrj - ulj + 1;     /* width of the select area */
4256     int i = 0, j = 0;           /* offsets into the select area */
4257
4258     res.y = uli;
4259     res.x = ulj;
4260     for (;;) {
4261         move(uli + i, ulj + j);
4262         newwin_report((FRAME *) 0);
4263
4264         switch (Getchar()) {
4265         case KEY_UP:
4266             i += si - 1;
4267             break;
4268         case KEY_DOWN:
4269             i++;
4270             break;
4271         case KEY_LEFT:
4272             j += sj - 1;
4273             break;
4274         case KEY_RIGHT:
4275             j++;
4276             break;
4277         case case_QUIT:
4278             return ((pair *) 0);
4279 #ifdef NCURSES_MOUSE_VERSION
4280         case KEY_MOUSE:
4281             {
4282                 MEVENT event;
4283
4284                 getmouse(&event);
4285                 if (event.y > uli && event.x > ulj) {
4286                     i = event.y - uli;
4287                     j = event.x - ulj;
4288                 } else {
4289                     beep();
4290                     break;
4291                 }
4292             }
4293             /* FALLTHRU */
4294 #endif
4295         default:
4296             res.y = uli + i;
4297             res.x = ulj + j;
4298             return (&res);
4299         }
4300         i %= si;
4301         j %= sj;
4302     }
4303 }
4304
4305 static void
4306 outerbox(pair ul, pair lr, bool onoff)
4307 /* draw or erase a box *outside* the given pair of corners */
4308 {
4309     MvAddCh(ul.y - 1, lr.x - 1, onoff ? ACS_ULCORNER : ' ');
4310     MvAddCh(ul.y - 1, lr.x + 1, onoff ? ACS_URCORNER : ' ');
4311     MvAddCh(lr.y + 1, lr.x + 1, onoff ? ACS_LRCORNER : ' ');
4312     MvAddCh(lr.y + 1, ul.x - 1, onoff ? ACS_LLCORNER : ' ');
4313     move(ul.y - 1, ul.x);
4314     hline(onoff ? ACS_HLINE : ' ', lr.x - ul.x + 1);
4315     move(ul.y, ul.x - 1);
4316     vline(onoff ? ACS_VLINE : ' ', lr.y - ul.y + 1);
4317     move(lr.y + 1, ul.x);
4318     hline(onoff ? ACS_HLINE : ' ', lr.x - ul.x + 1);
4319     move(ul.y, lr.x + 1);
4320     vline(onoff ? ACS_VLINE : ' ', lr.y - ul.y + 1);
4321 }
4322
4323 static WINDOW *
4324 getwindow(void)
4325 /* Ask user for a window definition */
4326 {
4327     WINDOW *rwindow;
4328     pair ul, lr, *tmp;
4329
4330     move(0, 0);
4331     clrtoeol();
4332     addstr("Use arrows to move cursor, anything else to mark corner 1");
4333     refresh();
4334     if ((tmp = selectcell(2, 1, LINES - BOTLINES - 2, COLS - 2)) == (pair *) 0)
4335         return ((WINDOW *) 0);
4336     memcpy(&ul, tmp, sizeof(pair));
4337     MvAddCh(ul.y - 1, ul.x - 1, ACS_ULCORNER);
4338     move(0, 0);
4339     clrtoeol();
4340     addstr("Use arrows to move cursor, anything else to mark corner 2");
4341     refresh();
4342     if ((tmp = selectcell(ul.y, ul.x, LINES - BOTLINES - 2, COLS - 2)) ==
4343         (pair *) 0)
4344         return ((WINDOW *) 0);
4345     memcpy(&lr, tmp, sizeof(pair));
4346
4347     rwindow = subwin(stdscr, lr.y - ul.y + 1, lr.x - ul.x + 1, ul.y, ul.x);
4348
4349     outerbox(ul, lr, TRUE);
4350     refresh();
4351
4352     if (rwindow != 0)
4353         wrefresh(rwindow);
4354
4355     move(0, 0);
4356     clrtoeol();
4357     return (rwindow);
4358 }
4359
4360 static void
4361 newwin_move(FRAME * curp, int dy, int dx)
4362 {
4363     WINDOW *win = frame_win(curp);
4364     int cur_y, cur_x;
4365     int max_y, max_x;
4366
4367     getyx(win, cur_y, cur_x);
4368     getmaxyx(win, max_y, max_x);
4369     if ((cur_x += dx) < 0)
4370         cur_x = 0;
4371     else if (cur_x >= max_x)
4372         cur_x = max_x - 1;
4373     if ((cur_y += dy) < 0)
4374         cur_y = 0;
4375     else if (cur_y >= max_y)
4376         cur_y = max_y - 1;
4377     wmove(win, cur_y, cur_x);
4378 }
4379
4380 static FRAME *
4381 delete_framed(FRAME * fp, bool showit)
4382 {
4383     FRAME *np = 0;
4384
4385     if (fp != 0) {
4386         fp->last->next = fp->next;
4387         fp->next->last = fp->last;
4388
4389         if (showit) {
4390             werase(fp->wind);
4391             wrefresh(fp->wind);
4392         }
4393         delwin(fp->wind);
4394
4395         np = (fp == fp->next) ? 0 : fp->next;
4396         free(fp);
4397     }
4398     return np;
4399 }
4400
4401 static void
4402 acs_and_scroll(void)
4403 /* Demonstrate windows */
4404 {
4405     int c;
4406     FRAME *current = (FRAME *) 0, *neww;
4407     WINDOW *usescr;
4408 #if HAVE_PUTWIN && HAVE_GETWIN
4409     FILE *fp;
4410 #endif
4411
4412 #define DUMPFILE        "screendump"
4413
4414 #ifdef NCURSES_MOUSE_VERSION
4415     mousemask(BUTTON1_CLICKED, (mmask_t *) 0);
4416 #endif
4417     c = CTRL('C');
4418     raw();
4419     do {
4420         transient((FRAME *) 0, (char *) 0);
4421         switch (c) {
4422         case CTRL('C'):
4423             if ((neww = typeCalloc(FRAME, (size_t) 1)) == 0) {
4424                 failed("acs_and_scroll");
4425                 goto breakout;
4426             }
4427             if ((neww->wind = getwindow()) == (WINDOW *) 0) {
4428                 failed("acs_and_scroll");
4429                 free(neww);
4430                 goto breakout;
4431             }
4432
4433             if (current == 0) { /* First element,  */
4434                 neww->next = neww;      /*   so point it at itself */
4435                 neww->last = neww;
4436             } else {
4437                 neww->next = current->next;
4438                 neww->last = current;
4439                 neww->last->next = neww;
4440                 neww->next->last = neww;
4441             }
4442             current = neww;
4443             /* SVr4 curses sets the keypad on all newly-created windows to
4444              * false.  Someone reported that PDCurses makes new windows inherit
4445              * this flag.  Remove the following 'keypad()' call to test this
4446              */
4447             keypad(current->wind, TRUE);
4448             current->do_keypad = HaveKeypad(current);
4449             current->do_scroll = HaveScroll(current);
4450             break;
4451
4452         case CTRL('N'): /* go to next window */
4453             if (current)
4454                 current = current->next;
4455             break;
4456
4457         case CTRL('P'): /* go to previous window */
4458             if (current)
4459                 current = current->last;
4460             break;
4461
4462         case CTRL('F'): /* scroll current window forward */
4463             if (current)
4464                 wscrl(frame_win(current), 1);
4465             break;
4466
4467         case CTRL('B'): /* scroll current window backwards */
4468             if (current)
4469                 wscrl(frame_win(current), -1);
4470             break;
4471
4472         case CTRL('K'): /* toggle keypad mode for current */
4473             if (current) {
4474                 current->do_keypad = !current->do_keypad;
4475                 keypad(current->wind, current->do_keypad);
4476             }
4477             break;
4478
4479         case CTRL('S'):
4480             if (current) {
4481                 current->do_scroll = !current->do_scroll;
4482                 scrollok(current->wind, current->do_scroll);
4483             }
4484             break;
4485
4486 #if HAVE_PUTWIN && HAVE_GETWIN
4487         case CTRL('W'): /* save and delete window */
4488             if ((current != 0) && (current == current->next)) {