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.397 2014/02/01 22:29:37 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     MvWPrintw(helpwin, row++, col,
2002               "  n/N     toggle text/number on/off");
2003     MvWPrintw(helpwin, row++, col,
2004               "  r/R     toggle reverse on/off");
2005     MvWPrintw(helpwin, row++, col,
2006               "  w/W     toggle width between 8/16 colors");
2007 #if USE_WIDEC_SUPPORT
2008     if (wide) {
2009         MvWPrintw(helpwin, row++, col,
2010                   "Wide characters:");
2011         MvWPrintw(helpwin, row, col,
2012                   "  x/X     toggle text between ASCII and wide-character");
2013     }
2014 #else
2015     (void) wide;
2016 #endif
2017 }
2018
2019 #define set_color_test(name, value) if (name != value) { name = value; base_row = 0; }
2020
2021 /* generate a color test pattern */
2022 static void
2023 color_test(void)
2024 {
2025     NCURSES_PAIRS_T i;
2026     int top = 0, width;
2027     int base_row = 0;
2028     int grid_top = top + 3;
2029     int page_size = (LINES - grid_top);
2030     int pairs_max = PAIR_NUMBER(A_COLOR) + 1;
2031     int row_limit;
2032     int per_row;
2033     char numbered[80];
2034     const char *hello;
2035     bool done = FALSE;
2036     bool opt_acsc = FALSE;
2037     bool opt_bold = FALSE;
2038     bool opt_revs = FALSE;
2039     bool opt_nums = FALSE;
2040     bool opt_wide = FALSE;
2041     WINDOW *helpwin;
2042
2043     if (COLORS * COLORS == COLOR_PAIRS) {
2044         int limit = (COLORS - min_colors) * (COLORS - min_colors);
2045         if (pairs_max > limit)
2046             pairs_max = limit;
2047     } else {
2048         if (pairs_max > COLOR_PAIRS)
2049             pairs_max = COLOR_PAIRS;
2050     }
2051
2052     while (!done) {
2053         int shown = 0;
2054
2055         /* this assumes an 80-column line */
2056         if (opt_wide) {
2057             width = 4;
2058             hello = "Test";
2059             per_row = (COLORS > 8) ? 16 : 8;
2060         } else {
2061             width = 8;
2062             hello = "Hello";
2063             per_row = 8;
2064         }
2065         per_row -= min_colors;
2066
2067         row_limit = (pairs_max + per_row - 1) / per_row;
2068
2069         move(0, 0);
2070         (void) printw("There are %d color pairs and %d colors%s\n",
2071                       pairs_max, COLORS,
2072                       min_colors ? " besides 'default'" : "");
2073
2074         clrtobot();
2075         MvPrintw(top + 1, 0,
2076                  "%dx%d matrix of foreground/background colors, bold *%s*\n",
2077                  row_limit,
2078                  per_row,
2079                  opt_bold ? "on" : "off");
2080
2081         /* show color names/numbers across the top */
2082         for (i = 0; i < per_row; i++)
2083             show_color_name(top + 2, (i + 1) * width, i + min_colors, opt_wide);
2084
2085         /* show a grid of colors, with color names/ numbers on the left */
2086         for (i = (NCURSES_PAIRS_T) (base_row * per_row); i < pairs_max; i++) {
2087             int row = grid_top + (i / per_row) - base_row;
2088             int col = (i % per_row + 1) * width;
2089             NCURSES_PAIRS_T pair = i;
2090
2091 #define InxToFG(i) (NCURSES_COLOR_T) ((i % (COLORS - min_colors)) + min_colors)
2092 #define InxToBG(i) (NCURSES_COLOR_T) ((i / (COLORS - min_colors)) + min_colors)
2093             if (row >= 0 && move(row, col) != ERR) {
2094                 NCURSES_COLOR_T fg = InxToFG(i);
2095                 NCURSES_COLOR_T bg = InxToBG(i);
2096
2097                 init_pair(pair, fg, bg);
2098                 attron((attr_t) COLOR_PAIR(pair));
2099                 if (opt_acsc)
2100                     attron((attr_t) A_ALTCHARSET);
2101                 if (opt_bold)
2102                     attron((attr_t) A_BOLD);
2103                 if (opt_revs)
2104                     attron((attr_t) A_REVERSE);
2105
2106                 if (opt_nums) {
2107                     sprintf(numbered, "{%02X}", (int) i);
2108                     hello = numbered;
2109                 }
2110                 printw("%-*.*s", width, width, hello);
2111                 (void) attrset(A_NORMAL);
2112
2113                 if ((i % per_row) == 0 && InxToFG(i) == min_colors) {
2114                     show_color_name(row, 0, InxToBG(i), opt_wide);
2115                 }
2116                 ++shown;
2117             } else if (shown) {
2118                 break;
2119             }
2120         }
2121
2122         switch (wGetchar(stdscr)) {
2123         case 'a':
2124             opt_acsc = FALSE;
2125             break;
2126         case 'A':
2127             opt_acsc = TRUE;
2128             break;
2129         case 'b':
2130             opt_bold = FALSE;
2131             break;
2132         case 'B':
2133             opt_bold = TRUE;
2134             break;
2135         case 'n':
2136             opt_nums = FALSE;
2137             break;
2138         case 'N':
2139             opt_nums = TRUE;
2140             break;
2141         case 'r':
2142             opt_revs = FALSE;
2143             break;
2144         case 'R':
2145             opt_revs = TRUE;
2146             break;
2147         case case_QUIT:
2148             done = TRUE;
2149             continue;
2150         case 'w':
2151             set_color_test(opt_wide, FALSE);
2152             break;
2153         case 'W':
2154             set_color_test(opt_wide, TRUE);
2155             break;
2156         case CTRL('p'):
2157         case KEY_UP:
2158             if (base_row <= 0) {
2159                 beep();
2160             } else {
2161                 base_row -= 1;
2162             }
2163             break;
2164         case CTRL('n'):
2165         case KEY_DOWN:
2166             if (base_row + page_size >= row_limit) {
2167                 beep();
2168             } else {
2169                 base_row += 1;
2170             }
2171             break;
2172         case CTRL('b'):
2173         case KEY_PREVIOUS:
2174         case KEY_PPAGE:
2175             if (base_row <= 0) {
2176                 beep();
2177             } else {
2178                 base_row -= (page_size - 1);
2179                 if (base_row < 0)
2180                     base_row = 0;
2181             }
2182             break;
2183         case CTRL('f'):
2184         case KEY_NEXT:
2185         case KEY_NPAGE:
2186             if (base_row + page_size >= row_limit) {
2187                 beep();
2188             } else {
2189                 base_row += page_size - 1;
2190                 if (base_row + page_size >= row_limit) {
2191                     base_row = row_limit - page_size - 1;
2192                 }
2193             }
2194             break;
2195         case '?':
2196             if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
2197                 box(helpwin, 0, 0);
2198                 color_legend(helpwin, FALSE);
2199                 wGetchar(helpwin);
2200                 delwin(helpwin);
2201             }
2202             break;
2203         default:
2204             beep();
2205             continue;
2206         }
2207     }
2208
2209     erase();
2210     endwin();
2211 }
2212
2213 #if USE_WIDEC_SUPPORT
2214 /* generate a color test pattern */
2215 static void
2216 wide_color_test(void)
2217 {
2218     int i;
2219     int top = 0, width;
2220     int base_row = 0;
2221     int grid_top = top + 3;
2222     int page_size = (LINES - grid_top);
2223     int pairs_max = (unsigned short) (-1);
2224     int row_limit;
2225     int per_row;
2226     char numbered[80];
2227     const char *hello;
2228     bool done = FALSE;
2229     bool opt_acsc = FALSE;
2230     bool opt_bold = FALSE;
2231     bool opt_revs = FALSE;
2232     bool opt_wide = FALSE;
2233     bool opt_nums = FALSE;
2234     bool opt_xchr = FALSE;
2235     wchar_t buffer[80];
2236     WINDOW *helpwin;
2237
2238     if (COLORS * COLORS == COLOR_PAIRS) {
2239         int limit = (COLORS - min_colors) * (COLORS - min_colors);
2240         if (pairs_max > limit)
2241             pairs_max = limit;
2242     } else {
2243         if (pairs_max > COLOR_PAIRS)
2244             pairs_max = COLOR_PAIRS;
2245     }
2246
2247     while (!done) {
2248         int shown = 0;
2249
2250         /* this assumes an 80-column line */
2251         if (opt_wide) {
2252             width = 4;
2253             hello = "Test";
2254             per_row = (COLORS > 8) ? 16 : 8;
2255         } else {
2256             width = 8;
2257             hello = "Hello";
2258             per_row = 8;
2259         }
2260         per_row -= min_colors;
2261
2262         if (opt_xchr) {
2263             make_fullwidth_text(buffer, hello);
2264             width *= 2;
2265             per_row /= 2;
2266         } else {
2267             make_narrow_text(buffer, hello);
2268         }
2269
2270         row_limit = (pairs_max + per_row - 1) / per_row;
2271
2272         move(0, 0);
2273         (void) printw("There are %d color pairs and %d colors%s\n",
2274                       pairs_max, COLORS,
2275                       min_colors ? " besides 'default'" : "");
2276
2277         clrtobot();
2278         MvPrintw(top + 1, 0,
2279                  "%dx%d matrix of foreground/background colors, bold *%s*\n",
2280                  row_limit,
2281                  per_row,
2282                  opt_bold ? "on" : "off");
2283
2284         /* show color names/numbers across the top */
2285         for (i = 0; i < per_row; i++)
2286             show_color_name(top + 2, (i + 1) * width, i + min_colors, opt_wide);
2287
2288         /* show a grid of colors, with color names/ numbers on the left */
2289         for (i = (base_row * per_row); i < pairs_max; i++) {
2290             int row = grid_top + (i / per_row) - base_row;
2291             int col = (i % per_row + 1) * width;
2292             NCURSES_PAIRS_T pair = (NCURSES_PAIRS_T) i;
2293
2294             if (row >= 0 && move(row, col) != ERR) {
2295                 init_pair(pair, InxToFG(i), InxToBG(i));
2296                 (void) color_set(pair, NULL);
2297                 if (opt_acsc)
2298                     attr_on((attr_t) A_ALTCHARSET, NULL);
2299                 if (opt_bold)
2300                     attr_on((attr_t) A_BOLD, NULL);
2301                 if (opt_revs)
2302                     attr_on((attr_t) A_REVERSE, NULL);
2303
2304                 if (opt_nums) {
2305                     sprintf(numbered, "{%02X}", i);
2306                     if (opt_xchr) {
2307                         make_fullwidth_text(buffer, numbered);
2308                     } else {
2309                         make_narrow_text(buffer, numbered);
2310                     }
2311                 }
2312                 addnwstr(buffer, width);
2313                 (void) attr_set(A_NORMAL, 0, NULL);
2314
2315                 if ((i % per_row) == 0 && InxToFG(i) == min_colors) {
2316                     show_color_name(row, 0, InxToBG(i), opt_wide);
2317                 }
2318                 ++shown;
2319             } else if (shown) {
2320                 break;
2321             }
2322         }
2323
2324         switch (wGetchar(stdscr)) {
2325         case 'a':
2326             opt_acsc = FALSE;
2327             break;
2328         case 'A':
2329             opt_acsc = TRUE;
2330             break;
2331         case 'b':
2332             opt_bold = FALSE;
2333             break;
2334         case 'B':
2335             opt_bold = TRUE;
2336             break;
2337         case 'n':
2338             opt_nums = FALSE;
2339             break;
2340         case 'N':
2341             opt_nums = TRUE;
2342             break;
2343         case 'r':
2344             opt_revs = FALSE;
2345             break;
2346         case 'R':
2347             opt_revs = TRUE;
2348             break;
2349         case case_QUIT:
2350             done = TRUE;
2351             continue;
2352         case 'w':
2353             set_color_test(opt_wide, FALSE);
2354             break;
2355         case 'W':
2356             set_color_test(opt_wide, TRUE);
2357             break;
2358         case 'x':
2359             opt_xchr = FALSE;
2360             break;
2361         case 'X':
2362             opt_xchr = TRUE;
2363             break;
2364         case CTRL('p'):
2365         case KEY_UP:
2366             if (base_row <= 0) {
2367                 beep();
2368             } else {
2369                 base_row -= 1;
2370             }
2371             break;
2372         case CTRL('n'):
2373         case KEY_DOWN:
2374             if (base_row + page_size >= row_limit) {
2375                 beep();
2376             } else {
2377                 base_row += 1;
2378             }
2379             break;
2380         case CTRL('b'):
2381         case KEY_PREVIOUS:
2382         case KEY_PPAGE:
2383             if (base_row <= 0) {
2384                 beep();
2385             } else {
2386                 base_row -= (page_size - 1);
2387                 if (base_row < 0)
2388                     base_row = 0;
2389             }
2390             break;
2391         case CTRL('f'):
2392         case KEY_NEXT:
2393         case KEY_NPAGE:
2394             if (base_row + page_size >= row_limit) {
2395                 beep();
2396             } else {
2397                 base_row += page_size - 1;
2398                 if (base_row + page_size >= row_limit) {
2399                     base_row = row_limit - page_size - 1;
2400                 }
2401             }
2402             break;
2403         case '?':
2404             if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
2405                 box(helpwin, 0, 0);
2406                 color_legend(helpwin, TRUE);
2407                 wGetchar(helpwin);
2408                 delwin(helpwin);
2409             }
2410             break;
2411         default:
2412             beep();
2413             continue;
2414         }
2415     }
2416
2417     erase();
2418     endwin();
2419 }
2420 #endif /* USE_WIDEC_SUPPORT */
2421
2422 static void
2423 change_color(NCURSES_PAIRS_T current, int field, int value, int usebase)
2424 {
2425     NCURSES_COLOR_T red, green, blue;
2426
2427     color_content(current, &red, &green, &blue);
2428
2429     switch (field) {
2430     case 0:
2431         red = (NCURSES_COLOR_T) (usebase ? (red + value) : value);
2432         break;
2433     case 1:
2434         green = (NCURSES_COLOR_T) (usebase ? (green + value) : value);
2435         break;
2436     case 2:
2437         blue = (NCURSES_COLOR_T) (usebase ? (blue + value) : value);
2438         break;
2439     }
2440
2441     if (init_color(current, red, green, blue) == ERR)
2442         beep();
2443 }
2444
2445 static void
2446 init_all_colors(void)
2447 {
2448     NCURSES_PAIRS_T c;
2449
2450     for (c = 0; c < COLORS; ++c)
2451         init_color(c,
2452                    all_colors[c].red,
2453                    all_colors[c].green,
2454                    all_colors[c].blue);
2455 }
2456
2457 #define scaled_rgb(n) ((255 * (n)) / 1000)
2458
2459 static void
2460 color_edit(void)
2461 /* display the color test pattern, without trying to edit colors */
2462 {
2463     int i;
2464     int current = 0;
2465     int this_c = 0, value = 0, field = 0;
2466     int last_c;
2467     int top_color = 0;
2468     int page_size = (LINES - 6);
2469
2470     init_all_colors();
2471     refresh();
2472
2473     for (i = 0; i < max_colors; i++)
2474         init_pair((NCURSES_PAIRS_T) i,
2475                   (NCURSES_COLOR_T) COLOR_WHITE,
2476                   (NCURSES_COLOR_T) i);
2477
2478     MvPrintw(LINES - 2, 0, "Number: %d", value);
2479
2480     do {
2481         NCURSES_COLOR_T red, green, blue;
2482
2483         attron(A_BOLD);
2484         MvAddStr(0, 20, "Color RGB Value Editing");
2485         attroff(A_BOLD);
2486
2487         for (i = (NCURSES_COLOR_T) top_color;
2488              (i - top_color < page_size)
2489              && (i < max_colors); i++) {
2490             char numeric[80];
2491
2492             sprintf(numeric, "[%d]", i);
2493             MvPrintw(2 + i - top_color, 0, "%c %-8s:",
2494                      (i == current ? '>' : ' '),
2495                      (i < (int) SIZEOF(the_color_names)
2496                       ? the_color_names[i] : numeric));
2497             (void) attrset((attr_t) COLOR_PAIR(i));
2498             addstr("        ");
2499             (void) attrset(A_NORMAL);
2500
2501             color_content((NCURSES_PAIRS_T) i, &red, &green, &blue);
2502             addstr("   R = ");
2503             if (current == i && field == 0)
2504                 attron(A_STANDOUT);
2505             printw("%04d", (int) red);
2506             if (current == i && field == 0)
2507                 (void) attrset(A_NORMAL);
2508             addstr(", G = ");
2509             if (current == i && field == 1)
2510                 attron(A_STANDOUT);
2511             printw("%04d", (int) green);
2512             if (current == i && field == 1)
2513                 (void) attrset(A_NORMAL);
2514             addstr(", B = ");
2515             if (current == i && field == 2)
2516                 attron(A_STANDOUT);
2517             printw("%04d", (int) blue);
2518             if (current == i && field == 2)
2519                 (void) attrset(A_NORMAL);
2520             (void) attrset(A_NORMAL);
2521             printw(" ( %3d %3d %3d )",
2522                    (int) scaled_rgb(red),
2523                    (int) scaled_rgb(green),
2524                    (int) scaled_rgb(blue));
2525         }
2526
2527         MvAddStr(LINES - 3, 0,
2528                  "Use up/down to select a color, left/right to change fields.");
2529         MvAddStr(LINES - 2, 0,
2530                  "Modify field by typing nnn=, nnn-, or nnn+.  ? for help.");
2531
2532         move(2 + current - top_color, 0);
2533
2534         last_c = this_c;
2535         this_c = Getchar();
2536         if (this_c < 256 && isdigit(this_c) && !isdigit(last_c))
2537             value = 0;
2538
2539         switch (this_c) {
2540         case CTRL('b'):
2541         case KEY_PPAGE:
2542             if (current > 0)
2543                 current -= (page_size - 1);
2544             else
2545                 beep();
2546             break;
2547
2548         case CTRL('f'):
2549         case KEY_NPAGE:
2550             if (current < (max_colors - 1))
2551                 current += (page_size - 1);
2552             else
2553                 beep();
2554             break;
2555
2556         case CTRL('p'):
2557         case KEY_UP:
2558             current = (current == 0 ? (max_colors - 1) : current - 1);
2559             break;
2560
2561         case CTRL('n'):
2562         case KEY_DOWN:
2563             current = (current == (max_colors - 1) ? 0 : current + 1);
2564             break;
2565
2566         case KEY_RIGHT:
2567             field = (field == 2 ? 0 : field + 1);
2568             break;
2569
2570         case KEY_LEFT:
2571             field = (field == 0 ? 2 : field - 1);
2572             break;
2573
2574         case '0':
2575         case '1':
2576         case '2':
2577         case '3':
2578         case '4':
2579         case '5':
2580         case '6':
2581         case '7':
2582         case '8':
2583         case '9':
2584             value = value * 10 + (this_c - '0');
2585             break;
2586
2587         case '+':
2588             change_color((NCURSES_PAIRS_T) current, field, value, 1);
2589             break;
2590
2591         case '-':
2592             change_color((NCURSES_PAIRS_T) current, field, -value, 1);
2593             break;
2594
2595         case '=':
2596             change_color((NCURSES_PAIRS_T) current, field, value, 0);
2597             break;
2598
2599         case '?':
2600             erase();
2601             P("                      RGB Value Editing Help");
2602             P("");
2603             P("You are in the RGB value editor.  Use the arrow keys to select one of");
2604             P("the fields in one of the RGB triples of the current colors; the one");
2605             P("currently selected will be reverse-video highlighted.");
2606             P("");
2607             P("To change a field, enter the digits of the new value; they are echoed");
2608             P("as entered.  Finish by typing `='.  The change will take effect instantly.");
2609             P("To increment or decrement a value, use the same procedure, but finish");
2610             P("with a `+' or `-'.");
2611             P("");
2612             P("Press 'm' to invoke the top-level menu with the current color settings.");
2613             P("To quit, do ESC");
2614
2615             Pause();
2616             erase();
2617             break;
2618
2619         case 'm':
2620             endwin();
2621             main_menu(FALSE);
2622             for (i = 0; i < max_colors; i++)
2623                 init_pair((NCURSES_PAIRS_T) i,
2624                           (NCURSES_COLOR_T) COLOR_WHITE,
2625                           (NCURSES_COLOR_T) i);
2626             refresh();
2627             break;
2628
2629         case case_QUIT:
2630             break;
2631
2632         default:
2633             beep();
2634             break;
2635         }
2636
2637         if (current < 0)
2638             current = 0;
2639         if (current >= max_colors)
2640             current = max_colors - 1;
2641         if (current < top_color)
2642             top_color = current;
2643         if (current - top_color >= page_size)
2644             top_color = current - (page_size - 1);
2645
2646         MvPrintw(LINES - 1, 0, "Number: %d", value);
2647         clrtoeol();
2648     } while
2649         (!isQuit(this_c));
2650
2651     erase();
2652
2653     /*
2654      * ncurses does not reset each color individually when calling endwin().
2655      */
2656     init_all_colors();
2657
2658     endwin();
2659 }
2660
2661 /****************************************************************************
2662  *
2663  * Alternate character-set stuff
2664  *
2665  ****************************************************************************/
2666 static bool
2667 cycle_attr(int ch, unsigned *at_code, chtype *attr, ATTR_TBL * list, unsigned limit)
2668 {
2669     bool result = TRUE;
2670
2671     switch (ch) {
2672     case 'v':
2673         if ((*at_code += 1) >= limit)
2674             *at_code = 0;
2675         break;
2676     case 'V':
2677         if (*at_code == 0)
2678             *at_code = limit - 1;
2679         else
2680             *at_code -= 1;
2681         break;
2682     default:
2683         result = FALSE;
2684         break;
2685     }
2686     if (result)
2687         *attr = list[*at_code].attr;
2688     return result;
2689 }
2690
2691 static bool
2692 cycle_colors(int ch, int *fg, int *bg, NCURSES_PAIRS_T *pair)
2693 {
2694     bool result = FALSE;
2695
2696     if (use_colors) {
2697         result = TRUE;
2698         switch (ch) {
2699         case 'F':
2700             if ((*fg -= 1) < 0)
2701                 *fg = COLORS - 1;
2702             break;
2703         case 'f':
2704             if ((*fg += 1) >= COLORS)
2705                 *fg = 0;
2706             break;
2707         case 'B':
2708             if ((*bg -= 1) < 0)
2709                 *bg = COLORS - 1;
2710             break;
2711         case 'b':
2712             if ((*bg += 1) >= COLORS)
2713                 *bg = 0;
2714             break;
2715         default:
2716             result = FALSE;
2717             break;
2718         }
2719         if (result) {
2720             *pair = (NCURSES_PAIRS_T) (*fg != COLOR_BLACK || *bg != COLOR_BLACK);
2721             if (*pair != 0) {
2722                 *pair = 1;
2723                 if (init_pair(*pair,
2724                               (NCURSES_COLOR_T) *fg,
2725                               (NCURSES_COLOR_T) *bg) == ERR) {
2726                     result = FALSE;
2727                 }
2728             }
2729         }
2730     }
2731     return result;
2732 }
2733
2734 /****************************************************************************
2735  *
2736  * Soft-key label test
2737  *
2738  ****************************************************************************/
2739
2740 #if USE_SOFTKEYS
2741
2742 #define SLK_HELP 17
2743 #define SLK_WORK (SLK_HELP + 3)
2744
2745 static void
2746 slk_help(void)
2747 {
2748     static const char *table[] =
2749     {
2750         "Available commands are:"
2751         ,""
2752         ,"^L         -- repaint this message and activate soft keys"
2753         ,"a/d        -- activate/disable soft keys"
2754         ,"c          -- set centered format for labels"
2755         ,"l          -- set left-justified format for labels"
2756         ,"r          -- set right-justified format for labels"
2757         ,"[12345678] -- set label; labels are numbered 1 through 8"
2758         ,"e          -- erase stdscr (should not erase labels)"
2759         ,"s          -- test scrolling of shortened screen"
2760         ,"v/V        -- cycle through video attributes"
2761 #if HAVE_SLK_COLOR
2762         ,"F/f/B/b    -- cycle through foreground/background colors"
2763 #endif
2764         ,"ESC        -- return to main menu"
2765         ,""
2766         ,"Note: if activating the soft keys causes your terminal to scroll up"
2767         ,"one line, your terminal auto-scrolls when anything is written to the"
2768         ,"last screen position.  The ncurses code does not yet handle this"
2769         ,"gracefully."
2770     };
2771     unsigned j;
2772
2773     move(2, 0);
2774     for (j = 0; j < SIZEOF(table); ++j) {
2775         P(table[j]);
2776     }
2777     refresh();
2778 }
2779
2780 #if HAVE_SLK_COLOR
2781 static void
2782 call_slk_color(int fg, int bg)
2783 {
2784     init_pair(1, (NCURSES_COLOR_T) bg, (NCURSES_COLOR_T) fg);
2785     slk_color(1);
2786     MvPrintw(SLK_WORK, 0, "Colors %d/%d\n", fg, bg);
2787     clrtoeol();
2788     slk_touch();
2789     slk_noutrefresh();
2790     refresh();
2791 }
2792 #endif
2793
2794 static void
2795 slk_test(void)
2796 /* exercise the soft keys */
2797 {
2798     int c, fmt = 1;
2799     char buf[9];
2800     char *s;
2801     chtype attr = A_NORMAL;
2802     unsigned at_code = 0;
2803 #if HAVE_SLK_COLOR
2804     int fg = COLOR_BLACK;
2805     int bg = COLOR_WHITE;
2806     NCURSES_PAIRS_T pair = 0;
2807 #endif
2808     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
2809     unsigned my_size = init_attr_list(my_list, termattrs());
2810
2811     c = CTRL('l');
2812 #if HAVE_SLK_COLOR
2813     if (use_colors) {
2814         call_slk_color(fg, bg);
2815     }
2816 #endif
2817
2818     do {
2819         move(0, 0);
2820         switch (c) {
2821         case CTRL('l'):
2822             erase();
2823             attron(A_BOLD);
2824             MvAddStr(0, 20, "Soft Key Exerciser");
2825             attroff(A_BOLD);
2826
2827             slk_help();
2828             /* fall through */
2829
2830         case 'a':
2831             slk_restore();
2832             break;
2833
2834         case 'e':
2835             wclear(stdscr);
2836             break;
2837
2838         case 's':
2839             MvPrintw(SLK_WORK, 0, "Press Q to stop the scrolling-test: ");
2840             while ((c = Getchar()) != 'Q' && (c != ERR))
2841                 addch((chtype) c);
2842             break;
2843
2844         case 'd':
2845             slk_clear();
2846             break;
2847
2848         case 'l':
2849             fmt = 0;
2850             break;
2851
2852         case 'c':
2853             fmt = 1;
2854             break;
2855
2856         case 'r':
2857             fmt = 2;
2858             break;
2859
2860         case '1':
2861         case '2':
2862         case '3':
2863         case '4':
2864         case '5':
2865         case '6':
2866         case '7':
2867         case '8':
2868             MvAddStr(SLK_WORK, 0, "Please enter the label value: ");
2869             strcpy(buf, "");
2870             if ((s = slk_label(c - '0')) != 0) {
2871                 strncpy(buf, s, (size_t) 8);
2872             }
2873             wGetstring(stdscr, buf, 8);
2874             slk_set((c - '0'), buf, fmt);
2875             slk_refresh();
2876             move(SLK_WORK, 0);
2877             clrtobot();
2878             break;
2879
2880         case case_QUIT:
2881             goto done;
2882
2883 #if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
2884         case KEY_RESIZE:
2885             wnoutrefresh(stdscr);
2886             break;
2887 #endif
2888
2889         default:
2890             if (cycle_attr(c, &at_code, &attr, my_list, my_size)) {
2891                 slk_attrset(attr);
2892                 slk_touch();
2893                 slk_noutrefresh();
2894                 break;
2895             }
2896 #if HAVE_SLK_COLOR
2897             if (cycle_colors(c, &fg, &bg, &pair)) {
2898                 if (use_colors) {
2899                     call_slk_color(fg, bg);
2900                 } else {
2901                     beep();
2902                 }
2903                 break;
2904             }
2905 #endif
2906             beep();
2907             break;
2908         }
2909     } while (!isQuit(c = Getchar()));
2910
2911   done:
2912     slk_clear();
2913     erase();
2914     endwin();
2915 }
2916
2917 #if USE_WIDEC_SUPPORT
2918 #define SLKLEN 8
2919 static void
2920 wide_slk_test(void)
2921 /* exercise the soft keys */
2922 {
2923     int c, fmt = 1;
2924     wchar_t buf[SLKLEN + 1];
2925     char *s;
2926     chtype attr = A_NORMAL;
2927     unsigned at_code = 0;
2928     int fg = COLOR_BLACK;
2929     int bg = COLOR_WHITE;
2930     NCURSES_PAIRS_T pair = 0;
2931     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
2932     unsigned my_size = init_attr_list(my_list, term_attrs());
2933
2934     c = CTRL('l');
2935     if (use_colors) {
2936         call_slk_color(fg, bg);
2937     }
2938     do {
2939         move(0, 0);
2940         switch (c) {
2941         case CTRL('l'):
2942             erase();
2943             attr_on(WA_BOLD, NULL);
2944             MvAddStr(0, 20, "Soft Key Exerciser");
2945             attr_off(WA_BOLD, NULL);
2946
2947             slk_help();
2948             /* fall through */
2949
2950         case 'a':
2951             slk_restore();
2952             break;
2953
2954         case 'e':
2955             wclear(stdscr);
2956             break;
2957
2958         case 's':
2959             MvPrintw(SLK_WORK, 0, "Press Q to stop the scrolling-test: ");
2960             while ((c = Getchar()) != 'Q' && (c != ERR))
2961                 addch((chtype) c);
2962             break;
2963
2964         case 'd':
2965             slk_clear();
2966             break;
2967
2968         case 'l':
2969             fmt = 0;
2970             break;
2971
2972         case 'c':
2973             fmt = 1;
2974             break;
2975
2976         case 'r':
2977             fmt = 2;
2978             break;
2979
2980         case '1':
2981         case '2':
2982         case '3':
2983         case '4':
2984         case '5':
2985         case '6':
2986         case '7':
2987         case '8':
2988             MvAddStr(SLK_WORK, 0, "Please enter the label value: ");
2989             *buf = 0;
2990             if ((s = slk_label(c - '0')) != 0) {
2991                 char *temp = strdup(s);
2992                 size_t used = strlen(temp);
2993                 size_t want = SLKLEN;
2994                 size_t test;
2995 #ifndef state_unused
2996                 mbstate_t state;
2997 #endif
2998
2999                 buf[0] = L'\0';
3000                 while (want > 0 && used != 0) {
3001                     const char *base = s;
3002                     reset_mbytes(state);
3003                     test = count_mbytes(base, 0, &state);
3004                     if (test == (size_t) -1) {
3005                         temp[--used] = 0;
3006                     } else if (test > want) {
3007                         temp[--used] = 0;
3008                     } else {
3009                         reset_mbytes(state);
3010                         trans_mbytes(buf, base, want, &state);
3011                         break;
3012                     }
3013                 }
3014                 free(temp);
3015             }
3016             wGet_wstring(stdscr, buf, SLKLEN);
3017             slk_wset((c - '0'), buf, fmt);
3018             slk_refresh();
3019             move(SLK_WORK, 0);
3020             clrtobot();
3021             break;
3022
3023         case case_QUIT:
3024             goto done;
3025
3026         case 'F':
3027             if (use_colors) {
3028                 fg = (NCURSES_COLOR_T) ((fg + 1) % COLORS);
3029                 call_slk_color(fg, bg);
3030             }
3031             break;
3032         case 'B':
3033             if (use_colors) {
3034                 bg = (NCURSES_COLOR_T) ((bg + 1) % COLORS);
3035                 call_slk_color(fg, bg);
3036             }
3037             break;
3038 #if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
3039         case KEY_RESIZE:
3040             wnoutrefresh(stdscr);
3041             break;
3042 #endif
3043         default:
3044             if (cycle_attr(c, &at_code, &attr, my_list, my_size)) {
3045                 slk_attr_set(attr, (NCURSES_COLOR_T) (fg || bg), NULL);
3046                 slk_touch();
3047                 slk_noutrefresh();
3048                 break;
3049             }
3050 #if HAVE_SLK_COLOR
3051             if (cycle_colors(c, &fg, &bg, &pair)) {
3052                 if (use_colors) {
3053                     call_slk_color(fg, bg);
3054                 } else {
3055                     beep();
3056                 }
3057                 break;
3058             }
3059 #endif
3060             beep();
3061             break;
3062         }
3063     } while (!isQuit(c = Getchar()));
3064
3065   done:
3066     slk_clear();
3067     erase();
3068     endwin();
3069 }
3070 #endif
3071 #endif /* SLK_INIT */
3072
3073 static void
3074 show_256_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3075 {
3076     unsigned first = 0;
3077     unsigned last = 255;
3078     unsigned code;
3079     int count;
3080
3081     erase();
3082     attron(A_BOLD);
3083     MvPrintw(0, 20, "Display of Character Codes %#0x to %#0x",
3084              first, last);
3085     attroff(A_BOLD);
3086     refresh();
3087
3088     for (code = first; code <= last; ++code) {
3089         int row = (int) (2 + (code / 16));
3090         int col = (int) (5 * (code % 16));
3091         IGNORE_RC(mvaddch(row, col, colored_chtype(code, attr, pair)));
3092         for (count = 1; count < repeat; ++count) {
3093             addch(colored_chtype(code, attr, pair));
3094         }
3095     }
3096
3097 }
3098
3099 /*
3100  * Show a slice of 32 characters, allowing those to be repeated up to the
3101  * screen's width.
3102  *
3103  * ISO 6429:  codes 0x80 to 0x9f may be control characters that cause the
3104  * terminal to perform functions.  The remaining codes can be graphic.
3105  */
3106 static void
3107 show_upper_chars(int base, int pagesize, int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3108 {
3109     unsigned code;
3110     unsigned first = (unsigned) base;
3111     unsigned last = first + (unsigned) pagesize - 2;
3112     bool C1 = (first == 128);
3113     int reply;
3114
3115     erase();
3116     attron(A_BOLD);
3117     MvPrintw(0, 20, "Display of %s Character Codes %d to %d",
3118              C1 ? "C1" : "GR", first, last);
3119     attroff(A_BOLD);
3120     refresh();
3121
3122     for (code = first; code <= last; code++) {
3123         int count = repeat;
3124         int row = 2 + ((int) (code - first) % (pagesize / 2));
3125         int col = ((int) (code - first) / (pagesize / 2)) * COLS / 2;
3126         char tmp[80];
3127         sprintf(tmp, "%3u (0x%x)", code, code);
3128         MvPrintw(row, col, "%*s: ", COLS / 4, tmp);
3129
3130         do {
3131             if (C1)
3132                 nodelay(stdscr, TRUE);
3133             echochar(colored_chtype(code, attr, pair));
3134             if (C1) {
3135                 /* (yes, this _is_ crude) */
3136                 while ((reply = Getchar()) != ERR) {
3137                     addch(UChar(reply));
3138                     napms(10);
3139                 }
3140                 nodelay(stdscr, FALSE);
3141             }
3142         } while (--count > 0);
3143     }
3144 }
3145
3146 #define PC_COLS 4
3147
3148 static void
3149 show_pc_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3150 {
3151     unsigned code;
3152
3153     erase();
3154     attron(A_BOLD);
3155     MvPrintw(0, 20, "Display of PC Character Codes");
3156     attroff(A_BOLD);
3157     refresh();
3158
3159     for (code = 0; code < 16; ++code) {
3160         MvPrintw(2, (int) code * PC_COLS + 8, "%X", code);
3161     }
3162     for (code = 0; code < 256; code++) {
3163         int count = repeat;
3164         int row = 3 + (int) (code / 16) + (code >= 128);
3165         int col = 8 + (int) (code % 16) * PC_COLS;
3166         if ((code % 16) == 0)
3167             MvPrintw(row, 0, "0x%02x:", code);
3168         move(row, col);
3169         do {
3170             switch (code) {
3171             case '\n':
3172             case '\r':
3173             case '\b':
3174             case '\f':
3175             case '\033':
3176             case 0x9b:
3177                 /*
3178                  * Skip the ones that do not work.
3179                  */
3180                 break;
3181             default:
3182                 addch(colored_chtype(code, A_ALTCHARSET | attr, pair));
3183                 break;
3184             }
3185         } while (--count > 0);
3186     }
3187 }
3188
3189 static void
3190 show_box_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3191 {
3192     (void) repeat;
3193
3194     attr |= (attr_t) COLOR_PAIR(pair);
3195
3196     erase();
3197     attron(A_BOLD);
3198     MvAddStr(0, 20, "Display of the ACS Line-Drawing Set");
3199     attroff(A_BOLD);
3200     refresh();
3201     /* *INDENT-OFF* */
3202     wborder(stdscr,
3203             colored_chtype(ACS_VLINE,    attr, pair),
3204             colored_chtype(ACS_VLINE,    attr, pair),
3205             colored_chtype(ACS_HLINE,    attr, pair),
3206             colored_chtype(ACS_HLINE,    attr, pair),
3207             colored_chtype(ACS_ULCORNER, attr, pair),
3208             colored_chtype(ACS_URCORNER, attr, pair),
3209             colored_chtype(ACS_LLCORNER, attr, pair),
3210             colored_chtype(ACS_LRCORNER, attr, pair));
3211     MvHLine(LINES / 2, 0,        colored_chtype(ACS_HLINE, attr, pair), COLS);
3212     MvVLine(0,         COLS / 2, colored_chtype(ACS_VLINE, attr, pair), LINES);
3213     MvAddCh(0,         COLS / 2, colored_chtype(ACS_TTEE,  attr, pair));
3214     MvAddCh(LINES / 2, COLS / 2, colored_chtype(ACS_PLUS,  attr, pair));
3215     MvAddCh(LINES - 1, COLS / 2, colored_chtype(ACS_BTEE,  attr, pair));
3216     MvAddCh(LINES / 2, 0,        colored_chtype(ACS_LTEE,  attr, pair));
3217     MvAddCh(LINES / 2, COLS - 1, colored_chtype(ACS_RTEE,  attr, pair));
3218     /* *INDENT-ON* */
3219
3220 }
3221
3222 static int
3223 show_1_acs(int n, int repeat, const char *name, chtype code)
3224 {
3225     const int height = 16;
3226     int row = 2 + (n % height);
3227     int col = (n / height) * COLS / 2;
3228
3229     MvPrintw(row, col, "%*s : ", COLS / 4, name);
3230     do {
3231         addch(code);
3232     } while (--repeat > 0);
3233     return n + 1;
3234 }
3235
3236 static void
3237 show_acs_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3238 /* display the ACS character set */
3239 {
3240     int n;
3241
3242 #define BOTH(name) #name, colored_chtype(name, attr, (chtype) pair)
3243
3244     erase();
3245     attron(A_BOLD);
3246     MvAddStr(0, 20, "Display of the ACS Character Set");
3247     attroff(A_BOLD);
3248     refresh();
3249
3250     n = show_1_acs(0, repeat, BOTH(ACS_ULCORNER));
3251     n = show_1_acs(n, repeat, BOTH(ACS_URCORNER));
3252     n = show_1_acs(n, repeat, BOTH(ACS_LLCORNER));
3253     n = show_1_acs(n, repeat, BOTH(ACS_LRCORNER));
3254
3255     n = show_1_acs(n, repeat, BOTH(ACS_LTEE));
3256     n = show_1_acs(n, repeat, BOTH(ACS_RTEE));
3257     n = show_1_acs(n, repeat, BOTH(ACS_TTEE));
3258     n = show_1_acs(n, repeat, BOTH(ACS_BTEE));
3259
3260     n = show_1_acs(n, repeat, BOTH(ACS_HLINE));
3261     n = show_1_acs(n, repeat, BOTH(ACS_VLINE));
3262
3263     /*
3264      * HPUX's ACS definitions are broken here.  Just give up.
3265      */
3266 #if !(defined(__hpux) && !defined(NCURSES_VERSION))
3267     n = show_1_acs(n, repeat, BOTH(ACS_LARROW));
3268     n = show_1_acs(n, repeat, BOTH(ACS_RARROW));
3269     n = show_1_acs(n, repeat, BOTH(ACS_UARROW));
3270     n = show_1_acs(n, repeat, BOTH(ACS_DARROW));
3271
3272     n = show_1_acs(n, repeat, BOTH(ACS_BLOCK));
3273     n = show_1_acs(n, repeat, BOTH(ACS_BOARD));
3274     n = show_1_acs(n, repeat, BOTH(ACS_LANTERN));
3275     n = show_1_acs(n, repeat, BOTH(ACS_BULLET));
3276     n = show_1_acs(n, repeat, BOTH(ACS_CKBOARD));
3277     n = show_1_acs(n, repeat, BOTH(ACS_DEGREE));
3278     n = show_1_acs(n, repeat, BOTH(ACS_DIAMOND));
3279     n = show_1_acs(n, repeat, BOTH(ACS_PLMINUS));
3280     n = show_1_acs(n, repeat, BOTH(ACS_PLUS));
3281
3282     n = show_1_acs(n, repeat, BOTH(ACS_GEQUAL));
3283     n = show_1_acs(n, repeat, BOTH(ACS_NEQUAL));
3284     n = show_1_acs(n, repeat, BOTH(ACS_LEQUAL));
3285
3286     n = show_1_acs(n, repeat, BOTH(ACS_STERLING));
3287     n = show_1_acs(n, repeat, BOTH(ACS_PI));
3288     n = show_1_acs(n, repeat, BOTH(ACS_S1));
3289     n = show_1_acs(n, repeat, BOTH(ACS_S3));
3290     n = show_1_acs(n, repeat, BOTH(ACS_S7));
3291     (void) show_1_acs(n, repeat, BOTH(ACS_S9));
3292 #endif
3293 }
3294
3295 static void
3296 acs_display(void)
3297 {
3298     int c = 'a';
3299     int pagesize = 32;
3300     char *term = getenv("TERM");
3301     const char *pch_kludge = ((term != 0 && strstr(term, "linux"))
3302                               ? "p=PC, "
3303                               : "");
3304     chtype attr = A_NORMAL;
3305     int digit = 0;
3306     int repeat = 1;
3307     int fg = COLOR_BLACK;
3308     int bg = COLOR_BLACK;
3309     unsigned at_code = 0;
3310     NCURSES_PAIRS_T pair = 0;
3311     void (*last_show_acs) (int, attr_t, NCURSES_PAIRS_T) = 0;
3312     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
3313     unsigned my_size = init_attr_list(my_list, termattrs());
3314
3315     do {
3316         switch (c) {
3317         case CTRL('L'):
3318             Repaint();
3319             break;
3320         case 'a':
3321             ToggleAcs(last_show_acs, show_acs_chars);
3322             break;
3323         case 'p':
3324             if (*pch_kludge)
3325                 ToggleAcs(last_show_acs, show_pc_chars);
3326             else
3327                 beep();
3328             break;
3329         case 'w':
3330             if (pagesize == 32) {
3331                 pagesize = 256;
3332             } else {
3333                 pagesize = 32;
3334             }
3335             break;
3336         case 'x':
3337             ToggleAcs(last_show_acs, show_box_chars);
3338             break;
3339         case '0':
3340         case '1':
3341         case '2':
3342         case '3':
3343             digit = (c - '0');
3344             last_show_acs = 0;
3345             break;
3346         case '-':
3347             if (digit > 0) {
3348                 --digit;
3349                 last_show_acs = 0;
3350             } else {
3351                 beep();
3352             }
3353             break;
3354         case '+':
3355             if (digit < 3) {
3356                 ++digit;
3357                 last_show_acs = 0;
3358             } else {
3359                 beep();
3360             }
3361             break;
3362         case '>':
3363             if (repeat < (COLS / 4))
3364                 ++repeat;
3365             break;
3366         case '<':
3367             if (repeat > 1)
3368                 --repeat;
3369             break;
3370         default:
3371             if (cycle_attr(c, &at_code, &attr, my_list, my_size)
3372                 || cycle_colors(c, &fg, &bg, &pair)) {
3373                 break;
3374             } else {
3375                 beep();
3376             }
3377             break;
3378         }
3379         if (pagesize != 32) {
3380             show_256_chars(repeat, attr, pair);
3381         } else if (last_show_acs != 0) {
3382             last_show_acs(repeat, attr, pair);
3383         } else {
3384             show_upper_chars(digit * pagesize + 128, pagesize, repeat, attr, pair);
3385         }
3386
3387         MvPrintw(LINES - 3, 0,
3388                  "Note: ANSI terminals may not display C1 characters.");
3389         MvPrintw(LINES - 2, 0,
3390                  "Select: a=ACS, w=all x=box, %s0=C1, 1-3,+/- non-ASCII, </> repeat, ESC=quit",
3391                  pch_kludge);
3392         if (use_colors) {
3393             MvPrintw(LINES - 1, 0,
3394                      "v/V, f/F, b/B cycle through video attributes (%s) and color %d/%d.",
3395                      my_list[at_code].name,
3396                      fg, bg);
3397         } else {
3398             MvPrintw(LINES - 1, 0,
3399                      "v/V cycles through video attributes (%s).",
3400                      my_list[at_code].name);
3401         }
3402         refresh();
3403     } while (!isQuit(c = Getchar()));
3404
3405     Pause();
3406     erase();
3407     endwin();
3408 }
3409
3410 #if USE_WIDEC_SUPPORT
3411 static cchar_t *
3412 merge_wide_attr(cchar_t *dst, const cchar_t *src, attr_t attr, NCURSES_PAIRS_T pair)
3413 {
3414     int count;
3415
3416     *dst = *src;
3417     do {
3418         TEST_CCHAR(src, count, {
3419             attr |= (test_attrs & A_ALTCHARSET);
3420             setcchar(dst, test_wch, attr, pair, NULL);
3421         }
3422         , {
3423             ;
3424         });
3425     } while (0);
3426     return dst;
3427 }
3428
3429 /*
3430  * Header/legend take up no more than 8 lines, leaving 16 lines on a 24-line
3431  * display.  If there are no repeats, we could normally display 16 lines of 64
3432  * characters (1024 total).  However, taking repeats and double-width cells
3433  * into account, use 256 characters for the page.
3434  */
3435 static void
3436 show_paged_widechars(int base,
3437                      int pagesize,
3438                      int repeat,
3439                      int space,
3440                      attr_t attr,
3441                      NCURSES_PAIRS_T pair)
3442 {
3443     int first = base * pagesize;
3444     int last = first + pagesize - 1;
3445     int per_line = 16;
3446     cchar_t temp;
3447     wchar_t code;
3448     wchar_t codes[10];
3449
3450     erase();
3451     attron(A_BOLD);
3452     MvPrintw(0, 20, "Display of Character Codes %#x to %#x", first, last);
3453     attroff(A_BOLD);
3454
3455     for (code = first; (int) code <= last; code++) {
3456         int row = (2 + ((int) code - first) / per_line);
3457         int col = 5 * ((int) code % per_line);
3458         int count;
3459
3460         memset(&codes, 0, sizeof(codes));
3461         codes[0] = code;
3462         setcchar(&temp, codes, attr, pair, 0);
3463         move(row, col);
3464         if (wcwidth(code) == 0 && code != 0) {
3465             addch((chtype) space |
3466                   (A_REVERSE ^ attr) |
3467                   (attr_t) COLOR_PAIR(pair));
3468         }
3469         add_wch(&temp);
3470         for (count = 1; count < repeat; ++count) {
3471             add_wch(&temp);
3472         }
3473     }
3474 }
3475
3476 static void
3477 show_upper_widechars(int first, int repeat, int space, attr_t attr, NCURSES_PAIRS_T pair)
3478 {
3479     cchar_t temp;
3480     wchar_t code;
3481     int last = first + 31;
3482
3483     erase();
3484     attron(A_BOLD);
3485     MvPrintw(0, 20, "Display of Character Codes %d to %d", first, last);
3486     attroff(A_BOLD);
3487
3488     for (code = first; (int) code <= last; code++) {
3489         int row = 2 + ((code - first) % 16);
3490         int col = ((code - first) / 16) * COLS / 2;
3491         wchar_t codes[10];
3492         char tmp[80];
3493         int count = repeat;
3494         int y, x;
3495
3496         sprintf(tmp, "%3ld (0x%lx)", (long) code, (long) code);
3497         MvPrintw(row, col, "%*s: ", COLS / 4, tmp);
3498
3499         memset(&codes, 0, sizeof(codes));
3500         codes[0] = code;
3501         setcchar(&temp, codes, attr, pair, 0);
3502
3503         do {
3504             /*
3505              * Give non-spacing characters something to combine with.  If we
3506              * don't, they'll bunch up in a heap on the space after the ":".
3507              * Mark them with reverse-video to make them simpler to find on
3508              * the display.
3509              */
3510             if (wcwidth(code) == 0) {
3511                 addch((chtype) space |
3512                       (A_REVERSE ^ attr) |
3513                       (attr_t) COLOR_PAIR(pair));
3514             }
3515             /*
3516              * This uses echo_wchar(), for comparison with the normal 'f'
3517              * test (and to make a test-case for echo_wchar()).  The screen
3518              * may flicker because the erase() at the top of the function
3519              * is met by the builtin refresh() in echo_wchar().
3520              */
3521             echo_wchar(&temp);
3522             /*
3523              * The repeat-count may make text wrap - avoid that.
3524              */
3525             getyx(stdscr, y, x);
3526             (void) y;
3527             if (x >= col + (COLS / 2) - 2)
3528                 break;
3529         } while (--count > 0);
3530     }
3531 }
3532
3533 static int
3534 show_1_wacs(int n, int repeat, const char *name, const cchar_t *code)
3535 {
3536     const int height = 16;
3537     int row = 2 + (n % height);
3538     int col = (n / height) * COLS / 2;
3539
3540     MvPrintw(row, col, "%*s : ", COLS / 4, name);
3541     while (--repeat >= 0) {
3542         add_wch(code);
3543     }
3544     return n + 1;
3545 }
3546
3547 #define MERGE_ATTR(wch) merge_wide_attr(&temp, wch, attr, pair)
3548
3549 static void
3550 show_wacs_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3551 /* display the wide-ACS character set */
3552 {
3553     cchar_t temp;
3554
3555     int n;
3556
3557 /*#define BOTH2(name) #name, &(name) */
3558 #define BOTH2(name) #name, MERGE_ATTR(name)
3559
3560     erase();
3561     attron(A_BOLD);
3562     MvAddStr(0, 20, "Display of the Wide-ACS Character Set");
3563     attroff(A_BOLD);
3564     refresh();
3565
3566     n = show_1_wacs(0, repeat, BOTH2(WACS_ULCORNER));
3567     n = show_1_wacs(n, repeat, BOTH2(WACS_URCORNER));
3568     n = show_1_wacs(n, repeat, BOTH2(WACS_LLCORNER));
3569     n = show_1_wacs(n, repeat, BOTH2(WACS_LRCORNER));
3570
3571     n = show_1_wacs(n, repeat, BOTH2(WACS_LTEE));
3572     n = show_1_wacs(n, repeat, BOTH2(WACS_RTEE));
3573     n = show_1_wacs(n, repeat, BOTH2(WACS_TTEE));
3574     n = show_1_wacs(n, repeat, BOTH2(WACS_BTEE));
3575
3576     n = show_1_wacs(n, repeat, BOTH2(WACS_HLINE));
3577     n = show_1_wacs(n, repeat, BOTH2(WACS_VLINE));
3578
3579     n = show_1_wacs(n, repeat, BOTH2(WACS_LARROW));
3580     n = show_1_wacs(n, repeat, BOTH2(WACS_RARROW));
3581     n = show_1_wacs(n, repeat, BOTH2(WACS_UARROW));
3582     n = show_1_wacs(n, repeat, BOTH2(WACS_DARROW));
3583
3584     n = show_1_wacs(n, repeat, BOTH2(WACS_BLOCK));
3585     n = show_1_wacs(n, repeat, BOTH2(WACS_BOARD));
3586     n = show_1_wacs(n, repeat, BOTH2(WACS_LANTERN));
3587     n = show_1_wacs(n, repeat, BOTH2(WACS_BULLET));
3588     n = show_1_wacs(n, repeat, BOTH2(WACS_CKBOARD));
3589     n = show_1_wacs(n, repeat, BOTH2(WACS_DEGREE));
3590     n = show_1_wacs(n, repeat, BOTH2(WACS_DIAMOND));
3591     n = show_1_wacs(n, repeat, BOTH2(WACS_PLMINUS));
3592     n = show_1_wacs(n, repeat, BOTH2(WACS_PLUS));
3593
3594 #ifdef CURSES_WACS_ARRAY
3595     n = show_1_wacs(n, repeat, BOTH2(WACS_GEQUAL));
3596     n = show_1_wacs(n, repeat, BOTH2(WACS_NEQUAL));
3597     n = show_1_wacs(n, repeat, BOTH2(WACS_LEQUAL));
3598
3599     n = show_1_wacs(n, repeat, BOTH2(WACS_STERLING));
3600     n = show_1_wacs(n, repeat, BOTH2(WACS_PI));
3601     n = show_1_wacs(n, repeat, BOTH2(WACS_S1));
3602     n = show_1_wacs(n, repeat, BOTH2(WACS_S3));
3603     n = show_1_wacs(n, repeat, BOTH2(WACS_S7));
3604     (void) show_1_wacs(n, repeat, BOTH2(WACS_S9));
3605 #endif
3606 }
3607
3608 #ifdef WACS_D_PLUS
3609 static void
3610 show_wacs_chars_double(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3611 /* display the wide-ACS character set */
3612 {
3613     cchar_t temp;
3614
3615     int n;
3616
3617 /*#define BOTH2(name) #name, &(name) */
3618 #define BOTH2(name) #name, MERGE_ATTR(name)
3619
3620     erase();
3621     attron(A_BOLD);
3622     MvAddStr(0, 20, "Display of the Wide-ACS Character Set");
3623     attroff(A_BOLD);
3624     refresh();
3625
3626     n = show_1_wacs(0, repeat, BOTH2(WACS_D_ULCORNER));
3627     n = show_1_wacs(n, repeat, BOTH2(WACS_D_URCORNER));
3628     n = show_1_wacs(n, repeat, BOTH2(WACS_D_LLCORNER));
3629     n = show_1_wacs(n, repeat, BOTH2(WACS_D_LRCORNER));
3630
3631     n = show_1_wacs(n, repeat, BOTH2(WACS_D_LTEE));
3632     n = show_1_wacs(n, repeat, BOTH2(WACS_D_RTEE));
3633     n = show_1_wacs(n, repeat, BOTH2(WACS_D_TTEE));
3634     n = show_1_wacs(n, repeat, BOTH2(WACS_D_BTEE));
3635
3636     n = show_1_wacs(n, repeat, BOTH2(WACS_D_HLINE));
3637     n = show_1_wacs(n, repeat, BOTH2(WACS_D_VLINE));
3638
3639     n = show_1_wacs(n, repeat, BOTH2(WACS_LARROW));
3640     n = show_1_wacs(n, repeat, BOTH2(WACS_RARROW));
3641     n = show_1_wacs(n, repeat, BOTH2(WACS_UARROW));
3642     n = show_1_wacs(n, repeat, BOTH2(WACS_DARROW));
3643
3644     n = show_1_wacs(n, repeat, BOTH2(WACS_BLOCK));
3645     n = show_1_wacs(n, repeat, BOTH2(WACS_BOARD));
3646     n = show_1_wacs(n, repeat, BOTH2(WACS_LANTERN));
3647     n = show_1_wacs(n, repeat, BOTH2(WACS_BULLET));
3648     n = show_1_wacs(n, repeat, BOTH2(WACS_CKBOARD));
3649     n = show_1_wacs(n, repeat, BOTH2(WACS_DEGREE));
3650     n = show_1_wacs(n, repeat, BOTH2(WACS_DIAMOND));
3651     n = show_1_wacs(n, repeat, BOTH2(WACS_PLMINUS));
3652     n = show_1_wacs(n, repeat, BOTH2(WACS_PLUS));
3653
3654 #ifdef CURSES_WACS_ARRAY
3655     n = show_1_wacs(n, repeat, BOTH2(WACS_GEQUAL));
3656     n = show_1_wacs(n, repeat, BOTH2(WACS_NEQUAL));
3657     n = show_1_wacs(n, repeat, BOTH2(WACS_LEQUAL));
3658
3659     n = show_1_wacs(n, repeat, BOTH2(WACS_STERLING));
3660     n = show_1_wacs(n, repeat, BOTH2(WACS_PI));
3661     n = show_1_wacs(n, repeat, BOTH2(WACS_S1));
3662     n = show_1_wacs(n, repeat, BOTH2(WACS_S3));
3663     n = show_1_wacs(n, repeat, BOTH2(WACS_S7));
3664     (void) show_1_wacs(n, repeat, BOTH2(WACS_S9));
3665 #endif
3666 }
3667 #endif
3668
3669 #ifdef WACS_T_PLUS
3670 static void
3671 show_wacs_chars_thick(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3672 /* display the wide-ACS character set */
3673 {
3674     cchar_t temp;
3675
3676     int n;
3677
3678 /*#define BOTH2(name) #name, &(name) */
3679 #define BOTH2(name) #name, MERGE_ATTR(name)
3680
3681     erase();
3682     attron(A_BOLD);
3683     MvAddStr(0, 20, "Display of the Wide-ACS Character Set");
3684     attroff(A_BOLD);
3685     refresh();
3686
3687     n = show_1_wacs(0, repeat, BOTH2(WACS_T_ULCORNER));
3688     n = show_1_wacs(n, repeat, BOTH2(WACS_T_URCORNER));
3689     n = show_1_wacs(n, repeat, BOTH2(WACS_T_LLCORNER));
3690     n = show_1_wacs(n, repeat, BOTH2(WACS_T_LRCORNER));
3691
3692     n = show_1_wacs(n, repeat, BOTH2(WACS_T_LTEE));
3693     n = show_1_wacs(n, repeat, BOTH2(WACS_T_RTEE));
3694     n = show_1_wacs(n, repeat, BOTH2(WACS_T_TTEE));
3695     n = show_1_wacs(n, repeat, BOTH2(WACS_T_BTEE));
3696
3697     n = show_1_wacs(n, repeat, BOTH2(WACS_T_HLINE));
3698     n = show_1_wacs(n, repeat, BOTH2(WACS_T_VLINE));
3699
3700     n = show_1_wacs(n, repeat, BOTH2(WACS_LARROW));
3701     n = show_1_wacs(n, repeat, BOTH2(WACS_RARROW));
3702     n = show_1_wacs(n, repeat, BOTH2(WACS_UARROW));
3703     n = show_1_wacs(n, repeat, BOTH2(WACS_DARROW));
3704
3705     n = show_1_wacs(n, repeat, BOTH2(WACS_BLOCK));
3706     n = show_1_wacs(n, repeat, BOTH2(WACS_BOARD));
3707     n = show_1_wacs(n, repeat, BOTH2(WACS_LANTERN));
3708     n = show_1_wacs(n, repeat, BOTH2(WACS_BULLET));
3709     n = show_1_wacs(n, repeat, BOTH2(WACS_CKBOARD));
3710     n = show_1_wacs(n, repeat, BOTH2(WACS_DEGREE));
3711     n = show_1_wacs(n, repeat, BOTH2(WACS_DIAMOND));
3712     n = show_1_wacs(n, repeat, BOTH2(WACS_PLMINUS));
3713     n = show_1_wacs(n, repeat, BOTH2(WACS_PLUS));
3714
3715 #ifdef CURSES_WACS_ARRAY
3716     n = show_1_wacs(n, repeat, BOTH2(WACS_GEQUAL));
3717     n = show_1_wacs(n, repeat, BOTH2(WACS_NEQUAL));
3718     n = show_1_wacs(n, repeat, BOTH2(WACS_LEQUAL));
3719
3720     n = show_1_wacs(n, repeat, BOTH2(WACS_STERLING));
3721     n = show_1_wacs(n, repeat, BOTH2(WACS_PI));
3722     n = show_1_wacs(n, repeat, BOTH2(WACS_S1));
3723     n = show_1_wacs(n, repeat, BOTH2(WACS_S3));
3724     n = show_1_wacs(n, repeat, BOTH2(WACS_S7));
3725     (void) show_1_wacs(n, repeat, BOTH2(WACS_S9));
3726 #endif
3727 }
3728 #endif
3729
3730 #undef MERGE_ATTR
3731
3732 #define MERGE_ATTR(n,wch) merge_wide_attr(&temp[n], wch, attr, pair)
3733
3734 static void
3735 show_wbox_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3736 {
3737     cchar_t temp[8];
3738
3739     (void) repeat;
3740     erase();
3741     attron(A_BOLD);
3742     MvAddStr(0, 20, "Display of the Wide-ACS Line-Drawing Set");
3743     attroff(A_BOLD);
3744     refresh();
3745
3746     wborder_set(stdscr,
3747                 MERGE_ATTR(0, WACS_VLINE),
3748                 MERGE_ATTR(1, WACS_VLINE),
3749                 MERGE_ATTR(2, WACS_HLINE),
3750                 MERGE_ATTR(3, WACS_HLINE),
3751                 MERGE_ATTR(4, WACS_ULCORNER),
3752                 MERGE_ATTR(5, WACS_URCORNER),
3753                 MERGE_ATTR(6, WACS_LLCORNER),
3754                 MERGE_ATTR(7, WACS_LRCORNER));
3755     /* *INDENT-OFF* */
3756     (void) mvhline_set(LINES / 2, 0,        MERGE_ATTR(0, WACS_HLINE), COLS);
3757     (void) mvvline_set(0,         COLS / 2, MERGE_ATTR(0, WACS_VLINE), LINES);
3758     (void) mvadd_wch(0,           COLS / 2, MERGE_ATTR(0, WACS_TTEE));
3759     (void) mvadd_wch(LINES / 2,   COLS / 2, MERGE_ATTR(0, WACS_PLUS));
3760     (void) mvadd_wch(LINES - 1,   COLS / 2, MERGE_ATTR(0, WACS_BTEE));
3761     (void) mvadd_wch(LINES / 2,   0,        MERGE_ATTR(0, WACS_LTEE));
3762     (void) mvadd_wch(LINES / 2,   COLS - 1, MERGE_ATTR(0, WACS_RTEE));
3763     /* *INDENT-ON* */
3764
3765 }
3766
3767 #undef MERGE_ATTR
3768
3769 static int
3770 show_2_wacs(int n, const char *name, const char *code, attr_t attr, NCURSES_PAIRS_T pair)
3771 {
3772     const int height = 16;
3773     int row = 2 + (n % height);
3774     int col = (n / height) * COLS / 2;
3775     char temp[80];
3776
3777     MvPrintw(row, col, "%*s : ", COLS / 4, name);
3778     (void) attr_set(attr, pair, 0);
3779     addstr(strncpy(temp, code, 20));
3780     (void) attr_set(A_NORMAL, 0, 0);
3781     return n + 1;
3782 }
3783
3784 #define SHOW_UTF8(n, name, code) show_2_wacs(n, name, code, attr, pair)
3785
3786 static void
3787 show_utf8_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
3788 {
3789     int n;
3790
3791     (void) repeat;
3792     erase();
3793     attron(A_BOLD);
3794     MvAddStr(0, 20, "Display of the Wide-ACS Character Set");
3795     attroff(A_BOLD);
3796     refresh();
3797     /* *INDENT-OFF* */
3798     n = SHOW_UTF8(0, "WACS_ULCORNER",   "\342\224\214");
3799     n = SHOW_UTF8(n, "WACS_URCORNER",   "\342\224\220");
3800     n = SHOW_UTF8(n, "WACS_LLCORNER",   "\342\224\224");
3801     n = SHOW_UTF8(n, "WACS_LRCORNER",   "\342\224\230");
3802
3803     n = SHOW_UTF8(n, "WACS_LTEE",       "\342\224\234");
3804     n = SHOW_UTF8(n, "WACS_RTEE",       "\342\224\244");
3805     n = SHOW_UTF8(n, "WACS_TTEE",       "\342\224\254");
3806     n = SHOW_UTF8(n, "WACS_BTEE",       "\342\224\264");
3807
3808     n = SHOW_UTF8(n, "WACS_HLINE",      "\342\224\200");
3809     n = SHOW_UTF8(n, "WACS_VLINE",      "\342\224\202");
3810
3811     n = SHOW_UTF8(n, "WACS_LARROW",     "\342\206\220");
3812     n = SHOW_UTF8(n, "WACS_RARROW",     "\342\206\222");
3813     n = SHOW_UTF8(n, "WACS_UARROW",     "\342\206\221");
3814     n = SHOW_UTF8(n, "WACS_DARROW",     "\342\206\223");
3815
3816     n = SHOW_UTF8(n, "WACS_BLOCK",      "\342\226\256");
3817     n = SHOW_UTF8(n, "WACS_BOARD",      "\342\226\222");
3818     n = SHOW_UTF8(n, "WACS_LANTERN",    "\342\230\203");
3819     n = SHOW_UTF8(n, "WACS_BULLET",     "\302\267");
3820     n = SHOW_UTF8(n, "WACS_CKBOARD",    "\342\226\222");
3821     n = SHOW_UTF8(n, "WACS_DEGREE",     "\302\260");
3822     n = SHOW_UTF8(n, "WACS_DIAMOND",    "\342\227\206");
3823     n = SHOW_UTF8(n, "WACS_PLMINUS",    "\302\261");
3824     n = SHOW_UTF8(n, "WACS_PLUS",       "\342\224\274");
3825     n = SHOW_UTF8(n, "WACS_GEQUAL",     "\342\211\245");
3826     n = SHOW_UTF8(n, "WACS_NEQUAL",     "\342\211\240");
3827     n = SHOW_UTF8(n, "WACS_LEQUAL",     "\342\211\244");
3828
3829     n = SHOW_UTF8(n, "WACS_STERLING",   "\302\243");
3830     n = SHOW_UTF8(n, "WACS_PI",         "\317\200");
3831     n = SHOW_UTF8(n, "WACS_S1",         "\342\216\272");
3832     n = SHOW_UTF8(n, "WACS_S3",         "\342\216\273");
3833     n = SHOW_UTF8(n, "WACS_S7",         "\342\216\274");
3834     (void) SHOW_UTF8(n, "WACS_S9",      "\342\216\275");
3835     /* *INDENT-ON* */
3836
3837 }
3838
3839 /* display the wide-ACS character set */
3840 static void
3841 wide_acs_display(void)
3842 {
3843     int c = 'a';
3844     int digit = 0;
3845     int repeat = 1;
3846     int space = ' ';
3847     int pagesize = 32;
3848     chtype attr = A_NORMAL;
3849     int fg = COLOR_BLACK;
3850     int bg = COLOR_BLACK;
3851     unsigned at_code = 0;
3852     NCURSES_PAIRS_T pair = 0;
3853     void (*last_show_wacs) (int, attr_t, NCURSES_PAIRS_T) = 0;
3854     ATTR_TBL my_list[SIZEOF(attrs_to_test)];
3855     unsigned my_size = init_attr_list(my_list, term_attrs());
3856
3857     do {
3858         switch (c) {
3859         case CTRL('L'):
3860             Repaint();
3861             break;
3862         case 'a':
3863             ToggleAcs(last_show_wacs, show_wacs_chars);
3864             break;
3865 #ifdef WACS_D_PLUS
3866         case 'd':
3867             ToggleAcs(last_show_wacs, show_wacs_chars_double);
3868             break;
3869 #endif
3870 #ifdef WACS_T_PLUS
3871         case 't':
3872             ToggleAcs(last_show_wacs, show_wacs_chars_thick);
3873             break;
3874 #endif
3875         case 'w':
3876             if (pagesize == 32) {
3877                 pagesize = 256;
3878             } else {
3879                 pagesize = 32;
3880             }
3881             break;
3882         case 'x':
3883             ToggleAcs(last_show_wacs, show_wbox_chars);
3884             break;
3885         case 'u':
3886             ToggleAcs(last_show_wacs, show_utf8_chars);
3887             break;
3888         default:
3889             if (c < 256 && isdigit(c)) {
3890                 digit = (c - '0');
3891                 last_show_wacs = 0;
3892             } else if (c == '+') {
3893                 ++digit;
3894                 last_show_wacs = 0;
3895             } else if (c == '-' && digit > 0) {
3896                 --digit;
3897                 last_show_wacs = 0;
3898             } else if (c == '>' && repeat < (COLS / 4)) {
3899                 ++repeat;
3900             } else if (c == '<' && repeat > 1) {
3901                 --repeat;
3902             } else if (c == '_') {
3903                 space = (space == ' ') ? '_' : ' ';
3904                 last_show_wacs = 0;
3905             } else if (cycle_attr(c, &at_code, &attr, my_list, my_size)
3906                        || cycle_colors(c, &fg, &bg, &pair)) {
3907                 if (last_show_wacs != 0)
3908                     break;
3909             } else {
3910                 beep();
3911                 break;
3912             }
3913             break;
3914         }
3915         if (pagesize != 32) {
3916             show_paged_widechars(digit, pagesize, repeat, space, attr, pair);
3917         } else if (last_show_wacs != 0) {
3918             last_show_wacs(repeat, attr, pair);
3919         } else {
3920             show_upper_widechars(digit * 32 + 128, repeat, space, attr, pair);
3921         }
3922
3923         MvPrintw(LINES - 4, 0,
3924                  "Select: a/d/t WACS, w=all x=box, u UTF-8, ^L repaint");
3925         MvPrintw(LINES - 3, 2,
3926                  "0-9,+/- non-ASCII, </> repeat, _ space, ESC=quit");
3927         if (use_colors) {
3928             MvPrintw(LINES - 2, 2,
3929                      "v/V, f/F, b/B cycle through video attributes (%s) and color %d/%d.",
3930                      my_list[at_code].name,
3931                      fg, bg);
3932         } else {
3933             MvPrintw(LINES - 2, 2,
3934                      "v/V cycles through video attributes (%s).",
3935                      my_list[at_code].name);
3936         }
3937         refresh();
3938     } while (!isQuit(c = Getchar()));
3939
3940     Pause();
3941     erase();
3942     endwin();
3943 }
3944
3945 #endif
3946
3947 /*
3948  * Graphic-rendition test (adapted from vttest)
3949  */
3950 static void
3951 test_sgr_attributes(void)
3952 {
3953     int pass;
3954
3955     for (pass = 0; pass < 2; pass++) {
3956         chtype normal = ((pass == 0 ? A_NORMAL : A_REVERSE)) | BLANK;
3957
3958         /* Use non-default colors if possible to exercise bce a little */
3959         if (use_colors) {
3960             init_pair(1, COLOR_WHITE, COLOR_BLUE);
3961             normal |= (chtype) COLOR_PAIR(1);
3962         }
3963         bkgdset(normal);
3964         erase();
3965         MvPrintw(1, 20, "Graphic rendition test pattern:");
3966
3967         MvPrintw(4, 1, "vanilla");
3968
3969 #define set_sgr(mask) bkgdset((normal^(mask)));
3970         set_sgr(A_BOLD);
3971         MvPrintw(4, 40, "bold");
3972
3973         set_sgr(A_UNDERLINE);
3974         MvPrintw(6, 6, "underline");
3975
3976         set_sgr(A_BOLD | A_UNDERLINE);
3977         MvPrintw(6, 45, "bold underline");
3978
3979         set_sgr(A_BLINK);
3980         MvPrintw(8, 1, "blink");
3981
3982         set_sgr(A_BLINK | A_BOLD);
3983         MvPrintw(8, 40, "bold blink");
3984
3985         set_sgr(A_UNDERLINE | A_BLINK);
3986         MvPrintw(10, 6, "underline blink");
3987
3988         set_sgr(A_BOLD | A_UNDERLINE | A_BLINK);
3989         MvPrintw(10, 45, "bold underline blink");
3990
3991         set_sgr(A_REVERSE);
3992         MvPrintw(12, 1, "negative");
3993
3994         set_sgr(A_BOLD | A_REVERSE);
3995         MvPrintw(12, 40, "bold negative");
3996
3997         set_sgr(A_UNDERLINE | A_REVERSE);
3998         MvPrintw(14, 6, "underline negative");
3999
4000         set_sgr(A_BOLD | A_UNDERLINE | A_REVERSE);
4001         MvPrintw(14, 45, "bold underline negative");
4002
4003         set_sgr(A_BLINK | A_REVERSE);
4004         MvPrintw(16, 1, "blink negative");
4005
4006         set_sgr(A_BOLD | A_BLINK | A_REVERSE);
4007         MvPrintw(16, 40, "bold blink negative");
4008
4009         set_sgr(A_UNDERLINE | A_BLINK | A_REVERSE);
4010         MvPrintw(18, 6, "underline blink negative");
4011
4012         set_sgr(A_BOLD | A_UNDERLINE | A_BLINK | A_REVERSE);
4013         MvPrintw(18, 45, "bold underline blink negative");
4014
4015         bkgdset(normal);
4016         MvPrintw(LINES - 2, 1, "%s background. ", pass == 0 ? "Dark" :
4017                  "Light");
4018         clrtoeol();
4019         Pause();
4020     }
4021
4022     bkgdset(A_NORMAL | BLANK);
4023     erase();
4024     endwin();
4025 }
4026
4027 /****************************************************************************
4028  *
4029  * Windows and scrolling tester.
4030  *
4031  ****************************************************************************/
4032
4033 #define BOTLINES        4       /* number of line stolen from screen bottom */
4034
4035 typedef struct {
4036     int y, x;
4037 } pair;
4038
4039 #define FRAME struct frame
4040 FRAME
4041 {
4042     FRAME *next, *last;
4043     bool do_scroll;
4044     bool do_keypad;
4045     WINDOW *wind;
4046 };
4047
4048 #if defined(NCURSES_VERSION)
4049 #if (NCURSES_VERSION_PATCH < 20070331) && NCURSES_EXT_FUNCS
4050 #define is_keypad(win)   (win)->_use_keypad
4051 #define is_scrollok(win) (win)->_scroll
4052 #elif !defined(is_keypad)
4053 #define is_keypad(win)   FALSE
4054 #define is_scrollok(win) FALSE
4055 #endif
4056 #else
4057 #define is_keypad(win)   FALSE
4058 #define is_scrollok(win) FALSE
4059 #endif
4060
4061 static WINDOW *
4062 frame_win(FRAME * curp)
4063 {
4064     return (curp != 0) ? curp->wind : stdscr;
4065 }
4066
4067 /* We need to know if these flags are actually set, so don't look in FRAME.
4068  * These names are known to work with SVr4 curses as well as ncurses.  The
4069  * _use_keypad name does not work with Solaris 8.
4070  */
4071 static bool
4072 HaveKeypad(FRAME * curp)
4073 {
4074     WINDOW *win = frame_win(curp);
4075     (void) win;
4076     return is_keypad(win);
4077 }
4078
4079 static bool
4080 HaveScroll(FRAME * curp)
4081 {
4082     WINDOW *win = frame_win(curp);
4083     (void) win;
4084     return is_scrollok(win);
4085 }
4086
4087 static void
4088 newwin_legend(FRAME * curp)
4089 {
4090     static const struct {
4091         const char *msg;
4092         int code;
4093     } legend[] = {
4094         {
4095             "^C = create window", 0
4096         },
4097         {
4098             "^N = next window", 0
4099         },
4100         {
4101             "^P = previous window", 0
4102         },
4103         {
4104             "^F = scroll forward", 0
4105         },
4106         {
4107             "^B = scroll backward", 0
4108         },
4109         {
4110             "^K = keypad(%s)", 1
4111         },
4112         {
4113             "^S = scrollok(%s)", 2
4114         },
4115         {
4116             "^W = save window to file", 0
4117         },
4118         {
4119             "^R = restore window", 0
4120         },
4121 #if HAVE_WRESIZE
4122         {
4123             "^X = resize", 0
4124         },
4125 #endif
4126         {
4127             "^Q%s = exit", 3
4128         }
4129     };
4130     size_t n;
4131     int x;
4132     bool do_keypad = HaveKeypad(curp);
4133     bool do_scroll = HaveScroll(curp);
4134     char buf[BUFSIZ];
4135
4136     move(LINES - 4, 0);
4137     for (n = 0; n < SIZEOF(legend); n++) {
4138         switch (legend[n].code) {
4139         default:
4140             strcpy(buf, legend[n].msg);
4141             break;
4142         case 1:
4143             sprintf(buf, legend[n].msg, do_keypad ? "yes" : "no");
4144             break;
4145         case 2:
4146             sprintf(buf, legend[n].msg, do_scroll ? "yes" : "no");
4147             break;
4148         case 3:
4149             sprintf(buf, legend[n].msg, do_keypad ? "/ESC" : "");
4150             break;
4151         }
4152         x = getcurx(stdscr);
4153         addstr((COLS < (x + 3 + (int) strlen(buf))) ? "\n" : (n ? ", " : ""));
4154         addstr(buf);
4155     }
4156     clrtoeol();
4157 }
4158
4159 static void
4160 transient(FRAME * curp, NCURSES_CONST char *msg)
4161 {
4162     newwin_legend(curp);
4163     if (msg) {
4164         MvAddStr(LINES - 1, 0, msg);
4165         refresh();
4166         napms(1000);
4167     }
4168
4169     move(LINES - 1, 0);
4170     printw("%s characters are echoed, window should %sscroll.",
4171            HaveKeypad(curp) ? "Non-arrow" : "All other",
4172            HaveScroll(curp) ? "" : "not ");
4173     clrtoeol();
4174 }
4175
4176 static void
4177 newwin_report(FRAME * curp)
4178 /* report on the cursor's current position, then restore it */
4179 {
4180     WINDOW *win = frame_win(curp);
4181     int y, x;
4182
4183     if (win != stdscr)
4184         transient(curp, (char *) 0);
4185     getyx(win, y, x);
4186     move(LINES - 1, COLS - 17);
4187     printw("Y = %2d X = %2d", y, x);
4188     if (win != stdscr)
4189         refresh();
4190     else
4191         wmove(win, y, x);
4192 }
4193
4194 static pair *
4195 selectcell(int uli, int ulj, int lri, int lrj)
4196 /* arrows keys move cursor, return location at current on non-arrow key */
4197 {
4198     static pair res;            /* result cell */
4199     int si = lri - uli + 1;     /* depth of the select area */
4200     int sj = lrj - ulj + 1;     /* width of the select area */
4201     int i = 0, j = 0;           /* offsets into the select area */
4202
4203     res.y = uli;
4204     res.x = ulj;
4205     for (;;) {
4206         move(uli + i, ulj + j);
4207         newwin_report((FRAME *) 0);
4208
4209         switch (Getchar()) {
4210         case KEY_UP:
4211             i += si - 1;
4212             break;
4213         case KEY_DOWN:
4214             i++;
4215             break;
4216         case KEY_LEFT:
4217             j += sj - 1;
4218             break;
4219         case KEY_RIGHT:
4220             j++;
4221             break;
4222         case case_QUIT:
4223             return ((pair *) 0);
4224 #ifdef NCURSES_MOUSE_VERSION
4225         case KEY_MOUSE:
4226             {
4227                 MEVENT event;
4228
4229                 getmouse(&event);
4230                 if (event.y > uli && event.x > ulj) {
4231                     i = event.y - uli;
4232                     j = event.x - ulj;
4233                 } else {
4234                     beep();
4235                     break;
4236                 }
4237             }
4238             /* FALLTHRU */
4239 #endif
4240         default:
4241             res.y = uli + i;
4242             res.x = ulj + j;
4243             return (&res);
4244         }
4245         i %= si;
4246         j %= sj;
4247     }
4248 }
4249
4250 static void
4251 outerbox(pair ul, pair lr, bool onoff)
4252 /* draw or erase a box *outside* the given pair of corners */
4253 {
4254     MvAddCh(ul.y - 1, lr.x - 1, onoff ? ACS_ULCORNER : ' ');
4255     MvAddCh(ul.y - 1, lr.x + 1, onoff ? ACS_URCORNER : ' ');
4256     MvAddCh(lr.y + 1, lr.x + 1, onoff ? ACS_LRCORNER : ' ');
4257     MvAddCh(lr.y + 1, ul.x - 1, onoff ? ACS_LLCORNER : ' ');
4258     move(ul.y - 1, ul.x);
4259     hline(onoff ? ACS_HLINE : ' ', lr.x - ul.x + 1);
4260     move(ul.y, ul.x - 1);
4261     vline(onoff ? ACS_VLINE : ' ', lr.y - ul.y + 1);
4262     move(lr.y + 1, ul.x);
4263     hline(onoff ? ACS_HLINE : ' ', lr.x - ul.x + 1);
4264     move(ul.y, lr.x + 1);
4265     vline(onoff ? ACS_VLINE : ' ', lr.y - ul.y + 1);
4266 }
4267
4268 static WINDOW *
4269 getwindow(void)
4270 /* Ask user for a window definition */
4271 {
4272     WINDOW *rwindow;
4273     pair ul, lr, *tmp;
4274
4275     move(0, 0);
4276     clrtoeol();
4277     addstr("Use arrows to move cursor, anything else to mark corner 1");
4278     refresh();
4279     if ((tmp = selectcell(2, 1, LINES - BOTLINES - 2, COLS - 2)) == (pair *) 0)
4280         return ((WINDOW *) 0);
4281     memcpy(&ul, tmp, sizeof(pair));
4282     MvAddCh(ul.y - 1, ul.x - 1, ACS_ULCORNER);
4283     move(0, 0);
4284     clrtoeol();
4285     addstr("Use arrows to move cursor, anything else to mark corner 2");
4286     refresh();
4287     if ((tmp = selectcell(ul.y, ul.x, LINES - BOTLINES - 2, COLS - 2)) ==
4288         (pair *) 0)
4289         return ((WINDOW *) 0);
4290     memcpy(&lr, tmp, sizeof(pair));
4291
4292     rwindow = subwin(stdscr, lr.y - ul.y + 1, lr.x - ul.x + 1, ul.y, ul.x);
4293
4294     outerbox(ul, lr, TRUE);
4295     refresh();
4296
4297     if (rwindow != 0)
4298         wrefresh(rwindow);
4299
4300     move(0, 0);
4301     clrtoeol();
4302     return (rwindow);
4303 }
4304
4305 static void
4306 newwin_move(FRAME * curp, int dy, int dx)
4307 {
4308     WINDOW *win = frame_win(curp);
4309     int cur_y, cur_x;
4310     int max_y, max_x;
4311
4312     getyx(win, cur_y, cur_x);
4313     getmaxyx(win, max_y, max_x);
4314     if ((cur_x += dx) < 0)
4315         cur_x = 0;
4316     else if (cur_x >= max_x)
4317         cur_x = max_x - 1;
4318     if ((cur_y += dy) < 0)
4319         cur_y = 0;
4320     else if (cur_y >= max_y)
4321         cur_y = max_y - 1;
4322     wmove(win, cur_y, cur_x);
4323 }
4324
4325 static FRAME *
4326 delete_framed(FRAME * fp, bool showit)
4327 {
4328     FRAME *np = 0;
4329
4330     if (fp != 0) {
4331         fp->last->next = fp->next;
4332         fp->next->last = fp->last;
4333
4334         if (showit) {
4335             werase(fp->wind);
4336             wrefresh(fp->wind);
4337         }
4338         delwin(fp->wind);
4339
4340         np = (fp == fp->next) ? 0 : fp->next;
4341         free(fp);
4342     }
4343     return np;
4344 }
4345
4346 static void
4347 acs_and_scroll(void)
4348 /* Demonstrate windows */
4349 {
4350     int c;
4351     FRAME *current = (FRAME *) 0, *neww;
4352     WINDOW *usescr;
4353 #if HAVE_PUTWIN && HAVE_GETWIN
4354     FILE *fp;
4355 #endif
4356
4357 #define DUMPFILE        "screendump"
4358
4359 #ifdef NCURSES_MOUSE_VERSION
4360     mousemask(BUTTON1_CLICKED, (mmask_t *) 0);
4361 #endif
4362     c = CTRL('C');
4363     raw();
4364     do {
4365         transient((FRAME *) 0, (char *) 0);
4366         switch (c) {
4367         case CTRL('C'):
4368             if ((neww = typeCalloc(FRAME, (size_t) 1)) == 0) {
4369                 failed("acs_and_scroll");
4370                 goto breakout;
4371             }
4372             if ((neww->wind = getwindow()) == (WINDOW *) 0) {
4373                 failed("acs_and_scroll");
4374                 free(neww);
4375                 goto breakout;
4376             }
4377
4378             if (current == 0) { /* First element,  */
4379                 neww->next = neww;      /*   so point it at itself */
4380                 neww->last = neww;
4381             } else {
4382                 neww->next = current->next;
4383                 neww->last = current;
4384                 neww->last->next = neww;
4385                 neww->next->last = neww;
4386             }
4387             current = neww;
4388             /* SVr4 curses sets the keypad on all newly-created windows to
4389              * false.  Someone reported that PDCurses makes new windows inherit
4390              * this flag.  Remove the following 'keypad()' call to test this
4391              */
4392             keypad(current->wind, TRUE);
4393             current->do_keypad = HaveKeypad(current);
4394             current->do_scroll = HaveScroll(current);
4395             break;
4396
4397         case CTRL('N'): /* go to next window */
4398             if (current)
4399                 current = current->next;
4400             break;
4401
4402         case CTRL('P'): /* go to previous window */
4403             if (current)
4404                 current = current->last;
4405             break;
4406
4407         case CTRL('F'): /* scroll current window forward */
4408             if (current)
4409                 wscrl(frame_win(current), 1);
4410             break;
4411
4412         case CTRL('B'): /* scroll current window backwards */
4413             if (current)
4414                 wscrl(frame_win(current), -1);
4415             break;
4416
4417         case CTRL('K'): /* toggle keypad mode for current */
4418             if (current) {
4419                 current->do_keypad = !current->do_keypad;
4420                 keypad(current->wind, current->do_keypad);
4421             }
4422             break;
4423
4424         case CTRL('S'):
4425             if (current) {
4426                 current->do_scroll = !current->do_scroll;
4427                 scrollok(current->wind, current->do_scroll);
4428             }
4429             break;
4430
4431 #if HAVE_PUTWIN && HAVE_GETWIN
4432         case CTRL('W'): /* save and delete window */
4433             if ((current != 0) && (current == current->next)) {
4434                 transient(current, "Will not save/delete ONLY window");
4435                 break;
4436             } else if ((fp = fopen(DUMPFILE, "w")) == (FILE *) 0) {
4437                 transient(current, "Can't open screen dump file");
4438             } else {
4439                 (void) putwin(frame_win(current), fp);
4440                 (void) fclose(fp);
4441
4442                 current = delete_framed(current, TRUE);
4443             }
4444             break;
4445
4446         case CTRL('R'): /* restore window */
4447             if ((fp = fopen(DUMPFILE, "r")) == (FILE *) 0) {
4448                 transient(current, "Can't open screen dump file");
4449             } else {
4450                 if ((neww = typeCalloc(FRAME, (size_t) 1)) != 0) {
4451
4452                     neww->next = current ? current->next : 0;
4453                     neww->last = current;
4454                     if (neww->last != 0)
4455                         neww->last->next = neww;
4456                     if (neww->next != 0)
4457                         neww->next->last = neww;
4458
4459                     neww->wind = getwin(fp);
4460
4461                     wrefresh(neww->wind);
4462                 } else {
4463                     failed("acs_and_scroll");
4464                 }
4465                 (void) fclose(fp);
4466             }
4467             break;
4468 #endif
4469
4470 #if HAVE_WRESIZE
4471         case CTRL('X'): /* resize window */
4472             if (current) {
4473                 pair *tmp, ul, lr;
4474                 int i, mx, my;
4475
4476                 move(0, 0);
4477                 clrtoeol();
4478                 addstr("Use arrows to move cursor, anything else to mark new corner");
4479                 refresh();
4480
4481                 getbegyx(current->wind, ul.y, ul.x);
4482
4483                 tmp = selectcell(ul.y, ul.x, LINES - BOTLINES - 2, COLS - 2);
4484           &nbs