ncurses 6.1 - patch 20180623
[ncurses.git] / test / ncurses.c
index 12717880514a48691192270ee46aeceb1b5962e8..9c7516896cf1b0e4fa476bec8e47620068e9ebb3 100644 (file)
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (c) 1998-2016,2017 Free Software Foundation, Inc.              *
+ * Copyright (c) 1998-2017,2018 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            *
@@ -40,7 +40,7 @@ AUTHOR
    Author: Eric S. Raymond <esr@snark.thyrsus.com> 1993
            Thomas E. Dickey (beginning revision 1.27 in 1996).
 
-$Id: ncurses.c,v 1.470 2017/10/20 21:20:47 tom Exp $
+$Id: ncurses.c,v 1.507 2018/06/23 21:35:06 tom Exp $
 
 ***************************************************************************/
 
@@ -355,6 +355,7 @@ wGet_wchar(WINDOW *win, wint_t *result)
 #define Get_wchar(result) wGet_wchar(stdscr, result)
 
 /* replaces wgetn_wstr(), since we want to be able to edit values */
+#if USE_SOFTKEYS
 static void
 wGet_wstring(WINDOW *win, wchar_t *buffer, int limit)
 {
@@ -460,8 +461,9 @@ wGet_wstring(WINDOW *win, wchar_t *buffer, int limit)
     wmove(win, y0, x0);
     noecho();
 }
+#endif /* USE_SOFTKEYS */
 
-#endif
+#endif /* USE_WIDEC_SUPPORT */
 
 static void
 Pause(void)
@@ -476,6 +478,7 @@ Cannot(const char *what)
 {
     printw("\nThis %s terminal %s\n\n", getenv("TERM"), what);
     Pause();
+    endwin();
 }
 
 static void
@@ -485,7 +488,7 @@ ShellOut(bool message)
        addstr("Shelling out...");
     def_prog_mode();
     endwin();
-#ifdef __MINGW32__
+#ifdef _WIN32
     system("cmd.exe");
 #else
     IGNORE_RC(system("sh"));
@@ -2123,16 +2126,26 @@ static NCURSES_CONST char *the_color_names[] =
 };
 
 static void
-show_color_name(int y, int x, int color, bool wide)
+show_color_name(int y, int x, int color, bool wide, int zoom)
 {
     if (move(y, x) != ERR) {
        char temp[80];
        int width = 8;
 
-       if (wide) {
+       if (wide || zoom) {
+           int have;
+
            _nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
                        "%02d", color);
-           width = 4;
+           if (wide)
+               width = 4;
+           if ((have = (int) strlen(temp)) >= width) {
+               int pwr2 = 0;
+               while ((1 << pwr2) < color)
+                   ++pwr2;
+               _nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
+                           width > 4 ? "2^%d" : "^%d", pwr2);
+           }
        } else if (color >= 8) {
            _nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
                        "[%02d]", color);
@@ -2179,7 +2192,9 @@ color_legend(WINDOW *helpwin, bool wide)
     MvWPrintw(helpwin, row++, col,
              "  r/R     toggle reverse on/off");
     MvWPrintw(helpwin, row++, col,
-             "  w/W     toggle width between 8/16 colors");
+             "  w/W     switch width between 4/8 columns");
+    MvWPrintw(helpwin, row++, col,
+             "  z/Z     zoom out (or in)");
 #if USE_WIDEC_SUPPORT
     if (wide) {
        MvWPrintw(helpwin, row++, col,
@@ -2245,6 +2260,7 @@ color_test(bool recur GCC_UNUSED)
     bool opt_revs = FALSE;
     bool opt_nums = FALSE;
     bool opt_wide = FALSE;
+    int opt_zoom = 0;
     WINDOW *helpwin;
 
     if (!UseColors) {
@@ -2252,7 +2268,7 @@ color_test(bool recur GCC_UNUSED)
        return ERR;
     }
 
-    numbered = (char *) calloc((size_t) (COLS + 1), sizeof(char));
+    numbered = typeCalloc(char, COLS + 1);
     done = ((COLS < 16) || (numbered == 0));
 
     /*
@@ -2261,28 +2277,33 @@ color_test(bool recur GCC_UNUSED)
      */
     for (col_limit = 1; col_limit * 2 < COLS; col_limit *= 2) ;
 
+  reloop:
     while (!done) {
        int shown = 0;
+       int zoom_size = (1 << opt_zoom);
+       int colors_max1 = colors_max / zoom_size;
+       double colors_max2 = (double) colors_max1 * (double) colors_max1;
 
        pairs_max = PAIR_NUMBER(A_COLOR) + 1;
-       if (colors_max * colors_max <= COLOR_PAIRS) {
-           int limit = (colors_max - MinColors) * (colors_max - MinColors);
+       if (colors_max2 <= COLOR_PAIRS) {
+           int limit = (colors_max1 - MinColors) * (colors_max1 - MinColors);
            if (pairs_max > limit)
                pairs_max = limit;
-       } else {
-           if (pairs_max > COLOR_PAIRS)
-               pairs_max = COLOR_PAIRS;
        }
+       if (pairs_max > COLOR_PAIRS)
+           pairs_max = COLOR_PAIRS;
+       if (pairs_max < colors_max1)
+           pairs_max = colors_max1;
 
        /* this assumes an 80-column line */
        if (opt_wide) {
            width = 4;
            hello = "Test";
-           per_row = (col_limit / ((colors_max > 8) ? 4 : 8));
+           per_row = (col_limit / ((colors_max1 > 8) ? width : 8));
        } else {
            width = 8;
            hello = "Hello";
-           per_row = (col_limit / 8);
+           per_row = (col_limit / width);
        }
        per_row -= MinColors;
 
@@ -2291,10 +2312,12 @@ color_test(bool recur GCC_UNUSED)
        move(0, 0);
        (void) printw("There are %d color pairs and %d colors",
                      pairs_max, COLORS);
-       if (colors_max != COLORS)
-           (void) printw(" (using %d colors)", colors_max);
+       if (colors_max1 != COLORS)
+           (void) printw(" (using %d colors)", colors_max1);
        if (MinColors)
            (void) addstr(" besides 'default'");
+       if (opt_zoom)
+           (void) printw(" zoom:%d", opt_zoom);
 
        clrtobot();
        MvPrintw(top + 1, 0,
@@ -2304,8 +2327,13 @@ color_test(bool recur GCC_UNUSED)
                 opt_bold ? "on" : "off");
 
        /* show color names/numbers across the top */
-       for (i = 0; i < per_row; i++)
-           show_color_name(top + 2, (i + 1) * width, i + MinColors, opt_wide);
+       for (i = 0; i < per_row; i++) {
+           show_color_name(top + 2,
+                           (i + 1) * width,
+                           (int) i * zoom_size + MinColors,
+                           opt_wide,
+                           opt_zoom);
+       }
 
        /* show a grid of colors, with color names/ numbers on the left */
        for (i = (NCURSES_PAIRS_T) (base_row * per_row); i < pairs_max; i++) {
@@ -2316,11 +2344,11 @@ color_test(bool recur GCC_UNUSED)
            if ((i / per_row) > row_limit)
                break;
 
-#define InxToFG(i) (NCURSES_COLOR_T) ((i % (colors_max - MinColors)) + MinColors)
-#define InxToBG(i) (NCURSES_COLOR_T) ((i / (colors_max - MinColors)) + MinColors)
+#define InxToFG(i) (int)((((unsigned long)(i) * (unsigned long)zoom_size) % (unsigned long)(colors_max1 - MinColors)) + (unsigned long)MinColors)
+#define InxToBG(i) (int)((((unsigned long)(i) * (unsigned long)zoom_size) / (unsigned long)(colors_max1 - MinColors)) + (unsigned long)MinColors)
            if (row >= 0 && move(row, col) != ERR) {
-               NCURSES_COLOR_T fg = InxToFG(i);
-               NCURSES_COLOR_T bg = InxToBG(i);
+               NCURSES_COLOR_T fg = (NCURSES_COLOR_T) InxToFG(i);
+               NCURSES_COLOR_T bg = (NCURSES_COLOR_T) InxToBG(i);
 
                init_pair(pair, fg, bg);
                attron(COLOR_PAIR(pair));
@@ -2340,7 +2368,10 @@ color_test(bool recur GCC_UNUSED)
                (void) attrset(A_NORMAL);
 
                if ((i % per_row) == 0 && InxToFG(i) == MinColors) {
-                   show_color_name(row, 0, InxToBG(i), opt_wide);
+                   show_color_name(row, 0,
+                                   InxToBG(i),
+                                   opt_wide,
+                                   opt_zoom);
                }
                ++shown;
            } else if (shown) {
@@ -2388,6 +2419,22 @@ color_test(bool recur GCC_UNUSED)
        case 'W':
            set_color_test(opt_wide, TRUE);
            break;
+       case 'z':
+           if (opt_zoom <= 0) {
+               beep();
+           } else {
+               --opt_zoom;
+               goto reloop;
+           }
+           break;
+       case 'Z':
+           if ((1 << opt_zoom) >= colors_max) {
+               beep();
+           } else {
+               ++opt_zoom;
+               goto reloop;
+           }
+           break;
        case CTRL('p'):
        case KEY_UP:
            if (base_row <= 0) {
@@ -2449,11 +2496,22 @@ color_test(bool recur GCC_UNUSED)
 }
 
 #if USE_WIDEC_SUPPORT
+
+#if HAVE_INIT_EXTENDED_COLOR
+#define InitExtendedPair(p,f,g) init_extended_pair((p),(f),(g))
+#define ExtendedColorSet(p)     color_set((NCURSES_PAIRS_T) (p), &(p))
+#define EXTENDED_PAIRS_T int
+#else
+#define InitExtendedPair(p,f,g) init_pair((NCURSES_PAIRS_T) (p),(f),(g))
+#define ExtendedColorSet(p)     color_set((NCURSES_PAIRS_T) (p), NULL)
+#define EXTENDED_PAIRS_T NCURSES_PAIRS_T
+#endif
+
 /* generate a color test pattern */
 static int
 x_color_test(bool recur GCC_UNUSED)
 {
-    int i;
+    long i;
     int top = 0, width;
     int base_row = 0;
     int grid_top = top + 3;
@@ -2472,6 +2530,7 @@ x_color_test(bool recur GCC_UNUSED)
     bool opt_wide = FALSE;
     bool opt_nums = FALSE;
     bool opt_xchr = FALSE;
+    int opt_zoom = 0;
     wchar_t *buffer = 0;
     WINDOW *helpwin;
 
@@ -2479,8 +2538,8 @@ x_color_test(bool recur GCC_UNUSED)
        Cannot("does not support color.");
        return ERR;
     }
-    numbered = (char *) calloc((size_t) (COLS + 1), sizeof(char));
-    buffer = (wchar_t *) calloc((size_t) (COLS + 1), sizeof(wchar_t));
+    numbered = typeCalloc(char, COLS + 1);
+    buffer = typeCalloc(wchar_t, COLS + 1);
     done = ((COLS < 16) || (numbered == 0) || (buffer == 0));
 
     /*
@@ -2489,27 +2548,32 @@ x_color_test(bool recur GCC_UNUSED)
      */
     for (col_limit = 1; col_limit * 2 < COLS; col_limit *= 2) ;
 
+  reloop:
     while (!done) {
        int shown = 0;
+       int zoom_size = (1 << opt_zoom);
+       int colors_max1 = colors_max / zoom_size;
+       double colors_max2 = (double) colors_max1 * (double) colors_max1;
 
-       pairs_max = (unsigned short) (-1);
-       if (colors_max * colors_max <= COLOR_PAIRS) {
-           int limit = (colors_max - MinColors) * (colors_max - MinColors);
+       pairs_max = ((unsigned) (-1)) / 2;
+       if (colors_max2 <= COLOR_PAIRS) {
+           int limit = (colors_max1 - MinColors) * (colors_max1 - MinColors);
            if (pairs_max > limit)
                pairs_max = limit;
-       } else {
-           if (pairs_max > COLOR_PAIRS)
-               pairs_max = COLOR_PAIRS;
        }
+       if (pairs_max > COLOR_PAIRS)
+           pairs_max = COLOR_PAIRS;
+       if (pairs_max < colors_max1)
+           pairs_max = colors_max1;
 
        if (opt_wide) {
            width = 4;
            hello = "Test";
-           per_row = (col_limit / ((colors_max > 8) ? 4 : 8));
+           per_row = (col_limit / ((colors_max1 > 8) ? width : 8));
        } else {
            width = 8;
            hello = "Hello";
-           per_row = (col_limit / 8);
+           per_row = (col_limit / width);
        }
        per_row -= MinColors;
 
@@ -2526,10 +2590,12 @@ x_color_test(bool recur GCC_UNUSED)
        move(0, 0);
        (void) printw("There are %d color pairs and %d colors",
                      pairs_max, COLORS);
-       if (colors_max != COLORS)
-           (void) printw(" (using %d colors)", colors_max);
+       if (colors_max1 != COLORS)
+           (void) printw(" (using %d colors)", colors_max1);
        if (MinColors)
            (void) addstr(" besides 'default'");
+       if (opt_zoom)
+           (void) printw(" zoom:%d", opt_zoom);
 
        clrtobot();
        MvPrintw(top + 1, 0,
@@ -2539,21 +2605,26 @@ x_color_test(bool recur GCC_UNUSED)
                 opt_bold ? "on" : "off");
 
        /* show color names/numbers across the top */
-       for (i = 0; i < per_row; i++)
-           show_color_name(top + 2, (i + 1) * width, i + MinColors, opt_wide);
+       for (i = 0; i < per_row; i++) {
+           show_color_name(top + 2,
+                           ((int) i + 1) * width,
+                           (int) i * zoom_size + MinColors,
+                           opt_wide,
+                           opt_zoom);
+       }
 
        /* show a grid of colors, with color names/ numbers on the left */
        for (i = (base_row * per_row); i < pairs_max; i++) {
-           int row = grid_top + (i / per_row) - base_row;
-           int col = (i % per_row + 1) * width;
-           NCURSES_PAIRS_T pair = (NCURSES_PAIRS_T) i;
+           int row = grid_top + ((int) i / per_row) - base_row;
+           int col = ((int) i % per_row + 1) * width;
+           int pair = (int) i;
 
            if ((i / per_row) > row_limit)
                break;
 
            if (row >= 0 && move(row, col) != ERR) {
-               init_pair(pair, InxToFG(i), InxToBG(i));
-               (void) color_set(pair, NULL);
+               InitExtendedPair(pair, InxToFG(i), InxToBG(i));
+               (void) ExtendedColorSet(pair);
                if (opt_acsc)
                    attr_on(WA_ALTCHARSET, NULL);
                if (opt_bold)
@@ -2564,7 +2635,7 @@ x_color_test(bool recur GCC_UNUSED)
                if (opt_nums) {
                    _nc_SPRINTF(numbered,
                                _nc_SLIMIT((size_t) (COLS + 1) * sizeof(wchar_t))
-                               "{%02X}", i);
+                               "{%02X}", (unsigned) i);
                    if (opt_xchr) {
                        make_fullwidth_text(buffer, numbered);
                    } else {
@@ -2575,7 +2646,10 @@ x_color_test(bool recur GCC_UNUSED)
                (void) attr_set(A_NORMAL, 0, NULL);
 
                if ((i % per_row) == 0 && InxToFG(i) == MinColors) {
-                   show_color_name(row, 0, InxToBG(i), opt_wide);
+                   show_color_name(row, 0,
+                                   InxToBG(i),
+                                   opt_wide,
+                                   opt_zoom);
                }
                ++shown;
            } else if (shown) {
@@ -2629,6 +2703,22 @@ x_color_test(bool recur GCC_UNUSED)
        case 'X':
            opt_xchr = TRUE;
            break;
+       case 'z':
+           if (opt_zoom <= 0) {
+               beep();
+           } else {
+               --opt_zoom;
+               goto reloop;
+           }
+           break;
+       case 'Z':
+           if ((1 << opt_zoom) >= colors_max) {
+               beep();
+           } else {
+               ++opt_zoom;
+               goto reloop;
+           }
+           break;
        case CTRL('p'):
        case KEY_UP:
            if (base_row <= 0) {
@@ -6656,6 +6746,74 @@ form_test(bool recur GCC_UNUSED)
  ****************************************************************************/
 
 #if HAVE_COPYWIN               /* ...and overlay, overwrite */
+
+static const int overlap_HEAD = 1;
+static const int overlap_FOOT = 6;
+
+static WINDOW *
+make_overlap(int n)
+{
+    WINDOW *result;
+    int y, x;
+
+    getmaxyx(stdscr, y, x);
+    if (y < 23 || x < 80) {
+       Cannot("The screen is too small for this test");
+       result = 0;
+    } else {
+       int ymax = y - (overlap_HEAD + overlap_FOOT);
+       int high = ymax / 5;    /* equal-sized parts for cross */
+       int xmax = x - 2;       /* margin */
+       int wide = (xmax / 5) & ~1;
+       int lmar, tmar;
+
+       if (high > 8)
+           high = 8;
+
+       if (wide > 8)
+           wide = 8;
+
+       tmar = (ymax - (5 * high)) / 2 + overlap_HEAD;
+       lmar = (xmax - (5 * wide)) / 2;
+
+       if (n == 0) {
+           result = newwin(3 * high, 3 * wide, tmar, lmar);
+       } else {
+           result = newwin(3 * high, 3 * wide, tmar + 2 * high, lmar + 2 * wide);
+       }
+    }
+    return result;
+}
+
+static void
+clear_overlap(void)
+{
+    int row;
+
+    for (row = overlap_HEAD; row < LINES - overlap_FOOT; ++row) {
+       move(row, 0);
+       clrtoeol();
+    }
+}
+
+static int
+move_overlap(int shift, WINDOW *win1)
+{
+    int ymax = getmaxy(stdscr) - (overlap_HEAD + overlap_FOOT);
+    int high = ymax / 5;       /* equal-sized parts for cross */
+    int tmar;
+    int xmax1 = getmaxx(win1) + 1;
+    int lmar1 = (COLS - (5 * (xmax1) / 3)) / 2;
+    int rc = ERR;
+
+    if (high > 8)
+       high = 8;
+    tmar = (ymax - (5 * high)) / 2 + overlap_HEAD;
+
+    rc = mvwin(win1, tmar, lmar1 + shift);
+    return rc;
+}
+
 static void
 fillwin(WINDOW *win, char ch)
 {
@@ -6670,24 +6828,107 @@ fillwin(WINDOW *win, char ch)
     }
 }
 
+#define InCross(x,y, x1,y1) \
+           (((x > (x1 - 1) / 3) && (x <= (2 * (x1 - 1)) / 3)) \
+               || (((y > (y1 - 1) / 3) && (y <= (2 * (y1 - 1)) / 3))))
+
 static void
 crosswin(WINDOW *win, char ch)
 {
     int y, x;
     int y1, x1;
+    int xw = 1;
 
     getmaxyx(win, y1, x1);
     for (y = 0; y < y1; y++) {
-       for (x = 0; x < x1; x++)
-           if (((x > (x1 - 1) / 3) && (x <= (2 * (x1 - 1)) / 3))
-               || (((y > (y1 - 1) / 3) && (y <= (2 * (y1 - 1)) / 3)))) {
+       for (x = 0; x < x1; x += xw) {
+           if (InCross(x, y, x1, y1)) {
                wmove(win, y, x);
                waddch(win, UChar(ch));
            }
+       }
     }
 }
 
-#define OVERLAP_FLAVORS 5
+/*
+ * Match "crosswin()", but using line-drawing characters.  This could be done
+ * a little simpler using box(), but the reason for this example is to test
+ * hline/vline and addch with line-drawing vs the copy/overlay functions.
+ */
+static void
+crossbox(WINDOW *win)
+{
+    int y1, x1;
+    int ymax, xmax;
+
+    getmaxyx(win, y1, x1);
+
+    ymax = (y1 + 1);
+    xmax = (x1 + 1);
+
+    mvwhline(win, 0, (xmax / 3), ACS_HLINE, (xmax / 3));
+    mvwhline(win, ymax / 3, 0, ACS_HLINE, xmax);
+    mvwhline(win, ((2 * ymax) / 3) - 1, 0, ACS_HLINE, xmax);
+    mvwhline(win, y1 - 1, (xmax / 3), ACS_HLINE, (xmax / 3));
+
+    mvwvline(win, (ymax / 3), 0, ACS_VLINE, (ymax / 3));
+    mvwvline(win, 0, xmax / 3, ACS_VLINE, ymax);
+    mvwvline(win, 0, ((2 * xmax) / 3) - 1, ACS_VLINE, ymax);
+    mvwvline(win, (ymax / 3), x1 - 1, ACS_VLINE, (ymax / 3));
+
+    mvwaddch(win, 0, (xmax / 3), ACS_ULCORNER);
+    mvwaddch(win, 0, ((2 * xmax) / 3) - 1, ACS_URCORNER);
+    mvwaddch(win, y1 - 1, (xmax / 3), ACS_LLCORNER);
+    mvwaddch(win, y1 - 1, ((2 * xmax) / 3) - 1, ACS_LRCORNER);
+
+    mvwaddch(win, (ymax / 3), 0, ACS_ULCORNER);
+    mvwaddch(win, ((2 * ymax) / 3) - 1, 0, ACS_LLCORNER);
+    mvwaddch(win, (ymax / 3), x1 - 1, ACS_URCORNER);
+    mvwaddch(win, ((2 * ymax) / 3) - 1, x1 - 1, ACS_LRCORNER);
+
+    mvwaddch(win, (ymax / 3), (xmax / 3), ACS_PLUS);
+    mvwaddch(win, (ymax / 3), ((2 * xmax) / 3) - 1, ACS_PLUS);
+    mvwaddch(win, ((2 * ymax) / 3) - 1, ((2 * xmax) / 3) - 1, ACS_PLUS);
+    mvwaddch(win, ((2 * ymax) / 3) - 1, (xmax / 3), ACS_PLUS);
+}
+
+typedef enum {
+    otBASE_refresh = 0
+    ,otBASE_fill
+    ,otBASE_draw
+    ,otBASE_clear
+    ,otBASE_copy
+} otBASE;
+
+#define OVERLAP_FLAVORS 6
+
+typedef enum {
+    otFILL_normal = 0
+    ,otFILL_bold
+    ,otFILL_color
+    ,otFILL_bright
+} otFILL;
+
+#define LimitFILL() UseColors ? 4 : 2
+
+typedef enum {
+    otDRAW_text_cross = 0
+    ,otDRAW_line_box
+    ,otDRAW_line_cross
+    ,otDRAW_set_bg
+    ,otDRAW_reset_bg
+} otDRAW;
+
+#define LimitDRAW() UseColors ? 5 : 3
+
+typedef enum {
+    otCOPY_overwrite = 0
+    ,otCOPY_merge
+    ,otCOPY_force
+    ,otCOPY_overlay
+} otCOPY;
+
+#define LimitCOPY() 4
 
 static void
 overlap_helpitem(int state, int item, char *message)
@@ -6705,18 +6946,18 @@ overlap_test_1_attr(WINDOW *win, int flavor, int col)
 {
     NCURSES_PAIRS_T cpair = (NCURSES_PAIRS_T) (1 + (flavor * 2) + col);
 
-    switch (flavor) {
-    case 0:
+    switch ((otFILL) flavor) {
+    case otFILL_normal:
        (void) wattrset(win, A_NORMAL);
        break;
-    case 1:
+    case otFILL_bold:
        (void) wattrset(win, A_BOLD);
        break;
-    case 2:
+    case otFILL_color:
        init_pair(cpair, COLOR_BLUE, COLOR_WHITE);
        (void) wattrset(win, AttrArg(COLOR_PAIR(cpair), A_NORMAL));
        break;
-    case 3:
+    case otFILL_bright:
        init_pair(cpair, COLOR_WHITE, COLOR_BLUE);
        (void) wattrset(win, AttrArg(COLOR_PAIR(cpair), A_BOLD));
        break;
@@ -6728,18 +6969,21 @@ overlap_test_2_attr(WINDOW *win, int flavor, int col)
 {
     NCURSES_PAIRS_T cpair = (NCURSES_PAIRS_T) (9 + (flavor * 2) + col);
 
-    switch (flavor) {
-    case 0:
+    switch ((otDRAW) flavor) {
+    case otDRAW_text_cross:
        /* no effect */
        break;
-    case 1:
+    case otDRAW_line_box:
        /* no effect */
        break;
-    case 2:
+    case otDRAW_line_cross:
+       /* no effect */
+       break;
+    case otDRAW_set_bg:
        init_pair(cpair, COLOR_RED, COLOR_GREEN);
        wbkgdset(win, colored_chtype(' ', A_BLINK, cpair));
        break;
-    case 3:
+    case otDRAW_reset_bg:
        wbkgdset(win, ' ' | A_NORMAL);
        break;
     }
@@ -6751,6 +6995,7 @@ overlap_help(int state, int flavors[OVERLAP_FLAVORS])
     int row;
     int col;
     int item;
+    int limit[OVERLAP_FLAVORS];
     const char *ths, *tht;
     char msg[80];
 
@@ -6765,68 +7010,69 @@ overlap_help(int state, int flavors[OVERLAP_FLAVORS])
        ths = col ? "B" : "A";
        tht = col ? "A" : "B";
 
-       switch (row) {
-       case 0:
+       switch ((otBASE) row) {
+       case otBASE_refresh:
+           limit[row] = 1;
            flavors[row] = 0;
            _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
                        "refresh %s, then %s, then doupdate.", ths, tht);
            break;
-       case 1:
-           if (UseColors) {
-               flavors[row] %= 4;
-           } else {
-               flavors[row] %= 2;
-           }
+       case otBASE_fill:
+           limit[row] = LimitFILL();
+           flavors[row] %= limit[row];
            overlap_test_1_attr(stdscr, flavors[row], col);
            _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
                        "fill window %s with letter %s.", ths, ths);
            break;
-       case 2:
-           if (UseColors) {
-               flavors[row] %= 4;
-           } else {
-               flavors[row] %= 2;
-           }
-           switch (flavors[row]) {
-           case 0:
+       case otBASE_draw:
+           limit[row] = LimitDRAW();
+           flavors[row] %= limit[row];
+           switch ((otDRAW) flavors[row]) {
+           case otDRAW_text_cross:
                _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
-                           "cross pattern in window %s.", ths);
+                           "cross text-pattern in window %s.", ths);
                break;
-           case 1:
+           case otDRAW_line_box:
                _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
-                           "draw box in window %s.", ths);
+                           "draw line-box in window %s.", ths);
                break;
-           case 2:
+           case otDRAW_line_cross:
+               _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+                           "draw line-cross in window %s.", ths);
+               break;
+           case otDRAW_set_bg:
                _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
                            "set background of window %s.", ths);
                break;
-           case 3:
+           case otDRAW_reset_bg:
                _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
                            "reset background of window %s.", ths);
                break;
            }
            break;
-       case 3:
+       case otBASE_clear:
+           limit[row] = 1;
            flavors[row] = 0;
            _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
                        "clear window %s.", ths);
            break;
-       case 4:
-           flavors[row] %= 4;
-           switch (flavors[row]) {
-           case 0:
+       case otBASE_copy:
+           limit[row] = LimitCOPY();
+           flavors[row] %= limit[row];
+           switch ((otCOPY) flavors[row]) {
+           case otCOPY_overwrite:
                _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
                            "overwrite %s onto %s.", ths, tht);
                break;
-           case 1:
+           case otCOPY_merge:
                _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
                            "copywin(FALSE) %s onto %s.", ths, tht);
                break;
-           case 2:
+           case otCOPY_force:
                _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
                            "copywin(TRUE) %s onto %s.", ths, tht);
                break;
-           case 3:
+           case otCOPY_overlay:
                _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
                            "overlay %s onto %s.", ths, tht);
                break;
@@ -6838,8 +7084,12 @@ overlap_help(int state, int flavors[OVERLAP_FLAVORS])
        wbkgdset(stdscr, ' ' | A_NORMAL);
     }
     move(LINES - 1, 0);
-    printw("^Q/ESC = terminate test.  Up/down/space select test variations (%d %d).",
-          state, flavors[state]);
+    printw("^Q/ESC = terminate test. </> shift. Up/down/space select (row %d",
+          state + 1);
+    if (limit[state] > 1)
+       printw(" test %d:%d", 1 + flavors[state], limit[state]);
+    printw(").");
+    clrtoeol();
 
     return state;
 }
@@ -6866,17 +7116,20 @@ static void
 overlap_test_2(int flavor, int col, WINDOW *a, char fill)
 {
     overlap_test_2_attr(a, flavor, col);
-    switch (flavor) {
-    case 0:
+    switch ((otDRAW) flavor) {
+    case otDRAW_text_cross:
        crosswin(a, fill);
        break;
-    case 1:
+    case otDRAW_line_box:
        box(a, 0, 0);
        break;
-    case 2:
+    case otDRAW_line_cross:
+       crossbox(a);
+       break;
+    case otDRAW_set_bg:
        /* done in overlap_test_2_attr */
        break;
-    case 3:
+    case otDRAW_reset_bg:
        /* done in overlap_test_2_attr */
        break;
     }
@@ -6892,17 +7145,17 @@ overlap_test_3(WINDOW *a)
 static void
 overlap_test_4(int flavor, WINDOW *a, WINDOW *b)
 {
-    switch (flavor) {
-    case 0:
+    switch ((otCOPY) flavor) {
+    case otCOPY_overwrite:
        overwrite(a, b);
        break;
-    case 1:
+    case otCOPY_merge:
        copywin(a, b, 0, 0, 0, 0, getmaxy(b), getmaxx(b), FALSE);
        break;
-    case 2:
+    case otCOPY_force:
        copywin(a, b, 0, 0, 0, 0, getmaxy(b), getmaxx(b), TRUE);
        break;
-    case 3:
+    case otCOPY_overlay:
        overlay(a, b);
        break;
     }
@@ -6912,24 +7165,28 @@ overlap_test_4(int flavor, WINDOW *a, WINDOW *b)
 static int
 overlap_test(bool recur GCC_UNUSED)
 {
+    WINDOW *win1, *win2;
     int ch;
+    int shift = 0, last_refresh = -1;
     int state, flavor[OVERLAP_FLAVORS];
 
-    WINDOW *win1 = newwin(9, 20, 3, 3);
-    WINDOW *win2 = newwin(9, 20, 9, 16);
+    if ((win1 = make_overlap(0)) == 0) {
+       return ERR;
+    } else if ((win2 = make_overlap(1)) == 0) {
+       delwin(win1);
+       return ERR;
+    }
 
     curs_set(0);
     raw();
     refresh();
     move(0, 0);
-    printw("This test shows the behavior of wnoutrefresh() with respect to\n");
-    printw("the shared region of two overlapping windows A and B.  The cross\n");
-    printw("pattern in each window does not overlap the other.\n");
+    printw("Test wnoutrefresh() for two overlapping windows:");
 
     memset(flavor, 0, sizeof(flavor));
     state = overlap_help(0, flavor);
 
-    while (!isQuit(ch = Getchar(), TRUE))
+    while (!isQuit(ch = Getchar(), TRUE)) {
        switch (ch) {
        case 'a':               /* refresh window A first, then B */
            overlap_test_0(win1, win2);
@@ -6940,19 +7197,19 @@ overlap_test(bool recur GCC_UNUSED)
            break;
 
        case 'c':               /* fill window A so it's visible */
-           overlap_test_1(flavor[1], 0, win1, 'A');
+           overlap_test_1(flavor[otBASE_fill], 0, win1, 'A');
            break;
 
        case 'd':               /* fill window B so it's visible */
-           overlap_test_1(flavor[1], 1, win2, 'B');
+           overlap_test_1(flavor[otBASE_fill], 1, win2, 'B');
            break;
 
        case 'e':               /* cross test pattern in window A */
-           overlap_test_2(flavor[2], 0, win1, 'A');
+           overlap_test_2(flavor[otBASE_draw], 0, win1, 'A');
            break;
 
        case 'f':               /* cross test pattern in window A */
-           overlap_test_2(flavor[2], 1, win2, 'B');
+           overlap_test_2(flavor[otBASE_draw], 1, win2, 'B');
            break;
 
        case 'g':               /* clear window A */
@@ -6964,11 +7221,11 @@ overlap_test(bool recur GCC_UNUSED)
            break;
 
        case 'i':               /* overwrite A onto B */
-           overlap_test_4(flavor[4], win1, win2);
+           overlap_test_4(flavor[otBASE_copy], win1, win2);
            break;
 
        case 'j':               /* overwrite B onto A */
-           overlap_test_4(flavor[4], win2, win1);
+           overlap_test_4(flavor[otBASE_copy], win2, win1);
            break;
 
        case CTRL('n'):
@@ -6990,11 +7247,46 @@ overlap_test(bool recur GCC_UNUSED)
            state = overlap_help(state, flavor);
            break;
 
+       case '<':
+           /* FALLTHRU */
+       case '>':
+           /* see below */
+           break;
+
        default:
            beep();
            break;
        }
 
+       switch (ch) {
+       case 'a':
+           /* FALLTHRU */
+       case 'b':
+           last_refresh = ch;
+           break;
+       case '<':
+           shift -= 2;
+           /* FALLTHRU */
+       case '>':
+           shift += 1;
+           if (move_overlap(shift, win1) != OK) {
+               flash();
+               shift += (ch == '>') ? -1 : 1;
+           } else if (last_refresh > 0) {
+               clear_overlap();
+               wnoutrefresh(stdscr);
+               if (last_refresh == 'a')
+                   overlap_test_0(win1, win2);
+               else
+                   overlap_test_0(win2, win1);
+           }
+           break;
+       default:
+           last_refresh = -1;
+           break;
+       }
+    }
+
     delwin(win2);
     delwin(win1);
     erase();
@@ -7002,6 +7294,207 @@ overlap_test(bool recur GCC_UNUSED)
     return OK;
 }
 
+#if USE_WIDEC_SUPPORT
+static void
+x_fillwin(WINDOW *win, wchar_t ch)
+{
+    int y, x;
+    int y1, x1;
+
+    getmaxyx(win, y1, x1);
+    x1 /= 2;
+    for (y = 0; y < y1; y++) {
+       wmove(win, y, 0);
+       for (x = 0; x < x1; x++)
+           waddnwstr(win, &ch, 1);
+    }
+}
+
+static void
+x_crosswin(WINDOW *win, wchar_t ch)
+{
+    int y, x;
+    int y1, x1;
+    int xw = 2;
+
+    getmaxyx(win, y1, x1);
+    for (y = 0; y < y1; y++) {
+       for (x = 0; x < x1; x += xw) {
+           if (InCross(x, y, x1, y1)) {
+               wmove(win, y, x);
+               waddnwstr(win, &ch, 1);
+           }
+       }
+    }
+}
+
+static void
+x_overlap_test_1(int flavor, int col, WINDOW *a, wchar_t fill)
+{
+    overlap_test_1_attr(a, flavor, col);
+    x_fillwin(a, fill);
+    (void) wattrset(a, A_NORMAL);
+}
+
+static void
+x_overlap_test_2(int flavor, int col, WINDOW *a, wchar_t fill)
+{
+    overlap_test_2_attr(a, flavor, col);
+    switch ((otDRAW) flavor) {
+    case otDRAW_text_cross:
+       x_crosswin(a, fill);
+       break;
+    case otDRAW_line_box:
+       box(a, 0, 0);
+       break;
+    case otDRAW_line_cross:
+       crossbox(a);
+       break;
+    case otDRAW_set_bg:
+       /* done in overlap_test_2_attr */
+       break;
+    case otDRAW_reset_bg:
+       /* done in overlap_test_2_attr */
+       break;
+    }
+}
+
+/* test effects of overlapping windows */
+static int
+x_overlap_test(bool recur GCC_UNUSED)
+{
+    const wchar_t WIDE_A = 0xff21;
+    const wchar_t WIDE_B = 0xff22;
+    WINDOW *win1, *win2;
+    int ch;
+    int shift = 0, last_refresh = -1;
+    int state, flavor[OVERLAP_FLAVORS];
+
+    if ((win1 = make_overlap(0)) == 0) {
+       return ERR;
+    } else if ((win2 = make_overlap(1)) == 0) {
+       delwin(win1);
+       return ERR;
+    }
+
+    curs_set(0);
+    raw();
+    refresh();
+    move(0, 0);
+    printw("Test wnoutrefresh() for overlapping windows with double-cell characters:");
+
+    memset(flavor, 0, sizeof(flavor));
+    state = overlap_help(0, flavor);
+
+    while (!isQuit(ch = Getchar(), TRUE)) {
+       switch (ch) {
+       case 'a':               /* refresh window A first, then B */
+           overlap_test_0(win1, win2);
+           break;
+
+       case 'b':               /* refresh window B first, then A */
+           overlap_test_0(win2, win1);
+           break;
+
+       case 'c':               /* fill window A so it's visible */
+           x_overlap_test_1(flavor[otBASE_fill], 0, win1, WIDE_A);
+           break;
+
+       case 'd':               /* fill window B so it's visible */
+           x_overlap_test_1(flavor[otBASE_fill], 1, win2, WIDE_B);
+           break;
+
+       case 'e':               /* cross test pattern in window A */
+           x_overlap_test_2(flavor[otBASE_draw], 0, win1, WIDE_A);
+           break;
+
+       case 'f':               /* cross test pattern in window A */
+           x_overlap_test_2(flavor[otBASE_draw], 1, win2, WIDE_B);
+           break;
+
+       case 'g':               /* clear window A */
+           overlap_test_3(win1);
+           break;
+
+       case 'h':               /* clear window B */
+           overlap_test_3(win2);
+           break;
+
+       case 'i':               /* overwrite A onto B */
+           overlap_test_4(flavor[otBASE_copy], win1, win2);
+           break;
+
+       case 'j':               /* overwrite B onto A */
+           overlap_test_4(flavor[otBASE_copy], win2, win1);
+           break;
+
+       case CTRL('n'):
+       case KEY_DOWN:
+           state = overlap_help(state + 1, flavor);
+           break;
+
+       case CTRL('p'):
+       case KEY_UP:
+           state = overlap_help(state - 1, flavor);
+           break;
+
+       case ' ':
+           flavor[state] += 1;
+           state = overlap_help(state, flavor);
+           break;
+
+       case HELP_KEY_1:
+           state = overlap_help(state, flavor);
+           break;
+
+       case '<':
+           /* FALLTHRU */
+       case '>':
+           /* see below */
+           break;
+
+       default:
+           beep();
+           break;
+       }
+
+       switch (ch) {
+       case 'a':
+           /* FALLTHRU */
+       case 'b':
+           last_refresh = ch;
+           break;
+       case '<':
+           shift -= 2;
+           /* FALLTHRU */
+       case '>':
+           shift += 1;
+           if (move_overlap(shift, win1) != OK) {
+               flash();
+               shift += (ch == '>') ? -1 : 1;
+           } else if (last_refresh > 0) {
+               clear_overlap();
+               wnoutrefresh(stdscr);
+               if (last_refresh == 'a')
+                   overlap_test_0(win1, win2);
+               else
+                   overlap_test_0(win2, win1);
+           }
+           break;
+       default:
+           last_refresh = -1;
+           break;
+       }
+    }
+
+    delwin(win2);
+    delwin(win1);
+    erase();
+    exit_curses();
+    return OK;
+}
+#endif /* USE_WIDEC_SUPPORT */
+
 #endif /* HAVE_COPYWIN */
 
 static void
@@ -7126,7 +7619,7 @@ usage(void)
 #if USE_LIBPANEL
        ,"  -s msec  specify nominal time for panel-demo (default: 1, to hold)"
 #endif
-#if defined(NCURSES_VERSION_PATCH) && (NCURSES_VERSION_PATCH >= 20120714) && !defined(__MINGW32__)
+#if defined(NCURSES_VERSION_PATCH) && (NCURSES_VERSION_PATCH >= 20120714) && !defined(_WIN32)
        ,"  -T       call use_tioctl(TRUE) to allow SIGWINCH to override environment"
 #endif
 #ifdef TRACE
@@ -7229,7 +7722,7 @@ main_menu(bool top)
 #if USE_LIBMENU
        CMDS(TRUE, ONLY(menu_test),     'm', "exercise menu library"),
 #endif
-#if USE_LIBMENU
+#if USE_LIBPANEL
        CMDS(TRUE, BOTH(panel_test),    'o', "exercise panel library"),
 #endif
 #if HAVE_NEWPAD
@@ -7240,7 +7733,7 @@ main_menu(bool top)
        CMDS(TRUE, ONLY(form_test),     'r', "exercise form library"),
 #endif
 #if HAVE_COPYWIN
-       CMDS(TRUE, ONLY(overlap_test),  's', "overlapping-refresh test"),
+       CMDS(TRUE, BOTH(overlap_test),  's', "overlapping-refresh test"),
 #endif
 #if USE_LIBMENU && defined(TRACE)
        CMDS(TRUE, ONLY(trace_set),     't', "set trace level"),
@@ -7415,7 +7908,7 @@ main(int argc, char *argv[])
            nap_msec = (int) atol(optarg);
            break;
 #endif
-#if defined(NCURSES_VERSION_PATCH) && (NCURSES_VERSION_PATCH >= 20120714) && !defined(__MINGW32__)
+#if defined(NCURSES_VERSION_PATCH) && (NCURSES_VERSION_PATCH >= 20120714) && !defined(_WIN32)
        case 'T':
            use_tioctl(TRUE);
            break;