/****************************************************************************
- * Copyright (c) 1998-2013,2014 Free Software Foundation, Inc. *
+ * Copyright (c) 1998-2018,2019 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 *
Author: Eric S. Raymond <esr@snark.thyrsus.com> 1993
Thomas E. Dickey (beginning revision 1.27 in 1996).
-$Id: ncurses.c,v 1.414 2014/08/02 23:10:26 tom Exp $
+$Id: ncurses.c,v 1.521 2019/12/14 23:25:29 tom Exp $
***************************************************************************/
#ifdef TRACE
static unsigned save_trace = TRACE_ORDINARY | TRACE_ICALLS | TRACE_CALLS;
-extern unsigned _nc_tracing;
#endif
#else
#define state_unused
#endif
-#define ToggleAcs(temp,real) temp = ((temp == real) ? 0 : real)
+#define ToggleAcs(temp,real) temp = ((temp == real) ? NULL : real)
#define P(string) printw("%s\n", string)
#define BLANK ' ' /* this is the background character */
-#undef max_colors
-static int max_colors; /* the actual number of colors we'll use */
-static int min_colors; /* the minimum color code */
-static bool use_colors; /* true if we use colors */
+static int MaxColors; /* the actual number of colors we'll use */
+static int MinColors; /* the minimum color code */
+static bool UseColors; /* true if we use colors */
#undef max_pairs
static int max_pairs; /* ...and the number of color pairs */
+#if HAVE_COLOR_CONTENT
typedef struct {
NCURSES_COLOR_T red;
NCURSES_COLOR_T green;
} RGB_DATA;
static RGB_DATA *all_colors;
+#endif
static void main_menu(bool);
+static void failed(const char *s) GCC_NORETURN;
static void
failed(const char *s)
ExitProgram(EXIT_FAILURE);
}
-/* The behavior of mvhline, mvvline for negative/zero length is unspecified,
- * though we can rely on negative x/y values to stop the macro.
- */
-static void
-do_h_line(int y, int x, chtype c, int to)
-{
- if ((to) > (x))
- MvHLine(y, x, c, (to) - (x));
-}
-
-static void
-do_v_line(int y, int x, chtype c, int to)
-{
- if ((to) > (y))
- MvVLine(y, x, c, (to) - (y));
-}
-
static void
Repaint(void)
{
touchwin(stdscr);
+#if HAVE_CURSCR
touchwin(curscr);
wrefresh(curscr);
+#else
+ wrefresh(stdscr);
+#endif
}
static bool
-isQuit(int c)
+isQuit(int c, bool escape)
{
- return ((c) == QUIT || (c) == ESCAPE);
+ return ((c) == QUIT || (escape && ((c) == ESCAPE)));
}
#define case_QUIT QUIT: case ESCAPE
} else {
_nc_tracing = save_trace;
}
- trace(_nc_tracing);
+ curses_trace(_nc_tracing);
if (_nc_tracing)
Trace(("TOGGLE-TRACING ON"));
}
}
#define Getchar() wGetchar(stdscr)
+#if USE_SOFTKEYS
/* replaces wgetnstr(), since we want to be able to edit values */
static void
wGetstring(WINDOW *win, char *buffer, int limit)
{
- int y0, x0, x, ch;
+ int y0, x0, x;
bool done = FALSE;
echo();
x = (int) strlen(buffer);
while (!done) {
+ int ch;
if (x > (int) strlen(buffer))
x = (int) strlen(buffer);
wmove(win, y0, x0);
wmove(win, y0, x0);
noecho();
}
+#endif
#if USE_WIDEC_SUPPORT
static wchar_t
} else {
_nc_tracing = save_trace;
}
- trace(_nc_tracing);
+ curses_trace(_nc_tracing);
if (_nc_tracing)
Trace(("TOGGLE-TRACING ON"));
}
#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)
{
wmove(win, y0, x0);
noecho();
}
+#endif /* USE_SOFTKEYS */
-#endif
+#endif /* USE_WIDEC_SUPPORT */
static void
Pause(void)
{
printw("\nThis %s terminal %s\n\n", getenv("TERM"), what);
Pause();
+ endwin();
}
static void
addstr("Shelling out...");
def_prog_mode();
endwin();
-#ifdef __MINGW32__
+#ifdef _WIN32
system("cmd.exe");
#else
IGNORE_RC(system("sh"));
{
static char buf[80 + (5 * 10) + (32 * 15)];
- (void) sprintf(buf, "id %2d at (%2d, %2d, %d) state %4lx = {",
- ep->id, ep->x, ep->y, ep->z, (unsigned long) ep->bstate);
+ (void) _nc_SPRINTF(buf, _nc_SLIMIT(sizeof(buf))
+ "id %2d at (%2d, %2d, %d) state %4lx = {",
+ ep->id, ep->x, ep->y, ep->z, (unsigned long) ep->bstate);
-#define SHOW(m, s) if ((ep->bstate & m)==m) {strcat(buf,s); strcat(buf, ", ");}
+#define SHOW(m, s) \
+ if ((ep->bstate & m)==m) { \
+ _nc_STRCAT(buf, s, sizeof(buf)); \
+ _nc_STRCAT(buf, ", ", sizeof(buf)); \
+ }
SHOW(BUTTON1_RELEASED, "release-1");
SHOW(BUTTON1_PRESSED, "press-1");
if (buf[strlen(buf) - 1] == ' ')
buf[strlen(buf) - 2] = '\0';
- (void) strcat(buf, "}");
+ _nc_STRCAT(buf, "}", sizeof(buf));
return (buf);
}
static void
show_mouse(WINDOW *win)
{
- int y, x;
MEVENT event;
bool outside;
bool show_loc;
show_loc = wmouse_trafo(win, &event.y, &event.x, FALSE);
if (show_loc) {
+ int y, x;
getyx(win, y, x);
wmove(win, event.y, event.x);
waddch(win, '*');
}
static void
-init_getch(WINDOW *win, GetchFlags flags)
+init_getch(WINDOW *win, GetchFlags flags, int delay)
{
memset(flags, FALSE, NUM_GETCH_FLAGS);
flags[UChar('k')] = (win == stdscr);
flags[UChar('m')] = TRUE;
+ flags[UChar('t')] = (delay != 0);
setup_getch(win, flags);
}
+static bool
+blocking_getch(GetchFlags flags, int delay)
+{
+ return ((delay < 0) && flags['t']);
+}
+
+#define ExitOnEscape() (flags[UChar('k')] && flags[UChar('t')])
+
static void
wgetch_help(WINDOW *win, GetchFlags flags)
{
,"k -- toggle keypad/literal mode"
,"m -- toggle meta (7-bit/8-bit) mode"
,"^q -- quit"
- ,"s -- shell out\n"
+ ,"s -- shell out"
+ ,"t -- toggle timeout"
,"w -- create a new window"
#ifdef SIGTSTP
,"z -- suspend this process"
printw("Type any key to see its %s value. Also:\n",
flags['k'] ? "keypad" : "literal");
for (n = 0; n < SIZEOF(help); ++n) {
+ const char *msg = help[n];
int row = 1 + (int) (n % chk);
int col = (n >= chk) ? COLS / 2 : 0;
- int flg = ((strstr(help[n], "toggle") != 0)
- && (flags[UChar(*help[n])] != FALSE));
+ int flg = ((strstr(msg, "toggle") != 0)
+ && (flags[UChar(*msg)] != FALSE));
+ if (*msg == '^' && ExitOnEscape())
+ msg = "^[,^q -- quit";
if (flg)
(void) standout();
- MvPrintw(row, col, "%s", help[n]);
+ MvPrintw(row, col, "%s", msg);
if (col == 0)
clrtoeol();
if (flg)
{
char buf[BUFSIZ];
int first_y, first_x;
- int c;
int incount = 0;
GetchFlags flags;
- bool blocking = (delay < 0);
- init_getch(win, flags);
+ init_getch(win, flags, delay);
+ notimeout(win, FALSE);
wtimeout(win, delay);
getyx(win, first_y, first_x);
scrollok(win, TRUE);
for (;;) {
+ int c;
+
while ((c = wGetchar(win)) == ERR) {
incount++;
- if (blocking) {
+ if (blocking_getch(flags, delay)) {
(void) wprintw(win, "%05d: input error", incount);
break;
} else {
}
wgetch_wrap(win, first_y);
}
- if (c == ERR && blocking) {
+ if (c == ERR && blocking_getch(flags, delay)) {
wprintw(win, "ERR");
wgetch_wrap(win, first_y);
- } else if (isQuit(c)) {
+ } else if (isQuit(c, ExitOnEscape())) {
break;
} else if (c == 'e') {
flags[UChar('e')] = !flags[UChar('e')];
wgetch_help(win, flags);
} else if (c == 's') {
ShellOut(TRUE);
+ } else if (c == 't') {
+ notimeout(win, flags[UChar('t')]);
+ flags[UChar('t')] = !flags[UChar('t')];
+ wgetch_help(win, flags);
} else if (c == 'w') {
int high = getmaxy(win) - 1 - first_y + 1;
int wide = getmaxx(win) - first_x;
wtimeout(win, -1);
if (!level)
- init_getch(win, flags);
+ init_getch(win, flags, delay);
}
static int
refresh();
#ifdef NCURSES_MOUSE_VERSION
- mousemask(ALL_MOUSE_EVENTS, (mmask_t *) 0);
+ mousemask(ALL_MOUSE_EVENTS | REPORT_MOUSE_POSITION, (mmask_t *) 0);
#endif
(void) printw("Delay in 10ths of a second (<CR> for blocking input)? ");
delay = -1;
}
raw();
- move(5, 0);
+ move(6, 0);
return delay;
}
endwin();
}
-static void
-getch_test(void)
+static int
+getch_test(bool recur GCC_UNUSED)
{
int delay = begin_getch_test();
forget_boxes();
finish_getch_test();
slk_clear();
+ return OK;
}
#if USE_WIDEC_SUPPORT
wint_t c;
int incount = 0;
GetchFlags flags;
- bool blocking = (delay < 0);
- int code;
char *temp;
- init_getch(win, flags);
+ init_getch(win, flags, delay);
+ notimeout(win, FALSE);
wtimeout(win, delay);
getyx(win, first_y, first_x);
scrollok(win, TRUE);
for (;;) {
+ int code;
+
while ((code = wGet_wchar(win, &c)) == ERR) {
incount++;
- if (blocking) {
+ if (blocking_getch(flags, delay)) {
(void) wprintw(win, "%05d: input error", incount);
break;
} else {
}
wgetch_wrap(win, first_y);
}
- if (code == ERR && blocking) {
+ if (code == ERR && blocking_getch(flags, delay)) {
wprintw(win, "ERR");
wgetch_wrap(win, first_y);
- } else if (isQuit((int) c)) {
+ } else if (isQuit((int) c, ExitOnEscape())) {
break;
} else if (c == 'e') {
flags[UChar('e')] = !flags[UChar('e')];
wgetch_help(win, flags);
} else if (c == 's') {
ShellOut(TRUE);
+ } else if (c == 't') {
+ notimeout(win, flags[UChar('t')]);
+ flags[UChar('t')] = !flags[UChar('t')];
+ wgetch_help(win, flags);
} else if (c == 'w') {
int high = getmaxy(win) - 1 - first_y + 1;
int wide = getmaxx(win) - first_x;
wtimeout(win, -1);
if (!level)
- init_getch(win, flags);
+ init_getch(win, flags, delay);
}
-static void
-get_wch_test(void)
+static int
+x_getch_test(bool recur GCC_UNUSED)
{
int delay = begin_getch_test();
forget_boxes();
finish_getch_test();
slk_clear();
+ return OK;
}
#endif
#define ATTRSTRING_1ST 32 /* ' ' */
#define ATTRSTRING_END 126 /* '~' */
-#define COL_ATTRSTRING 25
-#define MARGIN_4_ATTRS (COL_ATTRSTRING + 8)
-#define LEN_ATTRSTRING (COLS - MARGIN_4_ATTRS)
+#define COLS_PRE_ATTRS 5
+#define COLS_AFT_ATTRS 15
+#define COL_ATTRSTRING (COLS_PRE_ATTRS + 17)
+#define LEN_ATTRSTRING (COLS - (COL_ATTRSTRING + COLS_AFT_ATTRS))
#define MAX_ATTRSTRING (ATTRSTRING_END + 1 - ATTRSTRING_1ST)
static char attr_test_string[MAX_ATTRSTRING + 1];
++row;
MvWPrintw(helpwin, row++, col,
"Toggles:");
- if (use_colors) {
+ if (UseColors) {
MvWPrintw(helpwin, row++, col,
- " f/F/b/F toggle foreground/background background color");
+ " f/F/b/B toggle foreground/background background color");
MvWPrintw(helpwin, row++, col,
" t/T toggle text/background color attribute");
}
static void
show_color_attr(int fg, int bg, int tx)
{
- if (use_colors) {
+ if (UseColors) {
printw(" Colors (fg %d, bg %d", fg, bg);
if (tx >= 0)
printw(", text %d", tx);
{
bool error = FALSE;
- if (use_colors) {
+ if (UseColors) {
switch (ch) {
case 'f':
*fg = (NCURSES_COLOR_T) (*fg + 1);
break;
}
if (*fg >= COLORS)
- *fg = (NCURSES_COLOR_T) min_colors;
- if (*fg < min_colors)
+ *fg = (NCURSES_COLOR_T) MinColors;
+ if (*fg < MinColors)
*fg = (NCURSES_COLOR_T) (COLORS - 1);
if (*bg >= COLORS)
- *bg = (NCURSES_COLOR_T) min_colors;
- if (*bg < min_colors)
+ *bg = (NCURSES_COLOR_T) MinColors;
+ if (*bg < MinColors)
*bg = (NCURSES_COLOR_T) (COLORS - 1);
if (*tx >= COLORS)
*tx = -1;
{
char save = attr_test_string[0];
int first = ((int) UChar(save)) + adjust;
- int j, k;
if (first >= ATTRSTRING_1ST) {
+ int j, k;
+
for (j = 0, k = first; j < MAX_ATTRSTRING; ++j, ++k) {
if (k > ATTRSTRING_END)
break;
show_attr(WINDOW *win, int row, int skip, bool arrow, chtype attr, const char *name)
{
int ncv = get_ncv();
- chtype test = attr & (chtype) (~A_ALTCHARSET);
+ chtype test = attr & (chtype) (~(A_ALTCHARSET | A_CHARTEXT));
if (arrow)
- MvPrintw(row, 5, "-->");
- MvPrintw(row, 8, "%s mode:", name);
+ MvPrintw(row, COLS_PRE_ATTRS - 3, "-->");
+ MvPrintw(row, COLS_PRE_ATTRS, "%s mode:", name);
MvPrintw(row, COL_ATTRSTRING - 1, "|");
if (skip)
printw("%*s", skip, " ");
werase(win);
if (attr & A_ALTCHARSET) {
const char *s;
- chtype ch;
for (s = attr_test_string; *s != '\0'; ++s) {
- ch = UChar(*s);
+ chtype ch = UChar(*s);
(void) waddch(win, ch | attr);
}
} else {
if (found)
printw(" (NCV)");
}
- if ((termattrs() & test) != test)
+ if ((termattrs() & test) != test) {
printw(" (Part)");
+ }
}
}
return row + 2;
}
typedef struct {
- attr_t attr;
+ chtype attr;
NCURSES_CONST char *name;
} ATTR_TBL;
/* *INDENT-OFF* */
return result;
}
+#if USE_WIDEC_SUPPORT
+typedef struct {
+ attr_t attr;
+ NCURSES_CONST char *name;
+} W_ATTR_TBL;
+/* *INDENT-OFF* */
+static const W_ATTR_TBL w_attrs_to_test[] = {
+ { WA_STANDOUT, "STANDOUT" },
+ { WA_REVERSE, "REVERSE" },
+ { WA_BOLD, "BOLD" },
+ { WA_UNDERLINE, "UNDERLINE" },
+ { WA_DIM, "DIM" },
+ { WA_BLINK, "BLINK" },
+ { WA_PROTECT, "PROTECT" },
+#ifdef WA_INVIS
+ { WA_INVIS, "INVISIBLE" },
+#endif
+#ifdef WA_ITALIC
+ { WA_ITALIC, "ITALIC" },
+#endif
+ { WA_NORMAL, "NORMAL" },
+};
+/* *INDENT-ON* */
+
+static unsigned
+init_w_attr_list(W_ATTR_TBL * target, attr_t attrs)
+{
+ unsigned result = 0;
+ size_t n;
+
+ for (n = 0; n < SIZEOF(w_attrs_to_test); ++n) {
+ attr_t test = w_attrs_to_test[n].attr;
+ if (test == WA_NORMAL || (test & attrs) != 0) {
+ target[result++] = w_attrs_to_test[n];
+ }
+ }
+ return result;
+}
+#endif
+
static bool
attr_getc(int *skip,
NCURSES_COLOR_T *fg,
case CTRL('L'):
Repaint();
break;
- case '?':
+ case HELP_KEY_1:
if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
box(helpwin, 0, 0);
attr_legend(helpwin);
return result;
}
-static void
-attr_test(void)
+static int
+attr_test(bool recur GCC_UNUSED)
/* test text attributes */
{
int n;
NCURSES_COLOR_T bg = COLOR_BLACK;
NCURSES_COLOR_T tx = -1;
int ac = 0;
- unsigned j, k;
WINDOW *my_wins[SIZEOF(attrs_to_test)];
ATTR_TBL my_list[SIZEOF(attrs_to_test)];
unsigned my_size = init_attr_list(my_list, termattrs());
if (my_size > 1) {
+ unsigned j, k;
+
for (j = 0; j < my_size; ++j) {
my_wins[j] = subwin(stdscr,
1, LEN_ATTRSTRING,
chtype normal = A_NORMAL | BLANK;
chtype extras = (chtype) ac;
- if (use_colors) {
+ if (UseColors) {
NCURSES_PAIRS_T pair = 0;
if ((fg != COLOR_BLACK) || (bg != COLOR_BLACK)) {
pair = 1;
beep();
} else {
extras |= (chtype) COLOR_PAIR(pair);
+ normal &= ~A_COLOR;
}
}
}
for (j = 0; j < my_size; ++j) {
bool arrow = (j == k);
row = show_attr(my_wins[j], row, n, arrow,
+ normal |
extras |
my_list[j].attr |
my_list[k].attr,
my_list[j].name);
}
- MvPrintw(row, 8,
+ MvPrintw(row, COLS_PRE_ATTRS,
"This terminal does %shave the magic-cookie glitch",
get_xmc() > -1 ? "" : "not ");
- MvPrintw(row + 1, 8, "Enter '?' for help.");
+ MvPrintw(row + 1, COLS_PRE_ATTRS, "Enter '?' for help.");
show_color_attr(fg, bg, tx);
printw(" ACS (%d)", ac != 0);
bkgdset(A_NORMAL | BLANK);
erase();
endwin();
+ return OK;
} else {
Cannot("does not support video attributes.");
+ return ERR;
}
}
{
wchar_t save = wide_attr_test_string[0];
int first = ((int) normal_wchar(save)) + adjust;
- int j, k;
if (first >= ATTRSTRING_1ST) {
+ int j, k;
+
for (j = 0, k = first; j < MAX_ATTRSTRING; ++j, ++k) {
if (k > ATTRSTRING_END)
break;
static attr_t
get_wide_background(void)
{
- attr_t result = A_NORMAL;
+ attr_t result = WA_NORMAL;
attr_t attr;
cchar_t ch;
NCURSES_PAIRS_T pair;
- wchar_t wch[10];
memset(&ch, 0, sizeof(ch));
if (getbkgrnd(&ch) != ERR) {
+ wchar_t wch[CCHARW_MAX];
+
if (getcchar(&ch, wch, &attr, &pair, 0) != ERR) {
result = attr;
}
int row,
int skip,
bool arrow,
- chtype attr,
+ attr_t attr,
NCURSES_PAIRS_T pair,
const char *name)
{
int ncv = get_ncv();
- chtype test = attr & ~WA_ALTCHARSET;
+ attr_t test = attr & ~WA_ALTCHARSET;
if (arrow)
- MvPrintw(row, 5, "-->");
- MvPrintw(row, 8, "%s mode:", name);
+ MvPrintw(row, COLS_PRE_ATTRS - 3, "-->");
+ MvPrintw(row, COLS_PRE_ATTRS, "%s mode:", name);
MvPrintw(row, COL_ATTRSTRING - 1, "|");
if (skip)
printw("%*s", skip, " ");
if (found)
printw(" (NCV)");
}
- if ((term_attrs() & test) != test)
+ if ((term_attrs() & test) != test) {
printw(" (Part)");
+ }
}
}
return row + 2;
case CTRL('L'):
Repaint();
break;
- case '?':
+ case HELP_KEY_1:
if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
box_set(helpwin, 0, 0);
attr_legend(helpwin);
return result;
}
-static void
-wide_attr_test(void)
+static int
+x_attr_test(bool recur GCC_UNUSED)
/* test text attributes using wide-character calls */
{
int n;
NCURSES_COLOR_T bg = COLOR_BLACK;
NCURSES_COLOR_T tx = -1;
int ac = 0;
- unsigned j, k;
- ATTR_TBL my_list[SIZEOF(attrs_to_test)];
- WINDOW *my_wins[SIZEOF(attrs_to_test)];
- unsigned my_size = init_attr_list(my_list, term_attrs());
+ W_ATTR_TBL my_list[SIZEOF(w_attrs_to_test)];
+ WINDOW *my_wins[SIZEOF(w_attrs_to_test)];
+ unsigned my_size = init_w_attr_list(my_list, term_attrs());
if (my_size > 1) {
+ unsigned j, k;
+
for (j = 0; j < my_size; ++j) {
my_wins[j] = subwin(stdscr,
1, LEN_ATTRSTRING,
NCURSES_PAIRS_T pair = 0;
NCURSES_PAIRS_T extras = 0;
- if (use_colors) {
+ if (UseColors) {
pair = (NCURSES_PAIRS_T) (fg != COLOR_BLACK || bg != COLOR_BLACK);
if (pair != 0) {
pair = 1;
my_list[j].name);
}
- MvPrintw(row, 8,
+ MvPrintw(row, COLS_PRE_ATTRS,
"This terminal does %shave the magic-cookie glitch",
get_xmc() > -1 ? "" : "not ");
- MvPrintw(row + 1, 8, "Enter '?' for help.");
+ MvPrintw(row + 1, COLS_PRE_ATTRS, "Enter '?' for help.");
show_color_attr(fg, bg, tx);
printw(" ACS (%d)", ac != 0);
set_wide_background(0);
erase();
endwin();
+ return OK;
} else {
Cannot("does not support extended video attributes.");
+ return ERR;
}
}
#endif
};
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) {
- sprintf(temp, "%02d", color);
- width = 4;
+ if (wide || zoom) {
+ _nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
+ "%02d", color);
+ if (wide)
+ width = 4;
+ if ((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) {
- sprintf(temp, "[%02d]", color);
+ _nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
+ "[%02d]", color);
} else if (color < 0) {
- strcpy(temp, "default");
+ _nc_STRCPY(temp, "default", sizeof(temp));
} else {
- sprintf(temp, "%.*s", 16, the_color_names[color]);
+ _nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
+ "%.*s", 16, the_color_names[color]);
}
printw("%-*.*s", width, width, temp);
}
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,
}
/* generate a color test pattern */
-static void
-color_test(void)
+static int
+color_test(bool recur GCC_UNUSED)
{
NCURSES_PAIRS_T i;
int top = 0, width;
int page_size = (LINES - grid_top);
int pairs_max;
int colors_max = COLORS;
+ int col_limit;
int row_limit;
int per_row;
- char numbered[80];
+ char *numbered = 0;
const char *hello;
bool done = FALSE;
bool opt_acsc = FALSE;
bool opt_revs = FALSE;
bool opt_nums = FALSE;
bool opt_wide = FALSE;
+ int opt_zoom = 0;
WINDOW *helpwin;
+ if (!UseColors) {
+ Cannot("does not support color.");
+ return ERR;
+ }
+
+ numbered = typeCalloc(char, COLS + 1);
+ done = ((COLS < 16) || (numbered == 0));
+
+ /*
+ * Because the number of colors is usually a power of two, we also use
+ * a power of two for the number of colors shown per line (to be tidy).
+ */
+ 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 - min_colors) * (colors_max - min_colors);
+ 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 = (colors_max > 8) ? 16 : 8;
+ per_row = (col_limit / ((colors_max1 > 8) ? width : 8));
} else {
width = 8;
hello = "Hello";
- per_row = 8;
+ per_row = (col_limit / width);
}
- per_row -= min_colors;
+ per_row -= MinColors;
row_limit = (pairs_max + per_row - 1) / per_row;
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 (min_colors)
+ 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,
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 + min_colors, 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++) {
int col = (i % per_row + 1) * width;
NCURSES_PAIRS_T pair = i;
-#define InxToFG(i) (NCURSES_COLOR_T) ((i % (colors_max - min_colors)) + min_colors)
-#define InxToBG(i) (NCURSES_COLOR_T) ((i / (colors_max - min_colors)) + min_colors)
+ if ((i / per_row) > row_limit)
+ break;
+
+#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((attr_t) COLOR_PAIR(pair));
+ attron(COLOR_PAIR(pair));
if (opt_acsc)
- attron((attr_t) A_ALTCHARSET);
+ attron(A_ALTCHARSET);
if (opt_bold)
- attron((attr_t) A_BOLD);
+ attron(A_BOLD);
if (opt_revs)
- attron((attr_t) A_REVERSE);
+ attron(A_REVERSE);
if (opt_nums) {
- sprintf(numbered, "{%02X}", (int) i);
+ _nc_SPRINTF(numbered, _nc_SLIMIT((size_t) (COLS + 1))
+ "{%02X}", (int) i);
hello = numbered;
}
printw("%-*.*s", width, width, hello);
(void) attrset(A_NORMAL);
- if ((i % per_row) == 0 && InxToFG(i) == min_colors) {
- show_color_name(row, 0, InxToBG(i), opt_wide);
+ if ((i % per_row) == 0 && InxToFG(i) == MinColors) {
+ show_color_name(row, 0,
+ InxToBG(i),
+ opt_wide,
+ opt_zoom);
}
++shown;
} else if (shown) {
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) {
}
}
break;
- case '?':
+ case HELP_KEY_1:
if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
box(helpwin, 0, 0);
color_legend(helpwin, FALSE);
erase();
endwin();
+
+ free(numbered);
+ return OK;
}
#if USE_WIDEC_SUPPORT
+
+#if USE_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),(NCURSES_COLOR_T)(f),(NCURSES_COLOR_T)(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 void
-wide_color_test(void)
+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;
int page_size = (LINES - grid_top);
- int pairs_max = (unsigned short) (-1);
+ int pairs_max;
int colors_max = COLORS;
+ int col_limit;
int row_limit;
int per_row;
- char numbered[80];
+ char *numbered = 0;
const char *hello;
bool done = FALSE;
bool opt_acsc = FALSE;
bool opt_wide = FALSE;
bool opt_nums = FALSE;
bool opt_xchr = FALSE;
- wchar_t buffer[80];
+ int opt_zoom = 0;
+ wchar_t *buffer = 0;
WINDOW *helpwin;
+ if (!UseColors) {
+ Cannot("does not support color.");
+ return ERR;
+ }
+ numbered = typeCalloc(char, COLS + 1);
+ buffer = typeCalloc(wchar_t, COLS + 1);
+ done = ((COLS < 16) || (numbered == 0) || (buffer == 0));
+
+ /*
+ * Because the number of colors is usually a power of two, we also use
+ * a power of two for the number of colors shown per line (to be tidy).
+ */
+ 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 - min_colors) * (colors_max - min_colors);
+ 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;
- /* this assumes an 80-column line */
if (opt_wide) {
width = 4;
hello = "Test";
- per_row = (colors_max > 8) ? 16 : 8;
+ per_row = (col_limit / ((colors_max1 > 8) ? width : 8));
} else {
width = 8;
hello = "Hello";
- per_row = 8;
+ per_row = (col_limit / width);
}
- per_row -= min_colors;
+ per_row -= MinColors;
if (opt_xchr) {
make_fullwidth_text(buffer, hello);
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 (min_colors)
+ 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,
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 + min_colors, 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((attr_t) A_ALTCHARSET, NULL);
+ attr_on(WA_ALTCHARSET, NULL);
if (opt_bold)
- attr_on((attr_t) A_BOLD, NULL);
+ attr_on(WA_BOLD, NULL);
if (opt_revs)
- attr_on((attr_t) A_REVERSE, NULL);
+ attr_on(WA_REVERSE, NULL);
if (opt_nums) {
- sprintf(numbered, "{%02X}", i);
+ _nc_SPRINTF(numbered,
+ _nc_SLIMIT((size_t) (COLS + 1) * sizeof(wchar_t))
+ "{%02X}", (unsigned) i);
if (opt_xchr) {
make_fullwidth_text(buffer, numbered);
} else {
addnwstr(buffer, width);
(void) attr_set(A_NORMAL, 0, NULL);
- if ((i % per_row) == 0 && InxToFG(i) == min_colors) {
- show_color_name(row, 0, InxToBG(i), opt_wide);
+ if ((i % per_row) == 0 && InxToFG(i) == MinColors) {
+ show_color_name(row, 0,
+ InxToBG(i),
+ opt_wide,
+ opt_zoom);
}
++shown;
} else if (shown) {
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) {
}
}
break;
- case '?':
+ case HELP_KEY_1:
if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
box(helpwin, 0, 0);
color_legend(helpwin, TRUE);
erase();
endwin();
+
+ free(numbered);
+ free(buffer);
+ return OK;
}
#endif /* USE_WIDEC_SUPPORT */
+#if HAVE_COLOR_CONTENT
static void
change_color(NCURSES_PAIRS_T current, int field, int value, int usebase)
{
}
static void
-init_all_colors(void)
+reset_all_colors(void)
{
NCURSES_PAIRS_T c;
all_colors[c].blue);
}
-#define scaled_rgb(n) ((255 * (n)) / 1000)
+#define okCOLOR(n) ((n) >= 0 && (n) < MaxColors)
+#define okRGB(n) ((n) >= 0 && (n) <= 1000)
+#define DecodeRGB(n) (NCURSES_COLOR_T) ((n * 1000) / 0xffff)
static void
-color_edit(void)
+init_all_colors(bool xterm_colors, char *palette_file)
+{
+ NCURSES_PAIRS_T cp;
+ all_colors = typeMalloc(RGB_DATA, (unsigned) MaxColors);
+ if (!all_colors)
+ failed("all_colors");
+ for (cp = 0; cp < MaxColors; ++cp) {
+ color_content(cp,
+ &all_colors[cp].red,
+ &all_colors[cp].green,
+ &all_colors[cp].blue);
+ }
+ /* xterm and compatible terminals can read results of an OSC string
+ * asking for the current color palette.
+ */
+ if (xterm_colors) {
+ int n;
+ char result[BUFSIZ];
+ int check_n;
+ unsigned check_r, check_g, check_b;
+
+ raw();
+ noecho();
+
+ for (n = 0; n < MaxColors; ++n) {
+ int got;
+
+ fprintf(stderr, "\033]4;%d;?\007", n);
+ got = (int) read(0, result, sizeof(result) - 1);
+ if (got < 0)
+ break;
+ result[got] = '\0';
+ if (sscanf(result, "\033]4;%d;rgb:%x/%x/%x\007",
+ &check_n,
+ &check_r,
+ &check_g,
+ &check_b) == 4 &&
+ check_n == n) {
+ all_colors[n].red = DecodeRGB(check_r);
+ all_colors[n].green = DecodeRGB(check_g);
+ all_colors[n].blue = DecodeRGB(check_b);
+ } else {
+ break;
+ }
+ }
+ reset_prog_mode();
+ }
+ if (palette_file != 0) {
+ FILE *fp = fopen(palette_file, "r");
+ if (fp != 0) {
+ char buffer[BUFSIZ];
+ int red, green, blue;
+ int scale = 1000;
+ int c;
+ while (fgets(buffer, sizeof(buffer), fp) != 0) {
+ if (sscanf(buffer, "scale:%d", &c) == 1) {
+ scale = c;
+ } else if (sscanf(buffer, "%d:%d %d %d",
+ &c,
+ &red,
+ &green,
+ &blue) == 4
+ && okCOLOR(c)
+ && okRGB(red)
+ && okRGB(green)
+ && okRGB(blue)) {
+#define Scaled(n) (NCURSES_COLOR_T) (((n) * 1000) / scale)
+ all_colors[c].red = Scaled(red);
+ all_colors[c].green = Scaled(green);
+ all_colors[c].blue = Scaled(blue);
+ }
+ }
+ fclose(fp);
+ }
+ }
+}
+
+#define scaled_rgb(n) ((255 * (n)) / 1000)
+
+static int
+color_edit(bool recur GCC_UNUSED)
/* display the color test pattern, without trying to edit colors */
{
int i;
- int current = 0;
- int this_c = 0, value = 0, field = 0;
+ int current;
+ int this_c, value, field;
int last_c;
- int top_color = 0;
- int page_size = (LINES - 6);
+ int top_color;
+ int page_size;
+
+ if (!UseColors) {
+ Cannot("does not support color.");
+ return ERR;
+ } else if (!can_change_color()) {
+ Cannot("has hardwired color values.");
+ return ERR;
+ }
- init_all_colors();
- refresh();
+ reset_all_colors();
+#ifdef KEY_RESIZE
+ retry:
+#endif
+ current = 0;
+ this_c = 0;
+ value = 0;
+ field = 0;
+ top_color = 0;
+ page_size = (LINES - 6);
+ erase();
- for (i = 0; i < max_colors; i++)
+ for (i = 0; i < MaxColors; i++)
init_pair((NCURSES_PAIRS_T) i,
(NCURSES_COLOR_T) COLOR_WHITE,
(NCURSES_COLOR_T) i);
for (i = (NCURSES_COLOR_T) top_color;
(i - top_color < page_size)
- && (i < max_colors); i++) {
+ && (i < MaxColors); i++) {
char numeric[80];
- sprintf(numeric, "[%d]", i);
+ _nc_SPRINTF(numeric, _nc_SLIMIT(sizeof(numeric)) "[%d]", i);
MvPrintw(2 + i - top_color, 0, "%c %-8s:",
(i == current ? '>' : ' '),
(i < (int) SIZEOF(the_color_names)
value = 0;
switch (this_c) {
+#ifdef KEY_RESIZE
+ case KEY_RESIZE:
+ move(0, 0);
+ goto retry;
+#endif
+ case '!':
+ ShellOut(FALSE);
+ /* FALLTHRU */
+ case CTRL('r'):
+ endwin();
+ refresh();
+ break;
+ case CTRL('l'):
+ refresh();
+ break;
case CTRL('b'):
case KEY_PPAGE:
if (current > 0)
case CTRL('f'):
case KEY_NPAGE:
- if (current < (max_colors - 1))
+ if (current < (MaxColors - 1))
current += (page_size - 1);
else
beep();
case CTRL('p'):
case KEY_UP:
- current = (current == 0 ? (max_colors - 1) : current - 1);
+ current = (current == 0 ? (MaxColors - 1) : current - 1);
break;
case CTRL('n'):
case KEY_DOWN:
- current = (current == (max_colors - 1) ? 0 : current + 1);
+ current = (current == (MaxColors - 1) ? 0 : current + 1);
break;
+ case '\t':
case KEY_RIGHT:
field = (field == 2 ? 0 : field + 1);
break;
+ case KEY_BTAB:
case KEY_LEFT:
field = (field == 0 ? 2 : field - 1);
break;
change_color((NCURSES_PAIRS_T) current, field, value, 0);
break;
- case '?':
+ case HELP_KEY_1:
erase();
P(" RGB Value Editing Help");
P("");
P("To increment or decrement a value, use the same procedure, but finish");
P("with a `+' or `-'.");
P("");
+ P("Use `!' to shell-out, ^R or ^L to repaint the screen.");
+ P("");
P("Press 'm' to invoke the top-level menu with the current color settings.");
P("To quit, do ESC");
case 'm':
endwin();
main_menu(FALSE);
- for (i = 0; i < max_colors; i++)
+ for (i = 0; i < MaxColors; i++)
init_pair((NCURSES_PAIRS_T) i,
(NCURSES_COLOR_T) COLOR_WHITE,
(NCURSES_COLOR_T) i);
if (current < 0)
current = 0;
- if (current >= max_colors)
- current = max_colors - 1;
+ if (current >= MaxColors)
+ current = MaxColors - 1;
if (current < top_color)
top_color = current;
if (current - top_color >= page_size)
MvPrintw(LINES - 1, 0, "Number: %d", value);
clrtoeol();
} while
- (!isQuit(this_c));
+ (!isQuit(this_c, TRUE));
erase();
/*
* ncurses does not reset each color individually when calling endwin().
*/
- init_all_colors();
+ reset_all_colors();
endwin();
+ return OK;
}
+#endif /* HAVE_COLOR_CONTENT */
/****************************************************************************
*
return result;
}
+#if USE_WIDEC_SUPPORT
+static bool
+cycle_w_attr(int ch, unsigned *at_code, attr_t *attr, W_ATTR_TBL * list, unsigned limit)
+{
+ bool result = TRUE;
+
+ switch (ch) {
+ case 'v':
+ if ((*at_code += 1) >= limit)
+ *at_code = 0;
+ break;
+ case 'V':
+ if (*at_code == 0)
+ *at_code = limit - 1;
+ else
+ *at_code -= 1;
+ break;
+ default:
+ result = FALSE;
+ break;
+ }
+ if (result)
+ *attr = list[*at_code].attr;
+ return result;
+}
+#endif
+
static bool
cycle_colors(int ch, int *fg, int *bg, NCURSES_PAIRS_T *pair)
{
bool result = FALSE;
- if (use_colors) {
+ if (UseColors) {
result = TRUE;
switch (ch) {
case 'F':
}
#endif
-static void
-slk_test(void)
+static int
+slk_test(bool recur GCC_UNUSED)
/* exercise the soft keys */
{
int c, fmt = 1;
c = CTRL('l');
#if HAVE_SLK_COLOR
- if (use_colors) {
+ if (UseColors) {
call_slk_color(fg, bg);
}
#endif
case 's':
MvPrintw(SLK_WORK, 0, "Press Q to stop the scrolling-test: ");
while ((c = Getchar()) != 'Q' && (c != ERR))
- addch((chtype) c);
+ AddCh(c);
break;
case 'd':
case '7':
case '8':
MvAddStr(SLK_WORK, 0, "Please enter the label value: ");
- strcpy(buf, "");
+ _nc_STRCPY(buf, "", sizeof(buf));
if ((s = slk_label(c - '0')) != 0) {
- strncpy(buf, s, (size_t) 8);
+ _nc_STRNCPY(buf, s, (size_t) 8);
}
wGetstring(stdscr, buf, 8);
slk_set((c - '0'), buf, fmt);
}
#if HAVE_SLK_COLOR
if (cycle_colors(c, &fg, &bg, &pair)) {
- if (use_colors) {
+ if (UseColors) {
call_slk_color(fg, bg);
} else {
beep();
beep();
break;
}
- } while (!isQuit(c = Getchar()));
+ } while (!isQuit(c = Getchar(), TRUE));
done:
slk_clear();
erase();
endwin();
+ return OK;
}
#if USE_WIDEC_SUPPORT
#define SLKLEN 8
-static void
-wide_slk_test(void)
+static int
+x_slk_test(bool recur GCC_UNUSED)
/* exercise the soft keys */
{
int c, fmt = 1;
wchar_t buf[SLKLEN + 1];
char *s;
- chtype attr = A_NORMAL;
+ attr_t attr = WA_NORMAL;
unsigned at_code = 0;
int fg = COLOR_BLACK;
int bg = COLOR_WHITE;
NCURSES_PAIRS_T pair = 0;
- ATTR_TBL my_list[SIZEOF(attrs_to_test)];
- unsigned my_size = init_attr_list(my_list, term_attrs());
+ W_ATTR_TBL my_list[SIZEOF(w_attrs_to_test)];
+ unsigned my_size = init_w_attr_list(my_list, term_attrs());
c = CTRL('l');
- if (use_colors) {
+ if (UseColors) {
call_slk_color(fg, bg);
}
do {
case 's':
MvPrintw(SLK_WORK, 0, "Press Q to stop the scrolling-test: ");
while ((c = Getchar()) != 'Q' && (c != ERR))
- addch((chtype) c);
+ AddCh(c);
break;
case 'd':
char *temp = strdup(s);
size_t used = strlen(temp);
size_t want = SLKLEN;
- size_t test;
#ifndef state_unused
mbstate_t state;
#endif
buf[0] = L'\0';
while (want > 0 && used != 0) {
+ size_t test;
const char *base = s;
+
reset_mbytes(state);
test = count_mbytes(base, 0, &state);
if (test == (size_t) -1) {
goto done;
case 'F':
- if (use_colors) {
+ if (UseColors) {
fg = (NCURSES_COLOR_T) ((fg + 1) % COLORS);
call_slk_color(fg, bg);
}
break;
case 'B':
- if (use_colors) {
+ if (UseColors) {
bg = (NCURSES_COLOR_T) ((bg + 1) % COLORS);
call_slk_color(fg, bg);
}
break;
#endif
default:
- if (cycle_attr(c, &at_code, &attr, my_list, my_size)) {
+ if (cycle_w_attr(c, &at_code, &attr, my_list, my_size)) {
slk_attr_set(attr, (NCURSES_COLOR_T) (fg || bg), NULL);
slk_touch();
slk_noutrefresh();
}
#if HAVE_SLK_COLOR
if (cycle_colors(c, &fg, &bg, &pair)) {
- if (use_colors) {
+ if (UseColors) {
call_slk_color(fg, bg);
} else {
beep();
beep();
break;
}
- } while (!isQuit(c = Getchar()));
+ } while (!isQuit(c = Getchar(), TRUE));
done:
slk_clear();
erase();
endwin();
+ return OK;
}
#endif
#endif /* SLK_INIT */
int col = (int) (5 * (code % 16));
IGNORE_RC(mvaddch(row, col, colored_chtype(code, attr, pair)));
for (count = 1; count < repeat; ++count) {
- addch(colored_chtype(code, attr, pair));
+ AddCh(colored_chtype(code, attr, pair));
}
}
int row = 2 + ((int) (code - first) % (pagesize / 2));
int col = ((int) (code - first) / (pagesize / 2)) * COLS / 2;
char tmp[80];
- sprintf(tmp, "%3u (0x%x)", code, code);
+ _nc_SPRINTF(tmp, _nc_SLIMIT(sizeof(tmp)) "%3u (0x%x)", code, code);
MvPrintw(row, col, "%*s: ", COLS / 4, tmp);
do {
if (C1) {
/* (yes, this _is_ crude) */
while ((reply = Getchar()) != ERR) {
- addch(UChar(reply));
+ AddCh(UChar(reply));
napms(10);
}
nodelay(stdscr, FALSE);
*/
break;
default:
- addch(colored_chtype(code, A_ALTCHARSET | attr, pair));
+ AddCh(colored_chtype(code, A_ALTCHARSET | attr, pair));
break;
}
} while (--count > 0);
MvAddCh(LINES / 2, 0, colored_chtype(ACS_LTEE, attr, pair));
MvAddCh(LINES / 2, COLS - 1, colored_chtype(ACS_RTEE, attr, pair));
/* *INDENT-ON* */
-
}
static int
MvPrintw(row, col, "%*s : ", COLS / 4, name);
do {
- addch(code);
+ AddCh(code);
} while (--repeat > 0);
return n + 1;
}
n = show_1_acs(n, repeat, BOTH(ACS_S7));
(void) show_1_acs(n, repeat, BOTH(ACS_S9));
#endif
+#undef BOTH
}
-static void
-acs_display(void)
+static int
+acs_test(bool recur GCC_UNUSED)
{
int c = 'a';
int pagesize = 32;
MvPrintw(LINES - 2, 0,
"Select: a=ACS, w=all x=box, %s0=C1, 1-3,+/- non-ASCII, </> repeat, ESC=quit",
pch_kludge);
- if (use_colors) {
+ if (UseColors) {
MvPrintw(LINES - 1, 0,
"v/V, f/F, b/B cycle through video attributes (%s) and color %d/%d.",
my_list[at_code].name,
my_list[at_code].name);
}
refresh();
- } while (!isQuit(c = Getchar()));
+ } while (!isQuit(c = Getchar(), TRUE));
Pause();
erase();
endwin();
+ return OK;
}
#if USE_WIDEC_SUPPORT
static cchar_t *
merge_wide_attr(cchar_t *dst, const cchar_t *src, attr_t attr, NCURSES_PAIRS_T pair)
{
- int count;
*dst = *src;
do {
+ int count;
TEST_CCHAR(src, count, {
attr |= (test_attrs & A_ALTCHARSET);
setcchar(dst, test_wch, attr, pair, NULL);
- }
- , {
+ }, {
;
});
} while (0);
* into account, use 256 characters for the page.
*/
static void
-show_paged_widechars(int base,
- int pagesize,
+show_paged_widechars(unsigned base,
+ unsigned pagesize,
int repeat,
int space,
attr_t attr,
NCURSES_PAIRS_T pair)
{
- int first = base * pagesize;
- int last = first + pagesize - 1;
+ unsigned first = base * pagesize;
+ unsigned last = first + pagesize - 1;
int per_line = 16;
cchar_t temp;
wchar_t code;
MvPrintw(0, 20, "Display of Character Codes %#x to %#x", first, last);
attroff(A_BOLD);
- for (code = (wchar_t) first; (int) code <= last; code++) {
- int row = (2 + ((int) code - first) / per_line);
+ for (code = (wchar_t) first; code <= (wchar_t) last; code++) {
+ int row = (2 + (int) (code - (wchar_t) first) / per_line);
int col = 5 * ((int) code % per_line);
int count;
setcchar(&temp, codes, attr, pair, 0);
move(row, col);
if (wcwidth(code) == 0 && code != 0) {
- addch((chtype) space |
+ AddCh((chtype) space |
(A_REVERSE ^ attr) |
(attr_t) COLOR_PAIR(pair));
}
}
static void
-show_upper_widechars(int first, int repeat, int space, attr_t attr, NCURSES_PAIRS_T pair)
+show_upper_widechars(unsigned first, int repeat, int space, attr_t attr, NCURSES_PAIRS_T pair)
{
cchar_t temp;
wchar_t code;
- int last = first + 31;
+ unsigned last = first + 31;
erase();
attron(A_BOLD);
MvPrintw(0, 20, "Display of Character Codes %d to %d", first, last);
attroff(A_BOLD);
- for (code = (wchar_t) first; (int) code <= last; code++) {
- int row = 2 + ((code - first) % 16);
- int col = ((code - first) / 16) * COLS / 2;
+ for (code = (wchar_t) first; code <= (wchar_t) last; code++) {
+ int row = 2 + ((int) (code - (wchar_t) first) % 16);
+ int col = ((int) (code - (wchar_t) first) / 16) * COLS / 2;
wchar_t codes[10];
char tmp[80];
int count = repeat;
- int y, x;
- sprintf(tmp, "%3ld (0x%lx)", (long) code, (long) code);
+ _nc_SPRINTF(tmp, _nc_SLIMIT(sizeof(tmp))
+ "%3ld (0x%lx)", (long) code, (long) code);
MvPrintw(row, col, "%*s: ", COLS / 4, tmp);
memset(&codes, 0, sizeof(codes));
setcchar(&temp, codes, attr, pair, 0);
do {
+ int y, x;
+
/*
* Give non-spacing characters something to combine with. If we
* don't, they'll bunch up in a heap on the space after the ":".
* the display.
*/
if (wcwidth(code) == 0) {
- addch((chtype) space |
+ AddCh((chtype) space |
(A_REVERSE ^ attr) |
(attr_t) COLOR_PAIR(pair));
}
n = show_1_wacs(n, repeat, BOTH2(WACS_DEGREE));
n = show_1_wacs(n, repeat, BOTH2(WACS_DIAMOND));
n = show_1_wacs(n, repeat, BOTH2(WACS_PLMINUS));
- n = show_1_wacs(n, repeat, BOTH2(WACS_PLUS));
+ n = show_1_wacs(n, repeat, BOTH2(WACS_D_PLUS));
#ifdef CURSES_WACS_ARRAY
n = show_1_wacs(n, repeat, BOTH2(WACS_GEQUAL));
n = show_1_wacs(n, repeat, BOTH2(WACS_DEGREE));
n = show_1_wacs(n, repeat, BOTH2(WACS_DIAMOND));
n = show_1_wacs(n, repeat, BOTH2(WACS_PLMINUS));
- n = show_1_wacs(n, repeat, BOTH2(WACS_PLUS));
+ n = show_1_wacs(n, repeat, BOTH2(WACS_T_PLUS));
#ifdef CURSES_WACS_ARRAY
n = show_1_wacs(n, repeat, BOTH2(WACS_GEQUAL));
(void) mvadd_wch(LINES / 2, 0, MERGE_ATTR(0, WACS_LTEE));
(void) mvadd_wch(LINES / 2, COLS - 1, MERGE_ATTR(0, WACS_RTEE));
/* *INDENT-ON* */
-
}
#undef MERGE_ATTR
MvPrintw(row, col, "%*s : ", COLS / 4, name);
(void) attr_set(attr, pair, 0);
- addstr(strncpy(temp, code, 20));
+ _nc_STRNCPY(temp, code, 20);
+ addstr(temp);
(void) attr_set(A_NORMAL, 0, 0);
return n + 1;
}
n = SHOW_UTF8(n, "WACS_S7", "\342\216\274");
(void) SHOW_UTF8(n, "WACS_S9", "\342\216\275");
/* *INDENT-ON* */
-
}
/* display the wide-ACS character set */
-static void
-wide_acs_display(void)
+static int
+x_acs_test(bool recur GCC_UNUSED)
{
int c = 'a';
- int digit = 0;
+ unsigned digit = 0;
int repeat = 1;
int space = ' ';
- int pagesize = 32;
- chtype attr = A_NORMAL;
+ unsigned pagesize = 32;
+ attr_t attr = WA_NORMAL;
int fg = COLOR_BLACK;
int bg = COLOR_BLACK;
unsigned at_code = 0;
NCURSES_PAIRS_T pair = 0;
void (*last_show_wacs) (int, attr_t, NCURSES_PAIRS_T) = 0;
- ATTR_TBL my_list[SIZEOF(attrs_to_test)];
- unsigned my_size = init_attr_list(my_list, term_attrs());
+ W_ATTR_TBL my_list[SIZEOF(w_attrs_to_test)];
+ unsigned my_size = init_w_attr_list(my_list, term_attrs());
+ char at_page[20];
+ bool pending_code = FALSE;
+ at_page[0] = '\0';
do {
switch (c) {
case CTRL('L'):
case 'u':
ToggleAcs(last_show_wacs, show_utf8_chars);
break;
+ case '@':
+ pending_code = !pending_code;
+ if (pending_code) {
+ _nc_SPRINTF(at_page, _nc_SLIMIT(sizeof(at_page)) "%02x", digit);
+ } else if (at_page[0] != '\0') {
+ _nc_SPRINTF(at_page, _nc_SLIMIT(sizeof(at_page)) "%x", digit);
+ }
+ break;
default:
- if (c < 256 && isdigit(c)) {
- digit = (c - '0');
+ if (pending_code && isxdigit(c)) {
+ size_t len = strlen(at_page);
+ if (len && at_page[0] == '0') {
+ memmove(at_page, at_page + 1, len--);
+ }
+ if (len < sizeof(at_page) - 1) {
+ at_page[len++] = (char) c;
+ at_page[len] = '\0';
+ }
+ } else if (pending_code
+ && (c == '\b' || c == KEY_BACKSPACE || c == KEY_DC)) {
+ size_t len = strlen(at_page);
+ if (len)
+ at_page[--len] = '\0';
+ } else if (c < 256 && isdigit(c)) {
+ digit = (unsigned) (c - '0');
last_show_wacs = 0;
} else if (c == '+') {
++digit;
+ _nc_SPRINTF(at_page, _nc_SLIMIT(sizeof(at_page)) "%02x", digit);
last_show_wacs = 0;
} else if (c == '-' && digit > 0) {
--digit;
+ _nc_SPRINTF(at_page, _nc_SLIMIT(sizeof(at_page)) "%02x",
+ UChar(digit));
last_show_wacs = 0;
} else if (c == '>' && repeat < (COLS / 4)) {
++repeat;
} else if (c == '_') {
space = (space == ' ') ? '_' : ' ';
last_show_wacs = 0;
- } else if (cycle_attr(c, &at_code, &attr, my_list, my_size)
+ } else if (cycle_w_attr(c, &at_code, &attr, my_list, my_size)
|| cycle_colors(c, &fg, &bg, &pair)) {
if (last_show_wacs != 0)
break;
}
MvPrintw(LINES - 4, 0,
- "Select: a/d/t WACS, w=all x=box, u UTF-8, ^L repaint");
+ "Select: a/d/t WACS, w=%d/page, @",
+ pagesize);
+ printw("%s",
+ pending_code ? at_page : "page");
+ addstr(", x=box, u UTF-8, ^L repaint");
MvPrintw(LINES - 3, 2,
"0-9,+/- non-ASCII, </> repeat, _ space, ESC=quit");
- if (use_colors) {
+ if (UseColors) {
MvPrintw(LINES - 2, 2,
"v/V, f/F, b/B cycle through video attributes (%s) and color %d/%d.",
my_list[at_code].name,
my_list[at_code].name);
}
refresh();
- } while (!isQuit(c = Getchar()));
+ } while (!isQuit(c = Getchar(), TRUE));
Pause();
erase();
endwin();
+ return OK;
}
#endif
/*
* Graphic-rendition test (adapted from vttest)
*/
-static void
-test_sgr_attributes(void)
+static int
+sgr_attr_test(bool recur GCC_UNUSED)
{
int pass;
chtype normal = ((pass == 0 ? A_NORMAL : A_REVERSE)) | BLANK;
/* Use non-default colors if possible to exercise bce a little */
- if (use_colors) {
+ if (UseColors) {
init_pair(1, COLOR_WHITE, COLOR_BLUE);
normal |= (chtype) COLOR_PAIR(1);
}
bkgdset(A_NORMAL | BLANK);
erase();
endwin();
+ return OK;
}
/****************************************************************************
WINDOW *wind;
};
-#if defined(NCURSES_VERSION)
-#if (NCURSES_VERSION_PATCH < 20070331) && NCURSES_EXT_FUNCS
+#if defined(NCURSES_VERSION) && NCURSES_EXT_FUNCS
+#if (NCURSES_VERSION_PATCH < 20070331)
#define is_keypad(win) (win)->_use_keypad
#define is_scrollok(win) (win)->_scroll
-#elif !defined(is_keypad)
-#define is_keypad(win) FALSE
-#define is_scrollok(win) FALSE
#endif
#else
#define is_keypad(win) FALSE
static void
newwin_legend(FRAME * curp)
{
+#define DATA(num, name) { name, num }
static const struct {
const char *msg;
int code;
} legend[] = {
- {
- "^C = create window", 0
- },
- {
- "^N = next window", 0
- },
- {
- "^P = previous window", 0
- },
- {
- "^F = scroll forward", 0
- },
- {
- "^B = scroll backward", 0
- },
- {
- "^K = keypad(%s)", 1
- },
- {
- "^S = scrollok(%s)", 2
- },
- {
- "^W = save window to file", 0
- },
- {
- "^R = restore window", 0
- },
+ DATA(0, "^C = create window"),
+ DATA(0, "^N = next window"),
+ DATA(0, "^P = previous window"),
+ DATA(0, "^F = scroll forward"),
+ DATA(0, "^B = scroll backward"),
+ DATA(1, "^K = keypad(%s)"),
+ DATA(2, "^S = scrollok(%s)"),
+ DATA(0, "^W = save window"),
+ DATA(0, "^R = restore window"),
#if HAVE_WRESIZE
- {
- "^X = resize", 0
- },
+ DATA(0, "^X = resize"),
#endif
- {
- "^Q%s = exit", 3
- }
+ DATA(3, "^Q%s = exit")
};
+#undef DATA
size_t n;
- int x;
bool do_keypad = HaveKeypad(curp);
bool do_scroll = HaveScroll(curp);
char buf[BUFSIZ];
move(LINES - 4, 0);
+
for (n = 0; n < SIZEOF(legend); n++) {
+ int x;
+
switch (legend[n].code) {
default:
- strcpy(buf, legend[n].msg);
+ _nc_STRCPY(buf, legend[n].msg, sizeof(buf));
break;
case 1:
- sprintf(buf, legend[n].msg, do_keypad ? "yes" : "no");
+ _nc_SPRINTF(buf, _nc_SLIMIT(sizeof(buf))
+ legend[n].msg, do_keypad ? "yes" : "no");
break;
case 2:
- sprintf(buf, legend[n].msg, do_scroll ? "yes" : "no");
+ _nc_SPRINTF(buf, _nc_SLIMIT(sizeof(buf))
+ legend[n].msg, do_scroll ? "yes" : "no");
break;
case 3:
- sprintf(buf, legend[n].msg, do_keypad ? "/ESC" : "");
+ _nc_SPRINTF(buf, _nc_SLIMIT(sizeof(buf))
+ legend[n].msg, do_keypad ? "/ESC" : "");
break;
}
x = getcurx(stdscr);
break;
}
}
- /* FALLTHRU */
#endif
+ /* FALLTHRU */
default:
res.y = uli + i;
res.x = ulj + j;
}
delwin(fp->wind);
- np = (fp == fp->next) ? 0 : fp->next;
+ np = (fp == fp->next) ? NULL : fp->next;
free(fp);
}
return np;
}
-static void
-acs_and_scroll(void)
+static int
+scroll_test(bool recur GCC_UNUSED)
/* Demonstrate windows */
{
int c;
switch (c) {
case CTRL('C'):
if ((neww = typeCalloc(FRAME, (size_t) 1)) == 0) {
- failed("acs_and_scroll");
+ failed("scroll_test");
goto breakout;
}
if ((neww->wind = getwindow()) == (WINDOW *) 0) {
- failed("acs_and_scroll");
+ failed("scroll_test");
free(neww);
goto breakout;
}
} else if ((fp = fopen(DUMPFILE, "w")) == (FILE *) 0) {
transient(current, "Can't open screen dump file");
} else {
- (void) putwin(frame_win(current), fp);
+ int rc = putwin(frame_win(current), fp);
(void) fclose(fp);
- current = delete_framed(current, TRUE);
+ if (rc == OK) {
+ current = delete_framed(current, TRUE);
+ } else {
+ transient(current, "Can't write screen dump file");
+ }
}
break;
wrefresh(neww->wind);
} else {
- failed("acs_and_scroll");
+ failed("scroll_test");
}
(void) fclose(fp);
}
case CTRL('X'): /* resize window */
if (current) {
pair *tmp, ul, lr;
- int i, mx, my;
+ int mx, my;
move(0, 0);
clrtoeol();
wclrtobot(current->wind);
wmove(current->wind, lr.y, lr.x);
}
- if (mx > tmp->x - ul.x)
+ if (mx > tmp->x - ul.x) {
+ int i;
for (i = 0; i < my; i++) {
wmove(current->wind, i, tmp->x - ul.x + 1);
wclrtoeol(current->wind);
}
+ }
wnoutrefresh(current->wind);
memcpy(&lr, tmp, sizeof(pair));
break;
#endif /* HAVE_WRESIZE */
- case KEY_F(10): /* undocumented --- use this to test area clears */
- selectcell(0, 0, LINES - 1, COLS - 1);
- clrtobot();
- refresh();
- break;
-
case KEY_UP:
newwin_move(current, -1, 0);
break;
usescr = frame_win(current);
wrefresh(usescr);
} while
- (!isQuit(c = wGetchar(usescr))
+ (!isQuit(c = wGetchar(usescr), TRUE)
&& (c != ERR));
breakout:
noraw();
erase();
endwin();
+ return OK;
}
/****************************************************************************
if ((win = newwin(rows, cols, tly, tlx)) != 0) {
if ((pan = new_panel(win)) == 0) {
delwin(win);
- } else if (use_colors) {
+ } else if (UseColors) {
NCURSES_COLOR_T fg = (NCURSES_COLOR_T) ((color == COLOR_BLUE)
? COLOR_WHITE
: COLOR_BLACK);
rmpanel(pan)
--------------------------------------------------------------------------*/
static void
-rmpanel(PANEL * pan)
+rmpanel(PANEL *pan)
{
WINDOW *win = panel_window(pan);
del_panel(pan);
}
static void
-fill_panel(PANEL * pan)
+fill_panel(PANEL *pan)
{
WINDOW *win = panel_window(pan);
const char *userptr = (const char *) panel_userptr(pan);
}
static void
-fill_wide_panel(PANEL * pan)
+fill_wide_panel(PANEL *pan)
{
WINDOW *win = panel_window(pan);
const char *userptr = (const char *) panel_userptr(pan);
#define MAX_PANELS 5
static void
-canned_panel(PANEL * px[MAX_PANELS + 1], NCURSES_CONST char *cmd)
+canned_panel(PANEL *px[MAX_PANELS + 1], NCURSES_CONST char *cmd)
{
int which = cmd[1] - '0';
wait_a_while(nap_msec);
}
-static void
+static int
demo_panels(void (*InitPanel) (WINDOW *), void (*FillPanel) (PANEL *))
{
int count;
erase();
endwin();
+ return OK;
+}
+
+#if USE_LIBPANEL
+static int
+panel_test(bool recur GCC_UNUSED)
+{
+ return demo_panels(init_panel, fill_panel);
+}
+#endif
+
+#if USE_WIDEC_SUPPORT && USE_LIBPANEL
+static int
+x_panel_test(bool recur GCC_UNUSED)
+{
+ return demo_panels(init_wide_panel, fill_wide_panel);
}
+#endif
#endif /* USE_LIBPANEL */
/****************************************************************************
*
****************************************************************************/
+#if HAVE_NEWPAD
+
+/* The behavior of mvhline, mvvline for negative/zero length is unspecified,
+ * though we can rely on negative x/y values to stop the macro.
+ */
+static void
+do_h_line(int y, int x, chtype c, int to)
+{
+ if ((to) > (x))
+ MvHLine(y, x, c, (to) - (x));
+}
+
+static void
+do_v_line(int y, int x, chtype c, int to)
+{
+ if ((to) > (y))
+ MvVLine(y, x, c, (to) - (y));
+}
+
#define GRIDSIZE 3
static bool pending_pan = FALSE;
}
static void
-fill_pad(WINDOW *panpad, bool pan_lines)
+fill_pad(WINDOW *panpad, bool pan_lines, bool colored)
{
int y, x;
unsigned gridcount = 0;
+ chtype fill = 0;
+#ifdef A_COLOR
+ if (colored)
+ fill = (chtype) COLOR_PAIR(1);
+#endif
wmove(panpad, 0, 0);
for (y = 0; y < getmaxy(panpad); y++) {
waddch(panpad, pan_lines ? ACS_LTEE : '+');
else
waddch(panpad, (chtype) ((pan_lines ? 'a' : 'A') +
- (int) (gridcount++ % 26)));
+ (int) (gridcount++ % 26)) | fill);
} else if (y % GRIDSIZE == 0)
waddch(panpad, pan_lines ? ACS_HLINE : '-');
else if (x % GRIDSIZE == 0)
static void
panner(WINDOW *pad,
int top_x, int top_y, int porty, int portx,
- int (*pgetc) (WINDOW *))
+ int (*pgetc) (WINDOW *),
+ bool colored)
{
#if HAVE_GETTIMEOFDAY
struct timeval before, after;
erase();
/* FALLTHRU */
- case '?':
- if (c == '?')
+ case HELP_KEY_1:
+ if (c == HELP_KEY_1)
show_panner_legend = !show_panner_legend;
panner_legend(LINES - 4);
panner_legend(LINES - 3);
break;
case 'a':
pan_lines = !pan_lines;
- fill_pad(pad, pan_lines);
+ fill_pad(pad, pan_lines, colored);
pending_pan = FALSE;
break;
{
static int count;
static int last;
- int c;
if ((pending_pan = (count > 0)) != FALSE) {
count--;
pending_pan = (count != 0);
} else {
for (;;) {
+ int c;
switch (c = wGetchar(win)) {
case '!':
ShellOut(FALSE);
#define PAD_HIGH 200
#define PAD_WIDE 200
-static void
-demo_pad(void)
+static int
+pad_test(bool recur GCC_UNUSED)
/* Demonstrate pads. */
{
WINDOW *panpad = newpad(PAD_HIGH, PAD_WIDE);
if (panpad == 0) {
Cannot("cannot create requested pad");
- return;
+ return ERR;
}
-
- fill_pad(panpad, FALSE);
+#ifdef A_COLOR
+ if (UseColors) {
+ init_pair(1, COLOR_BLACK, COLOR_GREEN);
+ init_pair(2, COLOR_CYAN, COLOR_BLUE);
+ wbkgd(panpad, (chtype) (COLOR_PAIR(2) | ' '));
+ }
+#endif
+ fill_pad(panpad, FALSE, TRUE);
panner_legend(LINES - 4);
panner_legend(LINES - 3);
* We'll still be able to widen it during a test, since that's required
* for testing boundaries.
*/
- panner(panpad, 2, 2, LINES - 5, COLS - 15, padgetch);
+ panner(panpad, 2, 2, LINES - 5, COLS - 15, padgetch, TRUE);
delwin(panpad);
endwin();
erase();
+ return OK;
}
+#endif /* HAVE_NEWPAD */
/****************************************************************************
*
wGetchar(win);
}
-static void
-flushinp_test(WINDOW *win)
+static int
+flushinp_test(bool recur GCC_UNUSED)
/* Input test, adapted from John Burnell's PDCurses tester */
{
+ WINDOW *win = stdscr;
int w, h, bx, by, sw, sh, i;
WINDOW *subWin;
sw = w / 3;
sh = h / 3;
if ((subWin = subwin(win, sh, sw, by + h - sh - 2, bx + w - sw - 2)) == 0)
- return;
+ return ERR;
#ifdef A_COLOR
- if (use_colors) {
+ if (UseColors) {
init_pair(2, COLOR_CYAN, COLOR_BLUE);
wbkgd(subWin, (chtype) (COLOR_PAIR(2) | ' '));
}
Continue(win);
cbreak();
+ return OK;
}
/****************************************************************************
(char *) 0
};
-static void
-menu_test(void)
+static int
+menu_test(bool recur GCC_UNUSED)
{
MENU *m;
ITEM *items[SIZEOF(animals)];
#ifdef NCURSES_MOUSE_VERSION
mousemask(0, (mmask_t *) 0);
#endif
+ return OK;
}
#ifdef TRACE
tracetrace(unsigned tlevel)
{
static char *buf;
+ static size_t need = 12;
int n;
if (buf == 0) {
- size_t need = 12;
for (n = 0; t_tbl[n].name != 0; n++)
need += strlen(t_tbl[n].name) + 2;
buf = typeMalloc(char, need);
if (!buf)
failed("tracetrace");
}
- sprintf(buf, "0x%02x = {", tlevel);
+ _nc_SPRINTF(buf, _nc_SLIMIT(need) "0x%02x = {", tlevel);
if (tlevel == 0) {
- sprintf(buf + strlen(buf), "%s, ", t_tbl[0].name);
+ _nc_STRCAT(buf, t_tbl[0].name, need);
+ _nc_STRCAT(buf, ", ", need);
} else {
for (n = 1; t_tbl[n].name != 0; n++)
if ((tlevel & t_tbl[n].mask) == t_tbl[n].mask) {
- strcat(buf, t_tbl[n].name);
- strcat(buf, ", ");
+ _nc_STRCAT(buf, t_tbl[n].name, need);
+ _nc_STRCAT(buf, ", ", need);
}
}
if (buf[strlen(buf) - 2] == ',')
buf[strlen(buf) - 2] = '\0';
- return (strcat(buf, "}"));
+ _nc_STRCAT(buf, "}", need);
+ return buf;
}
/* fake a dynamically reconfigurable menu using the 0th entry to deselect
}
}
-static void
-trace_set(void)
+static int
+trace_set(bool recur GCC_UNUSED)
/* interactively set the trace level */
{
MENU *m;
for (ip = menu_items(m); *ip; ip++)
if (item_value(*ip))
newtrace |= t_tbl[item_index(*ip)].mask;
- trace(newtrace);
+ curses_trace(newtrace);
Trace(("trace level interactively set to %s", tracetrace(_nc_tracing)));
MvPrintw(LINES - 2, 0,
free_menu(m);
for (ip = items; *ip; ip++)
free_item(*ip);
+
+ return OK;
}
#endif /* TRACE */
#endif /* USE_LIBMENU */
}
static void
-display_form(FORM * f)
+display_form(FORM *f)
{
WINDOW *w;
int rows, cols;
}
static void
-erase_form(FORM * f)
+erase_form(FORM *f)
{
WINDOW *w = form_win(f);
WINDOW *s = form_sub(f);
}
static int
-edit_secure(FIELD * me, int c)
+edit_secure(FIELD *me, int c)
{
int rows, cols, frow, fcol, nrow, nbuf;
size_t have = (source ? strlen(source) : 0) + 1;
size_t need = 80 + have;
char *temp = malloc(need);
- size_t len;
if (temp != 0) {
- strncpy(temp, source ? source : "", have + 1);
+ size_t len;
+ _nc_STRNCPY(temp, source ? source : "", have + 1);
len = (size_t) (char *) field_userptr(me);
if (c <= KEY_MAX) {
if (isgraph(c) && (len + 1) < sizeof(temp)) {
}
static int
-form_virtualize(FORM * f, WINDOW *w)
+form_virtualize(FORM *f, WINDOW *w)
{
/* *INDENT-OFF* */
static const struct {
static int mode = REQ_INS_MODE;
int c = wGetchar(w);
- unsigned n;
FIELD *me = current_field(f);
bool current = TRUE;
}
c = mode;
} else {
+ unsigned n;
for (n = 0; n < SIZEOF(lookup); n++) {
if (lookup[n].code == c) {
c = lookup[n].result;
}
static int
-my_form_driver(FORM * form, int c)
+my_form_driver(FORM *form, int c)
{
if (c == (MAX_FORM_COMMAND + 1)
&& form_driver(form, REQ_VALIDATION) == E_OK)
return (isgraph(ch) ? TRUE : FALSE);
}
-static void
-demo_forms(void)
+static int
+form_test(bool recur GCC_UNUSED)
{
- WINDOW *w;
FORM *form;
FIELD *f[12], *secure;
FIELDTYPE *fty_middle = new_fieldtype(mi_field_check, mi_char_check);
FIELDTYPE *fty_passwd = new_fieldtype(pw_field_check, pw_char_check);
- int finished = 0, c;
+ int c;
unsigned n = 0;
#ifdef NCURSES_MOUSE_VERSION
f[n] = (FIELD *) 0;
if ((form = new_form(f)) != 0) {
+ WINDOW *w;
+ int finished = 0;
display_form(form);
#ifdef NCURSES_MOUSE_VERSION
mousemask(ALL_MOUSE_EVENTS, (mmask_t *) 0);
#endif
+ return OK;
}
#endif /* USE_LIBFORM */
*
****************************************************************************/
+#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)
{
}
}
+#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)
{
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;
{
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;
}
static int
overlap_help(int state, int flavors[OVERLAP_FLAVORS])
{
- int row;
- int col;
int item;
- const char *ths, *tht;
+ int limit[OVERLAP_FLAVORS];
char msg[80];
if (state < 0)
assert(state >= 0 && state < OVERLAP_FLAVORS);
for (item = 0; item < (2 * OVERLAP_FLAVORS); ++item) {
- row = item / 2;
- col = item % 2;
- ths = col ? "B" : "A";
- tht = col ? "A" : "B";
-
- switch (row) {
- case 0:
+ int row = item / 2;
+ int col = item % 2;
+ const char *ths = col ? "B" : "A";
+ const char *tht = col ? "A" : "B";
+
+ switch ((otBASE) row) {
+ case otBASE_refresh:
+ limit[row] = 1;
flavors[row] = 0;
- sprintf(msg, "refresh %s, then %s, then doupdate.", ths, tht);
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "refresh %s, then %s, then doupdate.", ths, tht);
break;
- case 1:
- if (use_colors) {
- 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);
- sprintf(msg, "fill window %s with letter %s.", ths, ths);
- break;
- case 2:
- if (use_colors) {
- flavors[row] %= 4;
- } else {
- flavors[row] %= 2;
- }
- switch (flavors[row]) {
- case 0:
- sprintf(msg, "cross pattern in window %s.", ths);
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "fill window %s with letter %s.", ths, ths);
+ break;
+ 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 text-pattern in window %s.", ths);
break;
- case 1:
- sprintf(msg, "draw box in window %s.", ths);
+ case otDRAW_line_box:
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "draw line-box in window %s.", ths);
+ break;
+ case otDRAW_line_cross:
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "draw line-cross in window %s.", ths);
break;
- case 2:
- sprintf(msg, "set background of window %s.", ths);
+ case otDRAW_set_bg:
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "set background of window %s.", ths);
break;
- case 3:
- sprintf(msg, "reset background of window %s.", ths);
+ 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;
- sprintf(msg, "clear window %s.", ths);
- break;
- case 4:
- flavors[row] %= 4;
- switch (flavors[row]) {
- case 0:
- sprintf(msg, "overwrite %s onto %s.", ths, tht);
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "clear window %s.", ths);
+ break;
+ 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:
- sprintf(msg, "copywin(FALSE) %s onto %s.", ths, tht);
+ case otCOPY_merge:
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "copywin(FALSE) %s onto %s.", ths, tht);
break;
- case 2:
- sprintf(msg, "copywin(TRUE) %s onto %s.", ths, tht);
+ case otCOPY_force:
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "copywin(TRUE) %s onto %s.", ths, tht);
break;
- case 3:
- sprintf(msg, "overlay %s onto %s.", ths, tht);
+ case otCOPY_overlay:
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "overlay %s onto %s.", ths, tht);
break;
}
break;
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;
}
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;
}
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;
}
}
/* test effects of overlapping windows */
-static void
-overlap_test(void)
+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()))
+ while (!isQuit(ch = Getchar(), TRUE)) {
switch (ch) {
case 'a': /* refresh window A first, then B */
overlap_test_0(win1, win2);
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 */
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'):
state = overlap_help(state, flavor);
break;
- case '?':
+ 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();
- curs_set(1);
- endwin();
+ stop_curses();
+ return OK;
}
-/****************************************************************************
- *
- * Main sequence
- *
- ****************************************************************************/
+#if USE_WIDEC_SUPPORT
+static void
+x_fillwin(WINDOW *win, wchar_t ch)
+{
+ int y, x;
+ int y1, x1;
-static bool
-do_single_test(const char c)
-/* perform a single specified test */
+ 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)
{
- switch (c) {
- case 'a':
- getch_test();
- break;
+ int y, x;
+ int y1, x1;
+ int xw = 2;
-#if USE_WIDEC_SUPPORT
- case 'A':
- get_wch_test();
- break;
-#endif
+ 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);
+ }
+ }
+ }
+}
- case 'b':
- attr_test();
- break;
+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);
+}
-#if USE_WIDEC_SUPPORT
- case 'B':
- wide_attr_test();
+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;
-#endif
-
- case 'c':
- if (!use_colors)
- Cannot("does not support color.");
- else
- color_test();
+ case otDRAW_line_box:
+ box(a, 0, 0);
break;
-
-#if USE_WIDEC_SUPPORT
- case 'C':
- if (!use_colors)
- Cannot("does not support color.");
- else
- wide_color_test();
+ case otDRAW_line_cross:
+ crossbox(a);
break;
-#endif
-
- case 'd':
- if (!use_colors)
- Cannot("does not support color.");
- else if (!can_change_color())
- Cannot("has hardwired color values.");
- else
- color_edit();
+ case otDRAW_set_bg:
+ /* done in overlap_test_2_attr */
break;
-
-#if USE_SOFTKEYS
- case 'e':
- slk_test();
+ case otDRAW_reset_bg:
+ /* done in overlap_test_2_attr */
break;
+ }
+}
-#if USE_WIDEC_SUPPORT
- case 'E':
- wide_slk_test();
- break;
-#endif
-#endif
+/* 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];
- case 'f':
- acs_display();
- break;
+ if ((win1 = make_overlap(0)) == 0) {
+ return ERR;
+ } else if ((win2 = make_overlap(1)) == 0) {
+ delwin(win1);
+ return ERR;
+ }
-#if USE_WIDEC_SUPPORT
- case 'F':
- wide_acs_display();
- break;
-#endif
+ curs_set(0);
+ raw();
+ refresh();
+ move(0, 0);
+ printw("Test wnoutrefresh() for overlapping windows with double-cell characters:");
-#if USE_LIBPANEL
- case 'o':
- demo_panels(init_panel, fill_panel);
- break;
-#endif
+ memset(flavor, 0, sizeof(flavor));
+ state = overlap_help(0, flavor);
-#if USE_WIDEC_SUPPORT && USE_LIBPANEL
- case 'O':
- demo_panels(init_wide_panel, fill_wide_panel);
- break;
-#endif
+ while (!isQuit(ch = Getchar(), TRUE)) {
+ switch (ch) {
+ case 'a': /* refresh window A first, then B */
+ overlap_test_0(win1, win2);
+ break;
- case 'g':
- acs_and_scroll();
- break;
+ case 'b': /* refresh window B first, then A */
+ overlap_test_0(win2, win1);
+ break;
- case 'i':
- flushinp_test(stdscr);
- break;
+ case 'c': /* fill window A so it's visible */
+ x_overlap_test_1(flavor[otBASE_fill], 0, win1, WIDE_A);
+ break;
- case 'k':
- test_sgr_attributes();
- break;
+ case 'd': /* fill window B so it's visible */
+ x_overlap_test_1(flavor[otBASE_fill], 1, win2, WIDE_B);
+ break;
-#if USE_LIBMENU
- case 'm':
- menu_test();
- break;
-#endif
+ case 'e': /* cross test pattern in window A */
+ x_overlap_test_2(flavor[otBASE_draw], 0, win1, WIDE_A);
+ break;
- case 'p':
- demo_pad();
- break;
+ case 'f': /* cross test pattern in window A */
+ x_overlap_test_2(flavor[otBASE_draw], 1, win2, WIDE_B);
+ break;
-#if USE_LIBFORM
- case 'r':
- demo_forms();
- break;
-#endif
+ case 'g': /* clear window A */
+ overlap_test_3(win1);
+ break;
- case 's':
- overlap_test();
- break;
+ case 'h': /* clear window B */
+ overlap_test_3(win2);
+ break;
-#if USE_LIBMENU && defined(TRACE)
- case 't':
- trace_set();
- break;
-#endif
+ case 'i': /* overwrite A onto B */
+ overlap_test_4(flavor[otBASE_copy], win1, win2);
+ break;
- case '?':
- break;
+ case 'j': /* overwrite B onto A */
+ overlap_test_4(flavor[otBASE_copy], win2, win1);
+ break;
- default:
- return FALSE;
+ 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;
+ }
}
- return TRUE;
+ delwin(win2);
+ delwin(win1);
+ erase();
+ stop_curses();
+ return OK;
+}
+#endif /* USE_WIDEC_SUPPORT */
+
+#endif /* HAVE_COPYWIN */
+
+static void
+show_setting_name(const char *name)
+{
+ printw("%-25s ", name);
+}
+
+static void
+show_string_setting(const char *name, const char *value)
+{
+ show_setting_name(name);
+ if (value) {
+ printw("\"%s\"", value);
+ } else {
+ attron(A_REVERSE);
+ addstr("<NULL>");
+ attroff(A_REVERSE);
+ }
+ AddCh('\n');
}
+static void
+show_number_setting(const char *name, int value)
+{
+ show_setting_name(name);
+ if (value >= 0) {
+ printw("%d", value);
+ } else {
+ attron(A_REVERSE);
+ printw("%d", value);
+ attroff(A_REVERSE);
+ }
+ AddCh('\n');
+}
+
+static void
+show_boolean_setting(const char *name, int value)
+{
+ show_setting_name(name);
+ if (value >= 0) {
+ printw("%s", value ? "TRUE" : "FALSE");
+ } else {
+ attron(A_REVERSE);
+ printw("%d", value);
+ attroff(A_REVERSE);
+ }
+ AddCh('\n');
+}
+
+static int
+settings_test(bool recur GCC_UNUSED)
+{
+#if USE_WIDEC_SUPPORT
+ wchar_t ch;
+#endif
+
+ move(0, 0);
+ show_string_setting("termname", termname());
+ show_string_setting("longname", longname());
+ show_number_setting("baudrate", baudrate());
+ if (erasechar() > 0) {
+ show_string_setting("unctrl(erasechar)", unctrl((chtype) erasechar()));
+ show_string_setting("keyname(erasechar)", keyname(erasechar()));
+ }
+ if (killchar() > 0) {
+ show_string_setting("unctrl(killchar)", unctrl((chtype) killchar()));
+ show_string_setting("keyname(killchar)", keyname(killchar()));
+ }
+#if USE_WIDEC_SUPPORT
+ if (erasewchar(&ch) == OK) {
+ show_string_setting("key_name(erasewchar)", key_name(ch));
+ }
+ if (killwchar(&ch) == OK) {
+ show_string_setting("key_name(killwchar)", key_name(ch));
+ }
+#endif
+ show_boolean_setting("has_ic", has_ic());
+ show_boolean_setting("has_il", has_il());
+ show_boolean_setting("has_colors", has_colors());
+#if HAVE_COLOR_CONTENT
+ show_boolean_setting("can_change_color", can_change_color());
+#endif
+ Pause();
+ erase();
+ stop_curses();
+ return OK;
+}
+
+/****************************************************************************
+ *
+ * Main sequence
+ *
+ ****************************************************************************/
+
static void
usage(void)
{
," -h rip-off header line (can repeat)"
#endif
," -m do not use colors"
+#if HAVE_COLOR_CONTENT
," -p file rgb values to use in 'd' rather than ncurses's builtin"
+#endif
#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
," -t mask specify default trace-level (may toggle with ^T)"
+#endif
+#if HAVE_COLOR_CONTENT
+ ," -x use xterm-compatible control for reading color palette"
#endif
};
size_t n;
static void
main_menu(bool top)
{
- char command;
-
- 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");
-#if USE_WIDEC_SUPPORT
- (void) puts("B = wide-character attribute test");
+ typedef struct {
+ bool recur;
+ int (*narrow_func) (bool);
+ int (*wide_func) (bool);
+ int code;
+ const char *help;
+ } MyCmds;
+#define BOTH(a) a, x_ ## a
+#define ONLY(a) a, NULL
+#define CMDS(recur, funcs,code,help) { recur, funcs, code, help }
+#else
+ typedef struct {
+ bool recur;
+ int (*narrow_func) (bool);
+ int code;
+ const char *help;
+ } MyCmds;
+#define BOTH(a) a
+#define ONLY(a) a
+#define CMDS(recur, funcs,code,help) { recur, funcs, code, help }
#endif
- (void) puts("c = color test pattern");
-#if USE_WIDEC_SUPPORT
- (void) puts("C = color test pattern using wide-character calls");
+ /* *INDENT-OFF* */
+ static MyCmds cmds[] =
+ {
+ CMDS(TRUE, BOTH(getch_test), 'a', "keyboard and mouse input test"),
+ CMDS(TRUE, BOTH(attr_test), 'b', "character attribute test"),
+ CMDS(TRUE, BOTH(color_test), 'c', "color test pattern"),
+#if HAVE_COLOR_CONTENT
+ CMDS(FALSE, ONLY(color_edit), 'd', "edit RGB color values"),
#endif
- if (top)
- (void) puts("d = edit RGB color values");
#if USE_SOFTKEYS
- (void) puts("e = exercise soft keys");
-#if USE_WIDEC_SUPPORT
- (void) puts("E = exercise soft keys using wide-characters");
-#endif
-#endif
- (void) puts("f = display ACS characters");
-#if USE_WIDEC_SUPPORT
- (void) puts("F = display Wide-ACS characters");
+ CMDS(TRUE, BOTH(slk_test), 'e', "exercise soft keys"),
#endif
- (void) puts("g = display windows and scrolling");
- (void) puts("i = test of flushinp()");
- (void) puts("k = display character attributes");
+ CMDS(TRUE, BOTH(acs_test), 'f', "display ACS characters"),
+ CMDS(TRUE, ONLY(scroll_test), 'g', "display windows and scrolling"),
+ CMDS(TRUE, ONLY(flushinp_test), 'i', "test flushinp()"),
+ CMDS(TRUE, ONLY(sgr_attr_test), 'k', "display character attributes"),
#if USE_LIBMENU
- (void) puts("m = menu code test");
+ CMDS(TRUE, ONLY(menu_test), 'm', "exercise menu library"),
#endif
#if USE_LIBPANEL
- (void) puts("o = exercise panels library");
-#if USE_WIDEC_SUPPORT
- (void) puts("O = exercise panels with wide-characters");
+ CMDS(TRUE, BOTH(panel_test), 'o', "exercise panel library"),
#endif
+#if HAVE_NEWPAD
+ CMDS(TRUE, ONLY(pad_test), 'p', "exercise pad features"),
#endif
- (void) puts("p = exercise pad features");
- (void) puts("q = quit");
-#if USE_LIBFORM
- (void) puts("r = exercise forms code");
+ CMDS(TRUE, ONLY(NULL), 'q', "quit"),
+#if USE_LIBMENU
+ CMDS(TRUE, ONLY(form_test), 'r', "exercise form library"),
+#endif
+#if HAVE_COPYWIN
+ CMDS(TRUE, BOTH(overlap_test), 's', "overlapping-refresh test"),
#endif
- (void) puts("s = overlapping-refresh test");
#if USE_LIBMENU && defined(TRACE)
- (void) puts("t = set trace level");
+ CMDS(TRUE, ONLY(trace_set), 't', "set trace level"),
#endif
- (void) puts("? = repeat this command summary");
+ CMDS(TRUE, ONLY(settings_test), 'v', "show terminal name and settings"),
+ CMDS(FALSE, ONLY(NULL), '?', "repeat this command summary")
+ };
+ /* *INDENT-ON* */
+
+ int (*doit) (bool);
+ char command;
+ unsigned n;
+
+ do {
+ printf("This is the ncurses main menu (uppercase for wide-characters)\n");
+ for (n = 0; n < SIZEOF(cmds); ++n) {
+ if (top || cmds[n].recur) {
+ putchar(' ');
+#if USE_WIDEC_SUPPORT
+ if (cmds[n].wide_func) {
+ printf("%c,", toupper(cmds[n].code));
+ }
+#endif
+ printf("%c\t= %s\n", cmds[n].code, cmds[n].help);
+ }
+ }
(void) fputs("> ", stdout);
(void) fflush(stdout); /* necessary under SVr4 curses */
for (;;) {
char ch = '\0';
if (read(fileno(stdin), &ch, (size_t) 1) <= 0) {
- if (command == 0)
+ int save_err = errno;
+ perror("\nOOPS");
+ if (save_err == EINTR) {
+ clearerr(stdin);
+ continue;
+ } else if (command == 0) {
command = 'q';
+ }
break;
} else if (command == 0 && !isspace(UChar(ch))) {
command = ch;
}
}
- if (do_single_test(command)) {
+ doit = NULL;
+ for (n = 0; n < SIZEOF(cmds); ++n) {
+ if (cmds[n].code == command) {
+ doit = cmds[n].narrow_func;
+ break;
+ }
+#if USE_WIDEC_SUPPORT
+ if (toupper(cmds[n].code) == command) {
+ doit = cmds[n].wide_func;
+ break;
+ }
+#endif
+ }
+
+ if (doit != NULL && doit(FALSE) == OK) {
/*
* This may be overkill; it's intended to reset everything back
* to the initial terminal modes so that tests don't get in
main(argc,argv)
--------------------------------------------------------------------------*/
-#define okCOLOR(n) ((n) >= 0 && (n) < max_colors)
-#define okRGB(n) ((n) >= 0 && (n) <= 1000)
-
int
main(int argc, char *argv[])
{
int c;
int my_e_param = 1;
-#ifdef NCURSES_VERSION
+#ifdef NCURSES_VERSION_PATCH
+#if HAVE_USE_DEFAULT_COLORS
int default_fg = COLOR_WHITE;
int default_bg = COLOR_BLACK;
- bool assumed_colors = FALSE;
bool default_colors = FALSE;
+#if HAVE_ASSUME_DEFAULT_COLORS
+ bool assumed_colors = FALSE;
+#endif
+#endif
#endif
- char *palette_file = 0;
bool monochrome = FALSE;
+#if HAVE_COLOR_CONTENT
+ bool xterm_colors = FALSE;
+ char *palette_file = 0;
+#endif
setlocale(LC_ALL, "");
- while ((c = getopt(argc, argv, "a:dEe:fhmp:s:Tt:")) != -1) {
+ while ((c = getopt(argc, argv, "a:dEe:fhmp:s:Tt:x")) != -1) {
switch (c) {
-#ifdef NCURSES_VERSION
+#ifdef NCURSES_VERSION_PATCH
+#if HAVE_USE_DEFAULT_COLORS
+#if HAVE_ASSUME_DEFAULT_COLORS
case 'a':
assumed_colors = TRUE;
switch (sscanf(optarg, "%d,%d", &default_fg, &default_bg)) {
break;
}
break;
+#endif
case 'd':
default_colors = TRUE;
break;
#endif
+#endif
#if HAVE_USE_ENV
case 'E':
use_env(FALSE);
case 'm':
monochrome = TRUE;
break;
+#if HAVE_COLOR_CONTENT
case 'p':
palette_file = optarg;
break;
+#endif
#if USE_LIBPANEL
case 's':
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;
case 't':
save_trace = (unsigned) strtol(optarg, 0, 0);
break;
+#endif
+#if HAVE_COLOR_CONTENT
+ case 'x':
+ xterm_colors = TRUE;
+ break;
#endif
default:
usage();
#ifdef TRACE
/* enable debugging */
#if !USE_LIBMENU
- trace(save_trace);
+ curses_trace(save_trace);
#else
if (!isatty(fileno(stdin)))
- trace(save_trace);
+ curses_trace(save_trace);
#endif /* USE_LIBMENU */
#endif /* TRACE */
initscr();
bkgdset(BLANK);
+ set_terminal_modes();
+ def_prog_mode();
+
/* tests, in general, will want these modes */
- use_colors = (bool) (monochrome ? FALSE : has_colors());
+ UseColors = (bool) (monochrome ? FALSE : has_colors());
- if (use_colors) {
+ if (UseColors) {
start_color();
#ifdef NCURSES_VERSION_PATCH
- max_colors = COLORS; /* was > 16 ? 16 : COLORS */
+ MaxColors = COLORS; /* was > 16 ? 16 : COLORS */
#if HAVE_USE_DEFAULT_COLORS
if (default_colors) {
use_default_colors();
- min_colors = -1;
+ MinColors = -1;
}
#if HAVE_ASSUME_DEFAULT_COLORS
if (assumed_colors)
#endif
#endif
#else /* normal SVr4 curses */
- max_colors = COLORS; /* was > 8 ? 8 : COLORS */
+ MaxColors = COLORS; /* was > 8 ? 8 : COLORS */
#endif
max_pairs = COLOR_PAIRS; /* was > 256 ? 256 : COLOR_PAIRS */
+#if HAVE_COLOR_CONTENT
if (can_change_color()) {
- NCURSES_PAIRS_T cp;
- all_colors = typeMalloc(RGB_DATA, (unsigned) max_colors);
- if (!all_colors)
- failed("all_colors");
- for (cp = 0; cp < max_colors; ++cp) {
- color_content(cp,
- &all_colors[cp].red,
- &all_colors[cp].green,
- &all_colors[cp].blue);
- }
- if (palette_file != 0) {
- FILE *fp = fopen(palette_file, "r");
- if (fp != 0) {
- char buffer[BUFSIZ];
- int red, green, blue;
- int scale = 1000;
- while (fgets(buffer, sizeof(buffer), fp) != 0) {
- if (sscanf(buffer, "scale:%d", &c) == 1) {
- scale = c;
- } else if (sscanf(buffer, "%d:%d %d %d",
- &c,
- &red,
- &green,
- &blue) == 4
- && okCOLOR(c)
- && okRGB(red)
- && okRGB(green)
- && okRGB(blue)) {
-#define Scaled(n) (NCURSES_COLOR_T) (((n) * 1000) / scale)
- all_colors[c].red = Scaled(red);
- all_colors[c].green = Scaled(green);
- all_colors[c].blue = Scaled(blue);
- }
- }
- fclose(fp);
- }
- }
+ init_all_colors(xterm_colors, palette_file);
}
+#endif
}
- set_terminal_modes();
- def_prog_mode();
/*
* Return to terminal mode, so we're guaranteed of being able to
projects / ncurses.git / blobdiff