ncurses 5.3
[ncurses.git] / test / ncurses.c
index 4bd8552e9c24de8606f19095a5d8066ca8da7ff9..b4bac67fdaad2fadd9bab4fb40725681eb1b5e05 100644 (file)
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc.              *
+ * Copyright (c) 1998-2001,2002 Free Software Foundation, Inc.              *
  *                                                                          *
  * Permission is hereby granted, free of charge, to any person obtaining a  *
  * copy of this software and associated documentation files (the            *
@@ -38,22 +38,17 @@ DESCRIPTION
 
 AUTHOR
    Author: Eric S. Raymond <esr@snark.thyrsus.com> 1993
+           Thomas E. Dickey (beginning revision 1.27 in 1996).
 
-$Id: ncurses.c,v 1.130 2000/07/07 11:05:16 tom Exp $
+$Id: ncurses.c,v 1.180 2002/09/15 00:39:33 tom Exp $
 
 ***************************************************************************/
 
-#include <test.priv.h>
-
 #include <stdio.h>
 #include <ctype.h>
-#include <string.h>
 #include <assert.h>
-#include <signal.h>
 
-#if HAVE_LOCALE_H
-#include <locale.h>
-#endif
+#include <test.priv.h>
 
 #if HAVE_GETTIMEOFDAY
 #if HAVE_SYS_TIME_H && HAVE_SYS_TIME_SELECT
@@ -64,7 +59,7 @@ $Id: ncurses.c,v 1.130 2000/07/07 11:05:16 tom Exp $
 #endif
 #endif
 
-#if HAVE_PANEL_H
+#if HAVE_PANEL_H && HAVE_LIBPANEL
 #define USE_LIBPANEL 1
 #include <panel.h>
 #else
@@ -92,33 +87,56 @@ static int save_trace = TRACE_ORDINARY | TRACE_CALLS;
 extern int _nc_tracing;
 #endif
 
-#if !HAVE_NAPMS
-#define HAVE_NAPMS 1
-#endif
-
 #else
 
 #define mmask_t chtype         /* not specified in XSI */
-#define attr_t chtype          /* not specified in XSI */
-#define ACS_S3          (acs_map['p']) /* scan line 3 */
-#define ACS_S7          (acs_map['r']) /* scan line 7 */
-#define ACS_LEQUAL      (acs_map['y']) /* less/equal */
-#define ACS_GEQUAL      (acs_map['z']) /* greater/equal */
-#define ACS_PI          (acs_map['{']) /* Pi */
-#define ACS_NEQUAL      (acs_map['|']) /* not equal */
-#define ACS_STERLING    (acs_map['}']) /* UK pound sign */
+
+#ifdef CURSES_ACS_ARRAY
+#define ACS_S3          (CURSES_ACS_ARRAY['p'])                /* scan line 3 */
+#define ACS_S7          (CURSES_ACS_ARRAY['r'])                /* scan line 7 */
+#define ACS_LEQUAL      (CURSES_ACS_ARRAY['y'])                /* less/equal */
+#define ACS_GEQUAL      (CURSES_ACS_ARRAY['z'])                /* greater/equal */
+#define ACS_PI          (CURSES_ACS_ARRAY['{'])                /* Pi */
+#define ACS_NEQUAL      (CURSES_ACS_ARRAY['|'])                /* not equal */
+#define ACS_STERLING    (CURSES_ACS_ARRAY['}'])                /* UK pound sign */
+#else
+#define ACS_S3          (A_ALTCHARSET + 'p')   /* scan line 3 */
+#define ACS_S7          (A_ALTCHARSET + 'r')   /* scan line 7 */
+#define ACS_LEQUAL      (A_ALTCHARSET + 'y')   /* less/equal */
+#define ACS_GEQUAL      (A_ALTCHARSET + 'z')   /* greater/equal */
+#define ACS_PI          (A_ALTCHARSET + '{')   /* Pi */
+#define ACS_NEQUAL      (A_ALTCHARSET + '|')   /* not equal */
+#define ACS_STERLING    (A_ALTCHARSET + '}')   /* UK pound sign */
+#endif
+
+#ifdef CURSES_WACS_ARRAY
+#define WACS_S3         (&(CURSES_WACS_ARRAY['p']))    /* scan line 3 */
+#define WACS_S7         (&(CURSES_WACS_ARRAY['r']))    /* scan line 7 */
+#define WACS_LEQUAL     (&(CURSES_WACS_ARRAY['y']))    /* less/equal */
+#define WACS_GEQUAL     (&(CURSES_WACS_ARRAY['z']))    /* greater/equal */
+#define WACS_PI         (&(CURSES_WACS_ARRAY['{']))    /* Pi */
+#define WACS_NEQUAL     (&(CURSES_WACS_ARRAY['|']))    /* not equal */
+#define WACS_STERLING   (&(CURSES_WACS_ARRAY['}']))    /* UK pound sign */
+#endif
 
 #endif
 
 #define P(string)      printw("%s\n", string)
-#ifndef CTRL
-#define CTRL(x)                ((x) & 0x1f)
+#ifdef CTRL
+#undef CTRL
 #endif
+#define CTRL(x)                ((x) & 0x1f)
 
 #define QUIT           CTRL('Q')
 #define ESCAPE         CTRL('[')
 #define BLANK          ' '     /* this is the background character */
 
+#undef max_colors
+static int max_colors;         /* the actual number of colors we'll use */
+
+#undef max_pairs
+static int max_pairs;          /* ...and the number of color pairs */
+
 /* The behavior of mvhline, mvvline for negative/zero length is unspecified,
  * though we can rely on negative x/y values to stop the macro.
  */
@@ -163,6 +181,33 @@ wGetchar(WINDOW *win)
 }
 #define Getchar() wGetchar(stdscr)
 
+#if USE_WIDEC_SUPPORT
+static int
+wGet_wchar(WINDOW *win, wint_t * result)
+{
+    int c;
+#ifdef TRACE
+    while ((c = wget_wch(win, result)) == CTRL('T')) {
+       if (_nc_tracing) {
+           save_trace = _nc_tracing;
+           _tracef("TOGGLE-TRACING OFF");
+           _nc_tracing = 0;
+       } else {
+           _nc_tracing = save_trace;
+       }
+       trace(_nc_tracing);
+       if (_nc_tracing)
+           _tracef("TOGGLE-TRACING ON");
+    }
+#else
+    c = wget_wch(win, result);
+#endif
+    return c;
+}
+#define Get_wchar(result) wGet_wchar(stdscr, result)
+
+#endif
+
 static void
 Pause(void)
 {
@@ -198,7 +243,7 @@ mouse_decode(MEVENT const *ep)
     static char buf[80];
 
     (void) sprintf(buf, "id %2d  at (%2d, %2d, %2d) state %4lx = {",
-       ep->id, ep->x, ep->y, ep->z, ep->bstate);
+                  ep->id, ep->x, ep->y, ep->z, ep->bstate);
 
 #define SHOW(m, s) if ((ep->bstate & m)==m) {strcat(buf,s); strcat(buf, ", ");}
     SHOW(BUTTON1_RELEASED, "release-1");
@@ -246,122 +291,537 @@ mouse_decode(MEVENT const *ep)
  ****************************************************************************/
 
 static void
-getch_test(void)
-/* test the keypad feature */
+setup_getch(WINDOW *win, bool flags[])
 {
-    char buf[BUFSIZ];
-    int c;
-    int incount = 0, firsttime = 0;
-    bool blocking = TRUE;
+    keypad(win, flags['k']);   /* should be redundant, but for testing */
+    meta(win, flags['m']);     /* force this to a known state */
+    if (flags['e'])
+       echo();
+    else
+       noecho();
+}
+
+static void
+wgetch_help(WINDOW *win, bool flags[])
+{
+    static const char *help[] =
+    {
+       "e -- toggle echo mode"
+       ,"g -- triggers a getstr test"
+       ,"k -- toggle keypad/literal mode"
+       ,"m -- toggle meta (7-bit/8-bit) mode"
+       ,"q -- quit (x also exits)"
+       ,"s -- shell out\n"
+       ,"w -- create a new window"
+#ifdef SIGTSTP
+       ,"z -- suspend this process"
+#endif
+    };
     int y, x;
+    unsigned chk = ((SIZEOF(help) + 1) / 2);
+    unsigned n;
 
-    refresh();
+    getyx(win, y, x);
+    move(0, 0);
+    printw("Type any key to see its %s value.  Also:\n",
+          flags['k'] ? "keypad" : "literal");
+    for (n = 0; n < SIZEOF(help); ++n) {
+       int row = 1 + (n % chk);
+       int col = (n >= chk) ? COLS / 2 : 0;
+       int flg = ((strstr(help[n], "toggle") != 0)
+                  && (flags[UChar(*help[n])] != FALSE));
+       if (flg)
+           standout();
+       mvprintw(row, col, "%s", help[n]);
+       if (col == 0)
+           clrtoeol();
+       if (flg)
+           standend();
+    }
+    wrefresh(stdscr);
+    wmove(win, y, x);
+}
 
-#ifdef NCURSES_MOUSE_VERSION
-    mousemask(ALL_MOUSE_EVENTS, (mmask_t *) 0);
-#endif
+static void
+wgetch_wrap(WINDOW *win, int first_y)
+{
+    int last_y = getmaxy(win) - 1;
+    int y = getcury(win) + 1;
 
-    (void) printw("Delay in 10ths of a second (<CR> for blocking input)? ");
-    echo();
-    getstr(buf);
-    noecho();
-    nonl();
+    if (y >= last_y)
+       y = first_y;
+    wmove(win, y, 0);
+    wclrtoeol(win);
+}
 
-    if (isdigit(buf[0])) {
-       timeout(atoi(buf) * 100);
-       blocking = FALSE;
+#if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
+typedef struct {
+    WINDOW *text;
+    WINDOW *frame;
+} WINSTACK;
+
+static WINSTACK *winstack = 0;
+static unsigned len_winstack = 0;
+
+static void
+remember_boxes(unsigned level, WINDOW *txt_win, WINDOW *box_win)
+{
+    unsigned need = (level + 1) * 2;
+
+    if (winstack == 0) {
+       len_winstack = 20;
+       winstack = malloc(len_winstack * sizeof(WINSTACK));
+    } else if (need >= len_winstack) {
+       len_winstack = need;
+       winstack = realloc(winstack, len_winstack * sizeof(WINSTACK));
     }
+    winstack[level].text = txt_win;
+    winstack[level].frame = box_win;
+}
+
+/*
+ * For wgetch_test(), we create pairs of windows - one for a box, one for text.
+ * Resize both and paint the box in the parent.
+ */
+static void
+resize_boxes(int level, WINDOW *win)
+{
+    unsigned n;
+    int base = 5;
+    int high = LINES - base;
+    int wide = COLS;
+
+    touchwin(stdscr);
+    wnoutrefresh(stdscr);
+
+    /* FIXME: this chunk should be done in resizeterm() */
+    slk_touch();
+    slk_clear();
+    slk_noutrefresh();
+
+    for (n = 0; (int) n < level; ++n) {
+       wresize(winstack[n].frame, high, wide);
+       wresize(winstack[n].text, high - 2, wide - 2);
+       high -= 2;
+       wide -= 2;
+       werase(winstack[n].text);
+       box(winstack[n].frame, 0, 0);
+       wnoutrefresh(winstack[n].frame);
+       wprintw(winstack[n].text,
+               "size %dx%d\n",
+               getmaxy(winstack[n].text),
+               getmaxx(winstack[n].text));
+       wnoutrefresh(winstack[n].text);
+       if (winstack[n].text == win)
+           break;
+    }
+    doupdate();
+}
+#else
+#define remember_boxes(level,text,frame)       /* nothing */
+#endif
+
+static void
+wgetch_test(int level, WINDOW *win, int delay)
+{
+    char buf[BUFSIZ];
+    int first_y, first_x;
+    int c;
+    int incount = 0;
+    bool flags[256];
+    bool blocking = (delay < 0);
+    int y, x;
+
+    memset(flags, FALSE, sizeof(flags));
+    flags['k'] = (win == stdscr);
+
+    setup_getch(win, flags);
+    wtimeout(win, delay);
+    getyx(win, first_y, first_x);
+
+    wgetch_help(win, flags);
+    wsetscrreg(win, first_y, getmaxy(win) - 1);
+    scrollok(win, TRUE);
 
-    c = '?';
-    raw();
     for (;;) {
-       if (firsttime++) {
-           printw("Key pressed: %04o ", c);
+       while ((c = wGetchar(win)) == ERR) {
+           incount++;
+           if (blocking) {
+               (void) wprintw(win, "%05d: input error", incount);
+               break;
+           } else {
+               (void) wprintw(win, "%05d: input timed out", incount);
+           }
+           wgetch_wrap(win, first_y);
+       }
+       if (c == ERR && blocking) {
+           wprintw(win, "ERR");
+           wgetch_wrap(win, first_y);
+       } else if (c == 'x' || c == 'q') {
+           break;
+       } else if (c == 'e') {
+           flags['e'] = !flags['e'];
+           setup_getch(win, flags);
+           wgetch_help(win, flags);
+       } else if (c == 'g') {
+           waddstr(win, "getstr test: ");
+           echo();
+           wgetnstr(win, buf, sizeof(buf) - 1);
+           noecho();
+           wprintw(win, "I saw %d characters:\n\t`%s'.", (int) strlen(buf), buf);
+           wclrtoeol(win);
+           wgetch_wrap(win, first_y);
+       } else if (c == 'k') {
+           flags['k'] = !flags['k'];
+           setup_getch(win, flags);
+           wgetch_help(win, flags);
+       } else if (c == 'm') {
+           flags['m'] = !flags['m'];
+           setup_getch(win, flags);
+           wgetch_help(win, flags);
+       } else if (c == 's') {
+           ShellOut(TRUE);
+       } else if (c == 'w') {
+           int high = getmaxy(win) - 1 - first_y + 1;
+           int wide = getmaxx(win) - first_x;
+           int old_y, old_x;
+           int new_y = first_y + getbegy(win);
+           int new_x = first_x + getbegx(win);
+
+           getyx(win, old_y, old_x);
+           if (high > 2 && wide > 2) {
+               WINDOW *wb = newwin(high, wide, new_y, new_x);
+               WINDOW *wi = newwin(high - 2, wide - 2, new_y + 1, new_x + 1);
+
+               box(wb, 0, 0);
+               wrefresh(wb);
+               wmove(wi, 0, 0);
+               remember_boxes(level, wi, wb);
+               wgetch_test(level + 1, wi, delay);
+               delwin(wi);
+               delwin(wb);
+
+               wgetch_help(win, flags);
+               wmove(win, old_y, old_x);
+               touchwin(win);
+               wrefresh(win);
+               doupdate();
+           }
+#ifdef SIGTSTP
+       } else if (c == 'z') {
+           kill(getpid(), SIGTSTP);
+#endif
+       } else {
+           wprintw(win, "Key pressed: %04o ", c);
 #ifdef NCURSES_MOUSE_VERSION
            if (c == KEY_MOUSE) {
                MEVENT event;
 
                getmouse(&event);
-               printw("KEY_MOUSE, %s\n", mouse_decode(&event));
+               wprintw(win, "KEY_MOUSE, %s", mouse_decode(&event));
+               getyx(win, y, x);
+               move(event.y, event.x);
+               addch('*');
+               wmove(win, y, x);
            } else
 #endif /* NCURSES_MOUSE_VERSION */
            if (c >= KEY_MIN) {
-               (void) addstr(keyname(c));
-               addch('\n');
+#if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE
+               if (c == KEY_RESIZE) {
+                   resize_boxes(level, win);
+               }
+#endif
+               (void) waddstr(win, keyname(c));
            } else if (c > 0x80) {
                int c2 = (c & 0x7f);
                if (isprint(c2))
-                   (void) printw("M-%c", c2);
+                   (void) wprintw(win, "M-%c", c2);
                else
-                   (void) printw("M-%s", unctrl(c2));
-               addstr(" (high-half character)\n");
+                   (void) wprintw(win, "M-%s", unctrl(c2));
+               waddstr(win, " (high-half character)");
            } else {
                if (isprint(c))
-                   (void) printw("%c (ASCII printable character)\n", c);
+                   (void) wprintw(win, "%c (ASCII printable character)", c);
                else
-                   (void) printw("%s (ASCII control character)\n", unctrl(c));
+                   (void) wprintw(win, "%s (ASCII control character)",
+                                  unctrl(c));
            }
-           getyx(stdscr, y, x);
-           if (y >= LINES - 1)
-               move(0, 0);
-           clrtoeol();
+           wgetch_wrap(win, first_y);
        }
+    }
 
-       if (c == 'g') {
-           addstr("getstr test: ");
-           echo();
-           getstr(buf);
-           noecho();
-           printw("I saw `%s'.\n", buf);
-       }
-       if (c == 's') {
-           ShellOut(TRUE);
-       }
-       if (c == 'x' || c == 'q' || (c == ERR && blocking))
-           break;
-       if (c == '?') {
-           addstr("Type any key to see its keypad value.  Also:\n");
-           addstr("g -- triggers a getstr test\n");
-           addstr("s -- shell out\n");
-           addstr("q -- quit\n");
-           addstr("? -- repeats this help message\n");
-       }
+    wtimeout(win, -1);
+}
 
-       while ((c = Getchar()) == ERR)
-           if (!blocking)
-               (void) printw("%05d: input timed out\n", incount++);
-           else {
-               (void) printw("%05d: input error\n", incount++);
-               break;
-           }
+static int
+begin_getch_test(void)
+{
+    char buf[BUFSIZ];
+    int delay;
+
+    refresh();
+
+#ifdef NCURSES_MOUSE_VERSION
+    mousemask(ALL_MOUSE_EVENTS, (mmask_t *) 0);
+#endif
+
+    (void) printw("Delay in 10ths of a second (<CR> for blocking input)? ");
+    echo();
+    getnstr(buf, sizeof(buf) - 1);
+    noecho();
+    nonl();
+
+    if (isdigit(UChar(buf[0]))) {
+       delay = atoi(buf) * 100;
+    } else {
+       delay = -1;
     }
+    raw();
+    move(5, 0);
+    return delay;
+}
 
+static void
+finish_getch_test(void)
+{
 #ifdef NCURSES_MOUSE_VERSION
     mousemask(0, (mmask_t *) 0);
 #endif
-    timeout(-1);
     erase();
     noraw();
     nl();
     endwin();
 }
 
+static void
+getch_test(void)
+{
+    int delay = begin_getch_test();
+    wgetch_test(0, stdscr, delay);
+    finish_getch_test();
+}
+
+#if USE_WIDEC_SUPPORT
+/*
+ * For wgetch_test(), we create pairs of windows - one for a box, one for text.
+ * Resize both and paint the box in the parent.
+ */
+static void
+resize_wide_boxes(int level, WINDOW *win)
+{
+    unsigned n;
+    int base = 5;
+    int high = LINES - base;
+    int wide = COLS;
+
+    touchwin(stdscr);
+    wnoutrefresh(stdscr);
+
+    /* FIXME: this chunk should be done in resizeterm() */
+    slk_touch();
+    slk_clear();
+    slk_noutrefresh();
+
+    for (n = 0; (int) n < level; ++n) {
+       wresize(winstack[n].frame, high, wide);
+       wresize(winstack[n].text, high - 2, wide - 2);
+       high -= 2;
+       wide -= 2;
+       werase(winstack[n].text);
+       box_set(winstack[n].frame, 0, 0);
+       wnoutrefresh(winstack[n].frame);
+       wprintw(winstack[n].text,
+               "size %dx%d\n",
+               getmaxy(winstack[n].text),
+               getmaxx(winstack[n].text));
+       wnoutrefresh(winstack[n].text);
+       if (winstack[n].text == win)
+           break;
+    }
+    doupdate();
+}
+
+static void
+wget_wch_test(int level, WINDOW *win, int delay)
+{
+    char buf[BUFSIZ];
+    int first_y, first_x;
+    wint_t c;
+    int incount = 0;
+    bool flags[256];
+    bool blocking = (delay < 0);
+    int y, x, code;
+
+    memset(flags, FALSE, sizeof(flags));
+    flags['k'] = (win == stdscr);
+
+    setup_getch(win, flags);
+    wtimeout(win, delay);
+    getyx(win, first_y, first_x);
+
+    wgetch_help(win, flags);
+    wsetscrreg(win, first_y, getmaxy(win) - 1);
+    scrollok(win, TRUE);
+
+    for (;;) {
+       while ((code = wGet_wchar(win, &c)) == ERR) {
+           incount++;
+           if (blocking) {
+               (void) wprintw(win, "%05d: input error", incount);
+               break;
+           } else {
+               (void) wprintw(win, "%05d: input timed out", incount);
+           }
+           wgetch_wrap(win, first_y);
+       }
+       if (code == ERR && blocking) {
+           wprintw(win, "ERR");
+           wgetch_wrap(win, first_y);
+       } else if (c == 'x' || c == 'q') {
+           break;
+       } else if (c == 'e') {
+           flags['e'] = !flags['e'];
+           setup_getch(win, flags);
+           wgetch_help(win, flags);
+       } else if (c == 'g') {
+           waddstr(win, "getstr test: ");
+           echo();
+           wgetnstr(win, buf, sizeof(buf) - 1);
+           noecho();
+           wprintw(win, "I saw %d characters:\n\t`%s'.", strlen(buf), buf);
+           wclrtoeol(win);
+           wgetch_wrap(win, first_y);
+       } else if (c == 'k') {
+           flags['k'] = !flags['k'];
+           setup_getch(win, flags);
+           wgetch_help(win, flags);
+       } else if (c == 'm') {
+           flags['m'] = !flags['m'];
+           setup_getch(win, flags);
+           wgetch_help(win, flags);
+       } else if (c == 's') {
+           ShellOut(TRUE);
+       } else if (c == 'w') {
+           int high = getmaxy(win) - 1 - first_y + 1;
+           int wide = getmaxx(win) - first_x;
+           int old_y, old_x;
+           int new_y = first_y + getbegy(win);
+           int new_x = first_x + getbegx(win);
+
+           getyx(win, old_y, old_x);
+           if (high > 2 && wide > 2) {
+               WINDOW *wb = newwin(high, wide, new_y, new_x);
+               WINDOW *wi = newwin(high - 2, wide - 2, new_y + 1, new_x + 1);
+
+               box_set(wb, 0, 0);
+               wrefresh(wb);
+               wmove(wi, 0, 0);
+               remember_boxes(level, wi, wb);
+               wget_wch_test(level + 1, wi, delay);
+               delwin(wi);
+               delwin(wb);
+
+               wgetch_help(win, flags);
+               wmove(win, old_y, old_x);
+               touchwin(win);
+               wrefresh(win);
+           }
+#ifdef SIGTSTP
+       } else if (c == 'z') {
+           kill(getpid(), SIGTSTP);
+#endif
+       } else {
+           wprintw(win, "Key pressed: %04o ", c);
+#ifdef NCURSES_MOUSE_VERSION
+           if (c == KEY_MOUSE) {
+               MEVENT event;
+
+               getmouse(&event);
+               wprintw(win, "KEY_MOUSE, %s", mouse_decode(&event));
+               getyx(win, y, x);
+               move(event.y, event.x);
+               addch('*');
+               wmove(win, y, x);
+           } else
+#endif /* NCURSES_MOUSE_VERSION */
+           if (code == KEY_CODE_YES) {
+#ifdef KEY_RESIZE
+               if (c == KEY_RESIZE) {
+                   resize_wide_boxes(level, win);
+               }
+#endif
+               (void) waddstr(win, key_name(c));
+           } else {
+               if (c < 256 && iscntrl(c)) {
+                   (void) wprintw(win, "%s (control character)", unctrl(c));
+               } else {
+                   wchar_t c2 = c;
+                   waddnwstr(win, &c2, 1);
+                   (void) wprintw(win, " = %#x (printable character)", c);
+               }
+           }
+           wgetch_wrap(win, first_y);
+       }
+    }
+
+    wtimeout(win, -1);
+}
+
+static void
+get_wch_test(void)
+{
+    int delay = begin_getch_test();
+    wget_wch_test(0, stdscr, delay);
+    finish_getch_test();
+}
+#endif
+
+/****************************************************************************
+ *
+ * Character attributes test
+ *
+ ****************************************************************************/
+
 static int
-show_attr(int row, int skip, chtype attr, const char *name, bool once)
+show_attr(int row, int skip, chtype attr, const char *name)
 {
+    static const char *string = "abcde fghij klmno pqrst uvwxy z";
     int ncv = tigetnum("ncv");
 
     mvprintw(row, 8, "%s mode:", name);
     mvprintw(row, 24, "|");
     if (skip)
        printw("%*s", skip, " ");
-    if (once)
-       attron(attr);
-    else
-       attrset(attr);
-    addstr("abcde fghij klmno pqrst uvwxy z");
-    if (once)
-       attroff(attr);
+    attrset(attr);
+    /*
+     * If we're to write a string in the alternate character set, it is not
+     * sufficient to just set A_ALTCHARSET.  We have to perform the mapping
+     * that corresponds.  This is not needed for vt100-compatible devices
+     * because the acs_map[] is 1:1, but for PC-style devices such as Linux
+     * console, the acs_map[] is scattered about the range.
+     *
+     * The addch/addstr functions do not themselves do this mapping, since it
+     * is possible to turn off the A_ALTCHARSET flag for the characters which
+     * are added, and it would be an unexpected result to have the mapped
+     * characters visible on the screen.
+     *
+     * This example works because the indices into acs_map[] are mostly from
+     * the lowercase characters.
+     */
+    if (attr & A_ALTCHARSET) {
+       const char *s = string;
+       while (*s) {
+           int ch = *s++;
+#ifdef CURSES_ACS_ARRAY
+           if ((ch = CURSES_ACS_ARRAY[ch]) == 0)
+               ch = ' ';
+#endif
+           addch(ch);
+       }
+    } else {
+       addstr(string);
+    }
+    attroff(attr);
     if (skip)
        printw("%*s", skip, " ");
     printw("|");
@@ -369,7 +829,7 @@ show_attr(int row, int skip, chtype attr, const char *name, bool once)
        if (!(termattrs() & attr)) {
            printw(" (N/A)");
        } else if (ncv > 0 && (getbkgd(stdscr) & A_COLOR)) {
-           static const attr_t table[] =
+           static const chtype table[] =
            {
                A_STANDOUT,
                A_UNDERLINE,
@@ -383,7 +843,7 @@ show_attr(int row, int skip, chtype attr, const char *name, bool once)
            };
            unsigned n;
            bool found = FALSE;
-           for (n = 0; n < sizeof(table) / sizeof(table[0]); n++) {
+           for (n = 0; n < SIZEOF(table); n++) {
                if ((table[n] & attr) != 0
                    && ((1 << n) & ncv) != 0) {
                    found = TRUE;
@@ -398,19 +858,23 @@ show_attr(int row, int skip, chtype attr, const char *name, bool once)
 }
 
 static bool
-attr_getc(int *skip, int *fg, int *bg)
+attr_getc(int *skip, int *fg, int *bg, int *ac)
 {
     int ch = Getchar();
 
     if (isdigit(ch)) {
        *skip = (ch - '0');
-       return TRUE;
     } else if (ch == CTRL('L')) {
        touchwin(stdscr);
        touchwin(curscr);
-       return TRUE;
     } else if (has_colors()) {
        switch (ch) {
+       case 'a':
+           *ac = 0;
+           break;
+       case 'A':
+           *ac = A_ALTCHARSET;
+           break;
        case 'f':
            *fg = (*fg + 1);
            break;
@@ -426,17 +890,27 @@ attr_getc(int *skip, int *fg, int *bg)
        default:
            return FALSE;
        }
-       if (*fg >= COLORS)
+       if (*fg >= max_colors)
            *fg = 0;
        if (*fg < 0)
-           *fg = COLORS - 1;
-       if (*bg >= COLORS)
+           *fg = max_colors - 1;
+       if (*bg >= max_colors)
            *bg = 0;
        if (*bg < 0)
-           *bg = COLORS - 1;
-       return TRUE;
+           *bg = max_colors - 1;
+    } else {
+       switch (ch) {
+       case 'a':
+           *ac = 0;
+           break;
+       case 'A':
+           *ac = A_ALTCHARSET;
+           break;
+       default:
+           return FALSE;
+       }
     }
-    return FALSE;
+    return TRUE;
 }
 
 static void
@@ -447,7 +921,8 @@ attr_test(void)
     int skip = tigetnum("xmc");
     int fg = COLOR_BLACK;      /* color pair 0 is special */
     int bg = COLOR_BLACK;
-    bool *pairs = (bool *) calloc(COLOR_PAIRS, sizeof(bool));
+    int ac = 0;
+    bool *pairs = (bool *) calloc(max_pairs, sizeof(bool));
     pairs[0] = TRUE;
 
     if (skip < 0)
@@ -460,40 +935,45 @@ attr_test(void)
        int normal = A_NORMAL | BLANK;
 
        if (has_colors()) {
-           int pair = (fg * COLORS) + bg;
+           int pair = (fg * max_colors) + bg;
            if (!pairs[pair]) {
                init_pair(pair, fg, bg);
                pairs[pair] = TRUE;
            }
            normal |= COLOR_PAIR(pair);
        }
+       bkgd(normal);
        bkgdset(normal);
        erase();
 
+       box(stdscr, 0, 0);
        mvaddstr(0, 20, "Character attribute test display");
 
-       row = show_attr(row, n, A_STANDOUT, "STANDOUT", TRUE);
-       row = show_attr(row, n, A_REVERSE, "REVERSE", TRUE);
-       row = show_attr(row, n, A_BOLD, "BOLD", TRUE);
-       row = show_attr(row, n, A_UNDERLINE, "UNDERLINE", TRUE);
-       row = show_attr(row, n, A_DIM, "DIM", TRUE);
-       row = show_attr(row, n, A_BLINK, "BLINK", TRUE);
-       row = show_attr(row, n, A_PROTECT, "PROTECT", TRUE);
-       row = show_attr(row, n, A_INVIS, "INVISIBLE", TRUE);
-       row = show_attr(row, n, A_NORMAL, "NORMAL", FALSE);
+       row = show_attr(row, n, ac | A_STANDOUT, "STANDOUT");
+       row = show_attr(row, n, ac | A_REVERSE, "REVERSE");
+       row = show_attr(row, n, ac | A_BOLD, "BOLD");
+       row = show_attr(row, n, ac | A_UNDERLINE, "UNDERLINE");
+       row = show_attr(row, n, ac | A_DIM, "DIM");
+       row = show_attr(row, n, ac | A_BLINK, "BLINK");
+       row = show_attr(row, n, ac | A_PROTECT, "PROTECT");
+       row = show_attr(row, n, ac | A_INVIS, "INVISIBLE");
+       row = show_attr(row, n, ac | A_NORMAL, "NORMAL");
 
        mvprintw(row, 8,
-           "This terminal does %shave the magic-cookie glitch",
-           tigetnum("xmc") > -1 ? "" : "not ");
+                "This terminal does %shave the magic-cookie glitch",
+                tigetnum("xmc") > -1 ? "" : "not ");
        mvprintw(row + 1, 8,
-           "Enter a digit to set gaps on each side of displayed attributes");
+                "Enter a digit to set gaps on each side of displayed attributes");
        mvprintw(row + 2, 8,
-           "^L = repaint");
+                "^L = repaint");
        if (has_colors())
-           printw(".  f/F/b/F toggle colors (now %d/%d)", fg, bg);
+           printw(".  f/F/b/F toggle colors (now %d/%d), a/A altcharset (%d)",
+                  fg, bg, ac != 0);
+       else
+           printw(".  a/A altcharset (%d)", ac != 0);
 
        refresh();
-    } while (attr_getc(&n, &fg, &bg));
+    } while (attr_getc(&n, &fg, &bg, &ac));
 
     free((char *) pairs);
     bkgdset(A_NORMAL | BLANK);
@@ -507,7 +987,7 @@ attr_test(void)
  *
  ****************************************************************************/
 
-static NCURSES_CONST char *color_names[] =
+static NCURSES_CONST char *the_color_names[] =
 {
     "black",
     "red",
@@ -530,10 +1010,10 @@ static NCURSES_CONST char *color_names[] =
 static void
 show_color_name(int y, int x, int color)
 {
-    if (COLORS > 8)
+    if (max_colors > 8)
        mvprintw(y, x, "%02d   ", color);
     else
-       mvaddstr(y, x, color_names[color]);
+       mvaddstr(y, x, the_color_names[color]);
 }
 
 static void
@@ -547,29 +1027,30 @@ color_test(void)
     refresh();
     (void) printw("There are %d color pairs\n", COLOR_PAIRS);
 
-    width = (COLORS > 8) ? 4 : 8;
-    hello = (COLORS > 8) ? "Test" : "Hello";
+    width = (max_colors > 8) ? 4 : 8;
+    hello = (max_colors > 8) ? "Test" : "Hello";
 
     for (base = 0; base < 2; base++) {
-       top = (COLORS > 8) ? 0 : base * (COLORS + 3);
+       top = (max_colors > 8) ? 0 : base * (max_colors + 3);
        clrtobot();
        (void) mvprintw(top + 1, 0,
-           "%dx%d matrix of foreground/background colors, bright *%s*\n",
-           COLORS, COLORS,
-           base ? "on" : "off");
-       for (i = 0; i < COLORS; i++)
+                       "%dx%d matrix of foreground/background colors, bright *%s*\n",
+                       max_colors, max_colors,
+                       base ? "on" : "off");
+       for (i = 0; i < max_colors; i++)
            show_color_name(top + 2, (i + 1) * width, i);
-       for (i = 0; i < COLORS; i++)
+       for (i = 0; i < max_colors; i++)
            show_color_name(top + 3 + i, 0, i);
-       for (i = 1; i < COLOR_PAIRS; i++) {
-           init_pair(i, i % COLORS, i / COLORS);
+       for (i = 1; i < max_pairs; i++) {
+           init_pair(i, i % max_colors, i / max_colors);
            attron((attr_t) COLOR_PAIR(i));
            if (base)
                attron((attr_t) A_BOLD);
-           mvaddstr(top + 3 + (i / COLORS), (i % COLORS + 1) * width, hello);
+           mvaddstr(top + 3 + (i / max_colors), (i % max_colors + 1) *
+                    width, hello);
            attrset(A_NORMAL);
        }
-       if ((COLORS > 8) || base)
+       if ((max_colors > 8) || base)
            Pause();
     }
 
@@ -609,7 +1090,6 @@ color_edit(void)
 {
     int i, this_c = 0, value = 0, current = 0, field = 0;
     int last_c;
-    int max_colors = COLORS > 16 ? 16 : COLORS;
 
     refresh();
 
@@ -627,9 +1107,9 @@ color_edit(void)
 
        for (i = 0; i < max_colors; i++) {
            mvprintw(2 + i, 0, "%c %-8s:",
-               (i == current ? '>' : ' '),
-               (i < (int) SIZEOF(color_names)
-                   color_names[i] : ""));
+                    (i == current ? '>' : ' '),
+                    (i < (int) SIZEOF(the_color_names)
+                     ? the_color_names[i] : ""));
            attrset(COLOR_PAIR(i));
            addstr("        ");
            attrset(A_NORMAL);
@@ -666,9 +1146,9 @@ color_edit(void)
        }
 
        mvaddstr(max_colors + 3, 0,
-           "Use up/down to select a color, left/right to change fields.");
+                "Use up/down to select a color, left/right to change fields.");
        mvaddstr(max_colors + 4, 0,
-           "Modify field by typing nnn=, nnn-, or nnn+.  ? for help.");
+                "Modify field by typing nnn=, nnn-, or nnn+.  ? for help.");
 
        move(2 + current, 0);
 
@@ -882,7 +1362,7 @@ show_upper_chars(int first)
     erase();
     attron(A_BOLD);
     mvprintw(0, 20, "Display of %s Character Codes %d to %d",
-       C1 ? "C1" : "GR", first, last);
+            C1 ? "C1" : "GR", first, last);
     attroff(A_BOLD);
     refresh();
 
@@ -906,6 +1386,27 @@ show_upper_chars(int first)
     }
 }
 
+static void
+show_box_chars(void)
+{
+    erase();
+    attron(A_BOLD);
+    mvaddstr(0, 20, "Display of the ACS Line-Drawing Set");
+    attroff(A_BOLD);
+    refresh();
+    box(stdscr, 0, 0);
+    /* *INDENT-OFF* */
+    mvhline(LINES / 2, 0,        ACS_HLINE, COLS);
+    mvvline(0,         COLS / 2, ACS_VLINE, LINES);
+    mvaddch(0,         COLS / 2, ACS_TTEE);
+    mvaddch(LINES / 2, COLS / 2, ACS_PLUS);
+    mvaddch(LINES - 1, COLS / 2, ACS_BTEE);
+    mvaddch(LINES / 2, 0,        ACS_LTEE);
+    mvaddch(LINES / 2, COLS - 1, ACS_RTEE);
+    /* *INDENT-ON* */
+
+}
+
 static int
 show_1_acs(int n, const char *name, chtype code)
 {
@@ -932,37 +1433,43 @@ show_acs_chars(void)
     refresh();
 
     n = show_1_acs(0, BOTH(ACS_ULCORNER));
-    n = show_1_acs(n, BOTH(ACS_LLCORNER));
     n = show_1_acs(n, BOTH(ACS_URCORNER));
+    n = show_1_acs(n, BOTH(ACS_LLCORNER));
     n = show_1_acs(n, BOTH(ACS_LRCORNER));
-    n = show_1_acs(n, BOTH(ACS_RTEE));
+
     n = show_1_acs(n, BOTH(ACS_LTEE));
-    n = show_1_acs(n, BOTH(ACS_BTEE));
+    n = show_1_acs(n, BOTH(ACS_RTEE));
     n = show_1_acs(n, BOTH(ACS_TTEE));
+    n = show_1_acs(n, BOTH(ACS_BTEE));
+
     n = show_1_acs(n, BOTH(ACS_HLINE));
     n = show_1_acs(n, BOTH(ACS_VLINE));
-    n = show_1_acs(n, BOTH(ACS_PLUS));
-    n = show_1_acs(n, BOTH(ACS_S1));
-    n = show_1_acs(n, BOTH(ACS_S9));
-    n = show_1_acs(n, BOTH(ACS_DIAMOND));
-    n = show_1_acs(n, BOTH(ACS_CKBOARD));
-    n = show_1_acs(n, BOTH(ACS_DEGREE));
-    n = show_1_acs(n, BOTH(ACS_PLMINUS));
-    n = show_1_acs(n, BOTH(ACS_BULLET));
+
     n = show_1_acs(n, BOTH(ACS_LARROW));
     n = show_1_acs(n, BOTH(ACS_RARROW));
-    n = show_1_acs(n, BOTH(ACS_DARROW));
     n = show_1_acs(n, BOTH(ACS_UARROW));
+    n = show_1_acs(n, BOTH(ACS_DARROW));
+
+    n = show_1_acs(n, BOTH(ACS_BLOCK));
     n = show_1_acs(n, BOTH(ACS_BOARD));
     n = show_1_acs(n, BOTH(ACS_LANTERN));
-    n = show_1_acs(n, BOTH(ACS_BLOCK));
-    n = show_1_acs(n, BOTH(ACS_S3));
-    n = show_1_acs(n, BOTH(ACS_S7));
-    n = show_1_acs(n, BOTH(ACS_LEQUAL));
+    n = show_1_acs(n, BOTH(ACS_BULLET));
+    n = show_1_acs(n, BOTH(ACS_CKBOARD));
+    n = show_1_acs(n, BOTH(ACS_DEGREE));
+    n = show_1_acs(n, BOTH(ACS_DIAMOND));
+    n = show_1_acs(n, BOTH(ACS_PLMINUS));
+    n = show_1_acs(n, BOTH(ACS_PLUS));
+
     n = show_1_acs(n, BOTH(ACS_GEQUAL));
-    n = show_1_acs(n, BOTH(ACS_PI));
     n = show_1_acs(n, BOTH(ACS_NEQUAL));
+    n = show_1_acs(n, BOTH(ACS_LEQUAL));
+
     n = show_1_acs(n, BOTH(ACS_STERLING));
+    n = show_1_acs(n, BOTH(ACS_PI));
+    n = show_1_acs(n, BOTH(ACS_S1));
+    n = show_1_acs(n, BOTH(ACS_S3));
+    n = show_1_acs(n, BOTH(ACS_S7));
+    n = show_1_acs(n, BOTH(ACS_S9));
 }
 
 static void
@@ -975,6 +1482,9 @@ acs_display(void)
        case 'a':
            show_acs_chars();
            break;
+       case 'b':
+           show_box_chars();
+           break;
        case '0':
        case '1':
        case '2':
@@ -983,9 +1493,222 @@ acs_display(void)
            break;
        }
        mvprintw(LINES - 3, 0,
-           "Note: ANSI terminals may not display C1 characters.");
+                "Note: ANSI terminals may not display C1 characters.");
+       mvprintw(LINES - 2, 0,
+                "Select: a=ACS, b=box, 0=C1, 1,2,3=GR characters, q=quit");
+       refresh();
+    } while ((c = Getchar()) != 'x' && c != 'q');
+
+    Pause();
+    erase();
+    endwin();
+}
+
+#if USE_WIDEC_SUPPORT
+static void
+show_upper_widechars(int first)
+{
+    cchar_t temp;
+    wchar_t code;
+    int last = first + 31;
+
+    erase();
+    attron(A_BOLD);
+    mvprintw(0, 20, "Display of Character Codes %d to %d", first, last);
+    attroff(A_BOLD);
+    refresh();
+
+    for (code = first; code <= last; code++) {
+       int row = 4 + ((code - first) % 16);
+       int col = ((code - first) / 16) * COLS / 2;
+       wchar_t codes[10];
+       attr_t attrs = A_NORMAL;
+       char tmp[80];
+
+       memset(&codes, 0, sizeof(codes));
+       codes[0] = code;
+       sprintf(tmp, "%3ld (0x%lx)", code, code);
+       mvprintw(row, col, "%*s: ", COLS / 4, tmp);
+       setcchar(&temp, codes, attrs, 0, 0);
+       echo_wchar(&temp);
+    }
+}
+
+static int
+show_1_wacs(int n, const char *name, const cchar_t * code)
+{
+    const int height = 16;
+    int row = 4 + (n % height);
+    int col = (n / height) * COLS / 2;
+    mvprintw(row, col, "%*s : ", COLS / 4, name);
+    add_wchnstr(code, 1);
+    return n + 1;
+}
+
+static void
+show_wacs_chars(void)
+/* display the wide-ACS character set */
+{
+    int n;
+
+/*#define BOTH2(name) #name, &(name) */
+#define BOTH2(name) #name, name
+
+    erase();
+    attron(A_BOLD);
+    mvaddstr(0, 20, "Display of the Wide-ACS Character Set");
+    attroff(A_BOLD);
+    refresh();
+
+    n = show_1_wacs(0, BOTH2(WACS_ULCORNER));
+    n = show_1_wacs(n, BOTH2(WACS_URCORNER));
+    n = show_1_wacs(n, BOTH2(WACS_LLCORNER));
+    n = show_1_wacs(n, BOTH2(WACS_LRCORNER));
+
+    n = show_1_wacs(n, BOTH2(WACS_LTEE));
+    n = show_1_wacs(n, BOTH2(WACS_RTEE));
+    n = show_1_wacs(n, BOTH2(WACS_TTEE));
+    n = show_1_wacs(n, BOTH2(WACS_BTEE));
+
+    n = show_1_wacs(n, BOTH2(WACS_HLINE));
+    n = show_1_wacs(n, BOTH2(WACS_VLINE));
+
+    n = show_1_wacs(n, BOTH2(WACS_LARROW));
+    n = show_1_wacs(n, BOTH2(WACS_RARROW));
+    n = show_1_wacs(n, BOTH2(WACS_UARROW));
+    n = show_1_wacs(n, BOTH2(WACS_DARROW));
+
+    n = show_1_wacs(n, BOTH2(WACS_BLOCK));
+    n = show_1_wacs(n, BOTH2(WACS_BOARD));
+    n = show_1_wacs(n, BOTH2(WACS_LANTERN));
+    n = show_1_wacs(n, BOTH2(WACS_BULLET));
+    n = show_1_wacs(n, BOTH2(WACS_CKBOARD));
+    n = show_1_wacs(n, BOTH2(WACS_DEGREE));
+    n = show_1_wacs(n, BOTH2(WACS_DIAMOND));
+    n = show_1_wacs(n, BOTH2(WACS_PLMINUS));
+    n = show_1_wacs(n, BOTH2(WACS_PLUS));
+
+#ifdef CURSES_WACS_ARRAY
+    n = show_1_wacs(n, BOTH2(WACS_GEQUAL));
+    n = show_1_wacs(n, BOTH2(WACS_NEQUAL));
+    n = show_1_wacs(n, BOTH2(WACS_LEQUAL));
+
+    n = show_1_wacs(n, BOTH2(WACS_STERLING));
+    n = show_1_wacs(n, BOTH2(WACS_PI));
+    n = show_1_wacs(n, BOTH2(WACS_S1));
+    n = show_1_wacs(n, BOTH2(WACS_S3));
+    n = show_1_wacs(n, BOTH2(WACS_S7));
+    n = show_1_wacs(n, BOTH2(WACS_S9));
+#endif
+}
+
+static void
+show_wbox_chars(void)
+{
+    erase();
+    attron(A_BOLD);
+    mvaddstr(0, 20, "Display of the Wide-ACS Line-Drawing Set");
+    attroff(A_BOLD);
+    refresh();
+    box_set(stdscr, 0, 0);
+    /* *INDENT-OFF* */
+    mvhline_set(LINES / 2, 0,        WACS_HLINE, COLS);
+    mvvline_set(0,         COLS / 2, WACS_VLINE, LINES);
+    mvadd_wch(0,           COLS / 2, WACS_TTEE);
+    mvadd_wch(LINES / 2,   COLS / 2, WACS_PLUS);
+    mvadd_wch(LINES - 1,   COLS / 2, WACS_BTEE);
+    mvadd_wch(LINES / 2,   0,        WACS_LTEE);
+    mvadd_wch(LINES / 2,   COLS - 1, WACS_RTEE);
+    /* *INDENT-ON* */
+
+}
+
+static int
+show_2_wacs(int n, const char *name, char *code)
+{
+    const int height = 16;
+    int row = 4 + (n % height);
+    int col = (n / height) * COLS / 2;
+    mvprintw(row, col, "%*s : ", COLS / 4, name);
+    addstr(code);
+    return n + 1;
+}
+
+static void
+show_utf8_chars(void)
+/* display the wide-ACS character set */
+{
+    int n;
+
+    erase();
+    attron(A_BOLD);
+    mvaddstr(0, 20, "Display of the Wide-ACS Character Set");
+    attroff(A_BOLD);
+    refresh();
+    /* *INDENT-OFF* */
+    n = show_2_wacs(0, "WACS_ULCORNER",        "\342\224\214");
+    n = show_2_wacs(n, "WACS_URCORNER",        "\342\224\220");
+    n = show_2_wacs(n, "WACS_LLCORNER",        "\342\224\224");
+    n = show_2_wacs(n, "WACS_LRCORNER",        "\342\224\230");
+
+    n = show_2_wacs(n, "WACS_LTEE",    "\342\224\234");
+    n = show_2_wacs(n, "WACS_RTEE",    "\342\224\244");
+    n = show_2_wacs(n, "WACS_TTEE",    "\342\224\254");
+    n = show_2_wacs(n, "WACS_BTEE",    "\342\224\264");
+
+    n = show_2_wacs(n, "WACS_HLINE",   "\342\224\200");
+    n = show_2_wacs(n, "WACS_VLINE",   "\342\224\202");
+
+    n = show_2_wacs(n, "WACS_LARROW",  "\342\206\220");
+    n = show_2_wacs(n, "WACS_RARROW",  "\342\206\222");
+    n = show_2_wacs(n, "WACS_UARROW",  "\342\206\221");
+    n = show_2_wacs(n, "WACS_DARROW",  "\342\206\223");
+
+    n = show_2_wacs(n, "WACS_BLOCK",   "\342\226\256");
+    n = show_2_wacs(n, "WACS_BOARD",   "\342\226\222");
+    n = show_2_wacs(n, "WACS_LANTERN", "\342\230\203");
+    n = show_2_wacs(n, "WACS_BULLET",  "\302\267");
+    n = show_2_wacs(n, "WACS_CKBOARD", "\342\226\222");
+    n = show_2_wacs(n, "WACS_DEGREE",  "\302\260");
+    n = show_2_wacs(n, "WACS_DIAMOND", "\342\227\206");
+    n = show_2_wacs(n, "WACS_PLMINUS", "\302\261");
+    n = show_2_wacs(n, "WACS_PLUS",    "\342\224\274");
+    n = show_2_wacs(n, "WACS_GEQUAL",  "\342\211\245");
+    n = show_2_wacs(n, "WACS_NEQUAL",  "\342\211\240");
+    n = show_2_wacs(n, "WACS_LEQUAL",  "\342\211\244");
+
+    n = show_2_wacs(n, "WACS_STERLING",        "\302\243");
+    n = show_2_wacs(n, "WACS_PI",      "\317\200");
+    n = show_2_wacs(n, "WACS_S1",      "\342\216\272");
+    n = show_2_wacs(n, "WACS_S3",      "\342\216\273");
+    n = show_2_wacs(n, "WACS_S7",      "\342\216\274");
+    n = show_2_wacs(n, "WACS_S9",      "\342\216\275");
+    /* *INDENT-OFF* */
+}
+
+static void
+wide_acs_display(void)
+{
+    int c = 'a';
+
+    do {
+       switch (c) {
+       case 'a':
+           show_wacs_chars();
+           break;
+       case 'b':
+           show_wbox_chars();
+           break;
+       case 'u':
+           show_utf8_chars();
+           break;
+       default:
+           if (isdigit(c))
+               show_upper_widechars((c - '0') * 32 + 128);
+           break;
+       }
        mvprintw(LINES - 2, 0,
-           "Select: a=ACS, 0=C1, 1,2,3=GR characters, q=quit");
+                "Select: a WACS, b box, u UTF-8, 0-9 non-ASCII characters, q=quit");
        refresh();
     } while ((c = Getchar()) != 'x' && c != 'q');
 
@@ -994,6 +1717,8 @@ acs_display(void)
     endwin();
 }
 
+#endif
+
 /*
  * Graphic-rendition test (adapted from vttest)
  */
@@ -1064,7 +1789,7 @@ test_sgr_attributes(void)
 
        bkgdset(normal);
        mvprintw(LINES - 2, 1, "%s background. ", pass == 0 ? "Dark" :
-           "Light");
+                "Light");
        clrtoeol();
        Pause();
     }
@@ -1095,21 +1820,30 @@ FRAME
     WINDOW *wind;
 };
 
+#ifdef NCURSES_VERSION
+#define keypad_active(win) (win)->_use_keypad
+#define scroll_active(win) (win)->_scroll
+#else
+#define keypad_active(win) FALSE
+#define scroll_active(win) FALSE
+#endif
+
 /* We need to know if these flags are actually set, so don't look in FRAME.
- * These names are known to work with SVr4 curses as well as ncurses.
+ * These names are known to work with SVr4 curses as well as ncurses.  The
+ * _use_keypad name does not work with Solaris 8.
  */
 static bool
 HaveKeypad(FRAME * curp)
 {
     WINDOW *win = (curp ? curp->wind : stdscr);
-    return win->_use_keypad;
+    return keypad_active(win);
 }
 
 static bool
 HaveScroll(FRAME * curp)
 {
     WINDOW *win = (curp ? curp->wind : stdscr);
-    return win->_scroll;
+    return scroll_active(win);
 }
 
 static void
@@ -1146,7 +1880,7 @@ newwin_legend(FRAME * curp)
        {
            "^R = restore window", 0
        },
-#ifdef HAVE_WRESIZE
+#if HAVE_WRESIZE
        {
            "^X = resize", 0
        },
@@ -1156,7 +1890,7 @@ newwin_legend(FRAME * curp)
        }
     };
     size_t n;
-    int y, x;
+    int x;
     bool do_keypad = HaveKeypad(curp);
     bool do_scroll = HaveScroll(curp);
     char buf[BUFSIZ];
@@ -1177,7 +1911,7 @@ newwin_legend(FRAME * curp)
            sprintf(buf, legend[n].msg, do_keypad ? "/ESC" : "");
            break;
        }
-       getyx(stdscr, y, x);
+       x = getcurx(stdscr);
        addstr((COLS < (x + 3 + (int) strlen(buf))) ? "\n" : (n ? ", " : ""));
        addstr(buf);
     }
@@ -1196,8 +1930,8 @@ transient(FRAME * curp, NCURSES_CONST char *msg)
 
     move(LINES - 1, 0);
     printw("%s characters are echoed, window should %sscroll.",
-       HaveKeypad(curp) ? "Non-arrow" : "All other",
-       HaveScroll(curp) ? "" : "not ");
+          HaveKeypad(curp) ? "Non-arrow" : "All other",
+          HaveScroll(curp) ? "" : "not ");
     clrtoeol();
 }
 
@@ -1447,11 +2181,12 @@ acs_and_scroll(void)
            break;
 
        case CTRL('W'): /* save and delete window */
-           if (current == current->next)
+           if (current == current->next) {
+               transient(current, "Will not save/delete ONLY window");
                break;
-           if ((fp = fopen(DUMPFILE, "w")) == (FILE *) 0)
+           } else if ((fp = fopen(DUMPFILE, "w")) == (FILE *) 0) {
                transient(current, "Can't open screen dump file");
-           else {
+           else {
                (void) putwin(current->wind, fp);
                (void) fclose(fp);
 
@@ -1460,9 +2195,9 @@ acs_and_scroll(void)
            break;
 
        case CTRL('R'): /* restore window */
-           if ((fp = fopen(DUMPFILE, "r")) == (FILE *) 0)
+           if ((fp = fopen(DUMPFILE, "r")) == (FILE *) 0) {
                transient(current, "Can't open screen dump file");
-           else {
+           else {
                neww = (FRAME *) calloc(1, sizeof(FRAME));
 
                neww->next = current->next;
@@ -1477,7 +2212,7 @@ acs_and_scroll(void)
            }
            break;
 
-#ifdef HAVE_WRESIZE
+#if HAVE_WRESIZE
        case CTRL('X'): /* resize window */
            if (current) {
                pair *tmp, ul, lr;
@@ -1585,8 +2320,8 @@ acs_and_scroll(void)
        wrefresh(usescr);
     } while
        ((c = wGetchar(usescr)) != QUIT
-       && !((c == ESCAPE) && (usescr->_use_keypad))
-       && (c != ERR));
+        && !((c == ESCAPE) && (keypad_active(usescr)))
+        && (c != ERR));
 
   breakout:
     while (current != 0)
@@ -1739,38 +2474,38 @@ demo_panels(void)
        PANEL *p5;
 
        p1 = mkpanel(COLOR_RED,
-           LINES / 2 - 2,
-           COLS / 8 + 1,
-           0,
-           0);
+                    LINES / 2 - 2,
+                    COLS / 8 + 1,
+                    0,
+                    0);
        set_panel_userptr(p1, "p1");
 
        p2 = mkpanel(COLOR_GREEN,
-           LINES / 2 + 1,
-           COLS / 7,
-           LINES / 4,
-           COLS / 10);
+                    LINES / 2 + 1,
+                    COLS / 7,
+                    LINES / 4,
+                    COLS / 10);
        set_panel_userptr(p2, "p2");
 
        p3 = mkpanel(COLOR_YELLOW,
-           LINES / 4,
-           COLS / 10,
-           LINES / 2,
-           COLS / 9);
+                    LINES / 4,
+                    COLS / 10,
+                    LINES / 2,
+                    COLS / 9);
        set_panel_userptr(p3, "p3");
 
        p4 = mkpanel(COLOR_BLUE,
-           LINES / 2 - 2,
-           COLS / 8,
-           LINES / 2 - 2,
-           COLS / 3);
+                    LINES / 2 - 2,
+                    COLS / 8,
+                    LINES / 2 - 2,
+                    COLS / 3);
        set_panel_userptr(p4, "p4");
 
        p5 = mkpanel(COLOR_MAGENTA,
-           LINES / 2 - 2,
-           COLS / 8,
-           LINES / 2,
-           COLS / 2 - 2);
+                    LINES / 2 - 2,
+                    COLS / 8,
+                    LINES / 2,
+                    COLS / 2 - 2);
        set_panel_userptr(p5, "p5");
 
        fill_panel(p1);
@@ -1943,6 +2678,7 @@ demo_panels(void)
 
 #define GRIDSIZE       3
 
+static bool pending_pan = FALSE;
 static bool show_panner_legend = TRUE;
 
 static int
@@ -1950,10 +2686,10 @@ panner_legend(int line)
 {
     static const char *const legend[] =
     {
-       "Use arrow keys (or U,D,L,R) to pan, q to quit (?,t,s flags)",
-       "Use ! to shell-out.  Toggle legend:?, timer:t, scroll mark:s.",
+       "Use arrow keys (or U,D,L,R) to pan, q to quit, ! to shell-out.",
        "Use +,- (or j,k) to grow/shrink the panner vertically.",
-       "Use <,> (or h,l) to grow/shrink the panner horizontally."
+       "Use <,> (or h,l) to grow/shrink the panner horizontally.",
+       "Number repeats.  Toggle legend:?, timer:t, scroll mark:s."
     };
     int n = (SIZEOF(legend) - (LINES - line));
     if (line < LINES && (n >= 0)) {
@@ -1982,8 +2718,8 @@ panner_v_cleanup(int from_y, int from_x, int to_y)
 
 static void
 panner(WINDOW *pad,
-    int top_x, int top_y, int porty, int portx,
-    int (*pgetc) (WINDOW *))
+       int top_x, int top_y, int porty, int portx,
+       int (*pgetc) (WINDOW *))
 {
 #if HAVE_GETTIMEOFDAY
     struct timeval before, after;
@@ -2205,29 +2941,31 @@ panner(WINDOW *pad,
        mvaddch(porty - 1, top_x - 1, ACS_LLCORNER);
        mvaddch(porty - 1, portx - 1, ACS_LRCORNER);
 
+       if (!pending_pan) {
 #if HAVE_GETTIMEOFDAY
-       gettimeofday(&before, 0);
+           gettimeofday(&before, 0);
 #endif
-       wnoutrefresh(stdscr);
+           wnoutrefresh(stdscr);
 
-       pnoutrefresh(pad,
-           basey, basex,
-           top_y, top_x,
-           porty - (pxmax > portx) - 1,
-           portx - (pymax > porty) - 1);
+           pnoutrefresh(pad,
+                        basey, basex,
+                        top_y, top_x,
+                        porty - (pxmax > portx) - 1,
+                        portx - (pymax > porty) - 1);
 
-       doupdate();
+           doupdate();
 #if HAVE_GETTIMEOFDAY
-       if (timing) {
-           double elapsed;
-           gettimeofday(&after, 0);
-           elapsed = (after.tv_sec + after.tv_usec / 1.0e6)
-               - (before.tv_sec + before.tv_usec / 1.0e6);
-           move(LINES - 1, COLS - 20);
-           printw("Secs: %2.03f", elapsed);
-           refresh();
-       }
+           if (timing) {
+               double elapsed;
+               gettimeofday(&after, 0);
+               elapsed = (after.tv_sec + after.tv_usec / 1.0e6)
+                   - (before.tv_sec + before.tv_usec / 1.0e6);
+               move(LINES - 1, COLS - 20);
+               printw("Secs: %2.03f", elapsed);
+               refresh();
+           }
 #endif
+       }
 
     } while
        ((c = pgetc(pad)) != KEY_EXIT);
@@ -2235,44 +2973,73 @@ panner(WINDOW *pad,
     scrollok(stdscr, TRUE);    /* reset to driver's default */
 }
 
-static
-int
+static int
 padgetch(WINDOW *win)
 {
+    static int count;
+    static int last;
     int c;
 
-    switch (c = wGetchar(win)) {
-    case '!':
-       ShellOut(FALSE);
-       return KEY_REFRESH;
-    case CTRL('r'):
-       endwin();
-       refresh();
-       return KEY_REFRESH;
-    case CTRL('l'):
-       return KEY_REFRESH;
-    case 'U':
-       return (KEY_UP);
-    case 'D':
-       return (KEY_DOWN);
-    case 'R':
-       return (KEY_RIGHT);
-    case 'L':
-       return (KEY_LEFT);
-    case '+':
-       return (KEY_IL);
-    case '-':
-       return (KEY_DL);
-    case '>':
-       return (KEY_IC);
-    case '<':
-       return (KEY_DC);
-    case ERR:                  /* FALLTHRU */
-    case 'q':
-       return (KEY_EXIT);
-    default:
-       return (c);
+    if ((pending_pan = (count > 0)) != FALSE) {
+       count--;
+       pending_pan = (count != 0);
+    } else {
+       for (;;) {
+           switch (c = wGetchar(win)) {
+           case '!':
+               ShellOut(FALSE);
+               /* FALLTHRU */
+           case CTRL('r'):
+               endwin();
+               refresh();
+               c = KEY_REFRESH;
+               break;
+           case CTRL('l'):
+               c = KEY_REFRESH;
+               break;
+           case 'U':
+               c = KEY_UP;
+               break;
+           case 'D':
+               c = KEY_DOWN;
+               break;
+           case 'R':
+               c = KEY_RIGHT;
+               break;
+           case 'L':
+               c = KEY_LEFT;
+               break;
+           case '+':
+               c = KEY_IL;
+               break;
+           case '-':
+               c = KEY_DL;
+               break;
+           case '>':
+               c = KEY_IC;
+               break;
+           case '<':
+               c = KEY_DC;
+               break;
+           case ERR:           /* FALLTHRU */
+           case 'q':
+               count = 0;
+               c = KEY_EXIT;
+               break;
+           default:
+               if (c >= '0' && c <= '9') {
+                   count = count * 10 + (c - '0');
+                   continue;
+               }
+               break;
+           }
+           last = c;
+           break;
+       }
+       if (count > 0)
+           count--;
     }
+    return (last);
 }
 
 #define PAD_HIGH 200
@@ -2379,7 +3146,7 @@ flushinp_test(WINDOW *win)
 
     mvwaddstr(win, 2, 1, "Type random keys for 5 seconds.");
     mvwaddstr(win, 3, 1,
-       "These should be discarded (not echoed) after the subwindow goes away.");
+             "These should be discarded (not echoed) after the subwindow goes away.");
     wrefresh(win);
 
     for (i = 0; i < 5; i++) {
@@ -2396,11 +3163,11 @@ flushinp_test(WINDOW *win)
     napms(1000);
 
     mvwaddstr(win, 2, 1,
-       "If you were still typing when the window timer expired,");
+             "If you were still typing when the window timer expired,");
     mvwaddstr(win, 3, 1,
-       "or else you typed nothing at all while it was running,");
+             "or else you typed nothing at all while it was running,");
     mvwaddstr(win, 4, 1,
-       "test was invalid.  You'll see garbage or nothing at all. ");
+             "test was invalid.  You'll see garbage or nothing at all. ");
     mvwaddstr(win, 6, 1, "Press a key");
     wmove(win, 9, 10);
     wrefresh(win);
@@ -2408,7 +3175,7 @@ flushinp_test(WINDOW *win)
     wGetchar(win);
     flushinp();
     mvwaddstr(win, 12, 0,
-       "If you see any key other than what you typed, flushinp() is broken.");
+             "If you see any key other than what you typed, flushinp() is broken.");
     Continue(win);
 
     wmove(win, 9, 10);
@@ -2417,7 +3184,7 @@ flushinp_test(WINDOW *win)
     wmove(win, 12, 0);
     clrtoeol();
     waddstr(win,
-       "What you typed should now have been deleted; if not, wdelch() failed.");
+           "What you typed should now have been deleted; if not, wdelch() failed.");
     Continue(win);
 
     cbreak();
@@ -2483,7 +3250,7 @@ menu_test(void)
     mvaddstr(2, 0, "  Use up and down arrow to move the select bar.");
     mvaddstr(3, 0, "  'n' and 'p' act like arrows.");
     mvaddstr(4, 0,
-       "  'b' and 'f' scroll up/down (page), 'u' and 'd' (line).");
+            "  'b' and 'f' scroll up/down (page), 'u' and 'd' (line).");
     mvaddstr(5, 0, "  Press return to exit.");
     refresh();
 
@@ -2512,7 +3279,7 @@ menu_test(void)
     }
 
     (void) mvprintw(LINES - 2, 0,
-       "You chose: %s\n", item_name(current_item(m)));
+                   "You chose: %s\n", item_name(current_item(m)));
     (void) addstr("Press any key to continue...");
     wGetchar(stdscr);
 
@@ -2548,6 +3315,7 @@ static struct {
        T_TBL(TRACE_ICALLS),
        T_TBL(TRACE_CCALLS),
        T_TBL(TRACE_DATABASE),
+       T_TBL(TRACE_ATTRS),
        T_TBL(TRACE_MAXIMUM),
     {
        (char *) 0, 0
@@ -2677,7 +3445,7 @@ trace_set(void)
     _tracef("trace level interactively set to %s", tracetrace(_nc_tracing));
 
     (void) mvprintw(LINES - 2, 0,
-       "Trace level is %s\n", tracetrace(_nc_tracing));
+                   "Trace level is %s\n", tracetrace(_nc_tracing));
     (void) addstr("Press any key to continue...");
     wGetchar(stdscr);
 
@@ -2945,7 +3713,7 @@ form_virtualize(FORM * f, WINDOW *w)
            mode = REQ_INS_MODE;
        c = mode;
     } else {
-       for (n = 0; n < sizeof(lookup) / sizeof(lookup[0]); n++) {
+       for (n = 0; n < SIZEOF(lookup); n++) {
            if (lookup[n].code == c) {
                c = lookup[n].result;
                break;
@@ -3184,6 +3952,12 @@ do_single_test(const char c)
        getch_test();
        break;
 
+#if USE_WIDEC_SUPPORT
+    case 'A':
+       get_wch_test();
+       break;
+#endif
+
     case 'b':
        attr_test();
        break;
@@ -3212,6 +3986,12 @@ do_single_test(const char c)
        acs_display();
        break;
 
+#if USE_WIDEC_SUPPORT
+    case 'F':
+       wide_acs_display();
+       break;
+#endif
+
 #if USE_LIBPANEL
     case 'o':
        demo_panels();
@@ -3289,9 +4069,9 @@ usage(void)
 #endif
     };
     size_t n;
-    for (n = 0; n < sizeof(tbl) / sizeof(tbl[0]); n++)
+    for (n = 0; n < SIZEOF(tbl); n++)
        fprintf(stderr, "%s\n", tbl[n]);
-    exit(EXIT_FAILURE);
+    ExitProgram(EXIT_FAILURE);
 }
 
 static void
@@ -3314,23 +4094,23 @@ announce_sig(int sig)
 #endif
 
 static int
-rip_footer(WINDOW *win, int columns)
+rip_footer(WINDOW *win, int cols)
 {
     wbkgd(win, A_REVERSE);
     werase(win);
     wmove(win, 0, 0);
-    wprintw(win, "footer: %d columns", columns);
+    wprintw(win, "footer: %d columns", cols);
     wnoutrefresh(win);
     return OK;
 }
 
 static int
-rip_header(WINDOW *win, int columns)
+rip_header(WINDOW *win, int cols)
 {
     wbkgd(win, A_REVERSE);
     werase(win);
     wmove(win, 0, 0);
-    wprintw(win, "header: %d columns", columns);
+    wprintw(win, "header: %d columns", cols);
     wnoutrefresh(win);
     return OK;
 }
@@ -3351,9 +4131,7 @@ main(int argc, char *argv[])
     bool default_colors = FALSE;
 #endif
 
-#if HAVE_LOCALE_H
-    setlocale(LC_CTYPE, "");
-#endif
+    setlocale(LC_ALL, "");
 
     while ((c = getopt(argc, argv, "a:de:fhs:t:")) != EOF) {
        switch (c) {
@@ -3427,12 +4205,22 @@ main(int argc, char *argv[])
     /* tests, in general, will want these modes */
     if (has_colors()) {
        start_color();
-#ifdef NCURSES_VERSION
+#ifdef NCURSES_VERSION_PATCH
+       max_colors = COLORS > 16 ? 16 : COLORS;
+#if HAVE_USE_DEFAULT_COLORS
        if (default_colors)
            use_default_colors();
+#if NCURSES_VERSION_PATCH >= 20000708
        else if (assumed_colors)
            assume_default_colors(default_fg, default_bg);
 #endif
+#endif
+#else /* normal SVr4 curses */
+       max_colors = COLORS > 8 ? 8 : COLORS;
+#endif
+       max_pairs = (max_colors * max_colors);
+       if (max_pairs < COLOR_PAIRS)
+           max_pairs = COLOR_PAIRS;
     }
     set_terminal_modes();
     def_prog_mode();
@@ -3447,9 +4235,9 @@ main(int argc, char *argv[])
     (void) printf("Welcome to %s.  Press ? for help.\n", curses_version());
 #elif defined(NCURSES_VERSION_MAJOR) && defined(NCURSES_VERSION_MINOR) && defined(NCURSES_VERSION_PATCH)
     (void) printf("Welcome to ncurses %d.%d.%d.  Press ? for help.\n",
-       NCURSES_VERSION_MAJOR,
-       NCURSES_VERSION_MINOR,
-       NCURSES_VERSION_PATCH);
+                 NCURSES_VERSION_MAJOR,
+                 NCURSES_VERSION_MINOR,
+                 NCURSES_VERSION_PATCH);
 #else
     (void) puts("Welcome to ncurses.  Press ? for help.");
 #endif
@@ -3457,11 +4245,17 @@ main(int argc, char *argv[])
     do {
        (void) puts("This is the ncurses main menu");
        (void) puts("a = keyboard and mouse input test");
+#if USE_WIDEC_SUPPORT
+       (void) puts("A = wide-character keyboard and mouse input test");
+#endif
        (void) puts("b = character attribute test");
        (void) puts("c = color test pattern");
        (void) puts("d = edit RGB color values");
        (void) puts("e = exercise soft keys");
        (void) puts("f = display ACS characters");
+#if USE_WIDEC_SUPPORT
+       (void) puts("F = display Wide-ACS characters");
+#endif
        (void) puts("g = display windows and scrolling");
        (void) puts("i = test of flushinp()");
        (void) puts("k = display character attributes");
@@ -3497,7 +4291,7 @@ main(int argc, char *argv[])
                if (command == 0)
                    command = 'q';
                break;
-           } else if (command == 0 && !isspace(ch)) {
+           } else if (command == 0 && !isspace(UChar(ch))) {
                command = ch;
            } else if (ch == '\n' || ch == '\r') {
                if (command != 0)