/****************************************************************************
- * Copyright (c) 1998-2015,2016 Free Software Foundation, Inc. *
+ * Copyright (c) 1998-2016,2017 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.441 2016/08/27 23:43:06 tom Exp $
+$Id: ncurses.c,v 1.465 2017/09/23 15:42:49 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)
#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
{
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);
}
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
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
"Toggles:");
if (use_colors) {
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");
}
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;
bkgdset(A_NORMAL | BLANK);
erase();
endwin();
+ return OK;
} else {
Cannot("does not support video attributes.");
+ return ERR;
}
}
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;
set_wide_background(0);
erase();
endwin();
+ return OK;
} else {
Cannot("does not support extended video attributes.");
+ return ERR;
}
}
#endif
int width = 8;
if (wide) {
- sprintf(temp, "%02d", color);
+ _nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
+ "%02d", color);
width = 4;
} 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);
}
}
/* 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;
bool opt_wide = FALSE;
WINDOW *helpwin;
+ if (!use_colors) {
+ Cannot("does not support color.");
+ return ERR;
+ }
+
numbered = (char *) calloc((size_t) (COLS + 1), sizeof(char));
done = ((COLS < 16) || (numbered == 0));
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);
}
}
break;
- case '?':
+ case HELP_KEY_1:
if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
box(helpwin, 0, 0);
color_legend(helpwin, FALSE);
endwin();
free(numbered);
+ return OK;
}
#if USE_WIDEC_SUPPORT
/* generate a color test pattern */
-static void
-wide_color_test(void)
+static int
+x_color_test(bool recur GCC_UNUSED)
{
int i;
int top = 0, width;
wchar_t *buffer = 0;
WINDOW *helpwin;
+ if (!use_colors) {
+ 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));
done = ((COLS < 16) || (numbered == 0) || (buffer == 0));
attr_on(A_REVERSE, NULL);
if (opt_nums) {
- sprintf(numbered, "{%02X}", i);
+ _nc_SPRINTF(numbered,
+ _nc_SLIMIT((size_t) (COLS + 1) * sizeof(wchar_t))
+ "{%02X}", i);
if (opt_xchr) {
make_fullwidth_text(buffer, numbered);
} else {
}
}
break;
- case '?':
+ case HELP_KEY_1:
if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) {
box(helpwin, 0, 0);
color_legend(helpwin, TRUE);
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)
{
int n;
int got;
char result[BUFSIZ];
- int check_n, check_r, check_g, check_b;
+ int check_n;
+ unsigned check_r, check_g, check_b;
raw();
noecho();
#define scaled_rgb(n) ((255 * (n)) / 1000)
-static void
-color_edit(void)
+static int
+color_edit(bool recur GCC_UNUSED)
/* display the color test pattern, without trying to edit colors */
{
int i;
int top_color;
int page_size;
+ if (!use_colors) {
+ Cannot("does not support color.");
+ return ERR;
+ } else if (!can_change_color()) {
+ Cannot("has hardwired color values.");
+ return ERR;
+ }
+
reset_all_colors();
#ifdef KEY_RESIZE
retry:
&& (i < max_colors); 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)
change_color((NCURSES_PAIRS_T) current, field, value, 0);
break;
- case '?':
+ case HELP_KEY_1:
erase();
P(" RGB Value Editing Help");
P("");
reset_all_colors();
endwin();
+ return OK;
}
+#endif /* HAVE_COLOR_CONTENT */
/****************************************************************************
*
}
#endif
-static void
-slk_test(void)
+static int
+slk_test(bool recur GCC_UNUSED)
/* exercise the soft keys */
{
int c, fmt = 1;
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);
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;
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':
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);
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;
Pause();
erase();
endwin();
+ return OK;
}
#if USE_WIDEC_SUPPORT
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));
}
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));
* 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));
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;
}
}
/* 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;
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;
bkgdset(A_NORMAL | BLANK);
erase();
endwin();
+ return OK;
}
/****************************************************************************
for (n = 0; n < SIZEOF(legend); n++) {
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;
}
wrefresh(neww->wind);
} else {
- failed("acs_and_scroll");
+ failed("scroll_test");
}
(void) fclose(fp);
}
noraw();
erase();
endwin();
+ return OK;
}
/****************************************************************************
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;
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);
#define PAD_HIGH 200
#define PAD_WIDE 200
-static void
-demo_pad(bool colored)
+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;
}
#ifdef A_COLOR
- if (colored && use_colors) {
+ if (use_colors) {
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, colored);
+ 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, colored);
+ 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) {
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;
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 len;
if (temp != 0) {
- strncpy(temp, source ? source : "", have + 1);
+ _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
-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;
#ifdef NCURSES_MOUSE_VERSION
mousemask(ALL_MOUSE_EVENTS, (mmask_t *) 0);
#endif
+ return OK;
}
#endif /* USE_LIBFORM */
*
****************************************************************************/
+#if HAVE_COPYWIN /* ...and overlay, overwrite */
static void
fillwin(WINDOW *win, char ch)
{
switch (row) {
case 0:
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] %= 2;
}
overlap_test_1_attr(stdscr, flavors[row], col);
- sprintf(msg, "fill window %s with letter %s.", ths, ths);
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "fill window %s with letter %s.", ths, ths);
break;
case 2:
if (use_colors) {
}
switch (flavors[row]) {
case 0:
- sprintf(msg, "cross pattern in window %s.", ths);
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "cross pattern in window %s.", ths);
break;
case 1:
- sprintf(msg, "draw box in window %s.", ths);
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "draw box in window %s.", ths);
break;
case 2:
- sprintf(msg, "set background of window %s.", ths);
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "set background of window %s.", ths);
break;
case 3:
- sprintf(msg, "reset background of window %s.", ths);
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "reset background of window %s.", ths);
break;
}
break;
case 3:
flavors[row] = 0;
- sprintf(msg, "clear window %s.", ths);
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(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))
+ "overwrite %s onto %s.", ths, tht);
break;
case 1:
- sprintf(msg, "copywin(FALSE) %s onto %s.", ths, tht);
+ _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);
+ _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);
+ _nc_SPRINTF(msg, _nc_SLIMIT(sizeof(msg))
+ "overlay %s onto %s.", ths, tht);
break;
}
break;
}
/* test effects of overlapping windows */
-static void
-overlap_test(void)
+static int
+overlap_test(bool recur GCC_UNUSED)
{
int ch;
int state, flavor[OVERLAP_FLAVORS];
state = overlap_help(state, flavor);
break;
- case '?':
+ case HELP_KEY_1:
state = overlap_help(state, flavor);
break;
delwin(win2);
delwin(win1);
erase();
- curs_set(1);
- endwin();
+ exit_curses();
+ return OK;
}
+#endif /* HAVE_COPYWIN */
+
static void
show_setting_name(const char *name)
{
addstr("<NULL>");
attroff(A_REVERSE);
}
- addch('\n');
+ AddCh('\n');
}
static void
printw("%d", value);
attroff(A_REVERSE);
}
- addch('\n');
+ AddCh('\n');
}
static void
printw("%d", value);
attroff(A_REVERSE);
}
- addch('\n');
+ AddCh('\n');
}
-static void
-show_settings(void)
+static int
+settings_test(bool recur GCC_UNUSED)
{
#if USE_WIDEC_SUPPORT
wchar_t ch;
show_string_setting("longname", longname());
show_number_setting("baudrate", baudrate());
if (erasechar() > 0) {
- show_string_setting("unctrl(erasechar)", unctrl(erasechar()));
+ show_string_setting("unctrl(erasechar)", unctrl((chtype) erasechar()));
show_string_setting("keyname(erasechar)", keyname(erasechar()));
}
if (killchar() > 0) {
- show_string_setting("unctrl(killchar)", unctrl(killchar()));
+ show_string_setting("unctrl(killchar)", unctrl((chtype) killchar()));
show_string_setting("keyname(killchar)", keyname(killchar()));
}
#if USE_WIDEC_SUPPORT
show_boolean_setting("has_il", has_il());
Pause();
erase();
- endwin();
+ exit_curses();
+ return OK;
}
/****************************************************************************
*
****************************************************************************/
-static bool
-do_single_test(const char c)
-/* perform a single specified test */
-{
- switch (c) {
- case 'a':
- getch_test();
- break;
-
-#if USE_WIDEC_SUPPORT
- case 'A':
- get_wch_test();
- break;
-#endif
-
- case 'b':
- attr_test();
- break;
-
-#if USE_WIDEC_SUPPORT
- case 'B':
- wide_attr_test();
- break;
-#endif
-
- case 'c':
- if (!use_colors)
- Cannot("does not support color.");
- else
- color_test();
- break;
-
-#if USE_WIDEC_SUPPORT
- case 'C':
- if (!use_colors)
- Cannot("does not support color.");
- else
- wide_color_test();
- 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();
- break;
-
-#if USE_SOFTKEYS
- case 'e':
- slk_test();
- break;
-
-#if USE_WIDEC_SUPPORT
- case 'E':
- wide_slk_test();
- break;
-#endif
-#endif
-
- case 'f':
- acs_display();
- break;
-
-#if USE_WIDEC_SUPPORT
- case 'F':
- wide_acs_display();
- break;
-#endif
-
-#if USE_LIBPANEL
- case 'o':
- demo_panels(init_panel, fill_panel);
- break;
-#endif
-
-#if USE_WIDEC_SUPPORT && USE_LIBPANEL
- case 'O':
- demo_panels(init_wide_panel, fill_wide_panel);
- break;
-#endif
-
- case 'g':
- acs_and_scroll();
- break;
-
- case 'i':
- flushinp_test(stdscr);
- break;
-
- case 'k':
- test_sgr_attributes();
- break;
-
-#if USE_LIBMENU
- case 'm':
- menu_test();
- break;
-#endif
-
- case 'p':
- demo_pad(FALSE);
- break;
-
- case 'P':
- demo_pad(TRUE);
- break;
-
-#if USE_LIBFORM
- case 'r':
- demo_forms();
- break;
-#endif
-
- case 's':
- overlap_test();
- break;
-
-#if USE_LIBMENU && defined(TRACE)
- case 't':
- trace_set();
- break;
-#endif
-
- case 'v':
- show_settings();
- break;
-
- case '?':
- break;
-
- default:
- return FALSE;
- }
-
- return TRUE;
-}
-
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
#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;
for (n = 0; n < SIZEOF(tbl); 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
+ CMDS(TRUE, BOTH(slk_test), 'e', "exercise soft keys"),
#endif
- (void) puts("f = display ACS characters");
-#if USE_WIDEC_SUPPORT
- (void) puts("F = display Wide-ACS characters");
+ 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
+ CMDS(TRUE, ONLY(menu_test), 'm', "exercise menu library"),
#endif
- (void) puts("g = display windows and scrolling");
- (void) puts("i = test of flushinp()");
- (void) puts("k = display character attributes");
#if USE_LIBMENU
- (void) puts("m = menu code test");
+ CMDS(TRUE, BOTH(panel_test), 'o', "exercise panel library"),
#endif
-#if USE_LIBPANEL
- (void) puts("o = exercise panels library");
-#if USE_WIDEC_SUPPORT
- (void) puts("O = exercise panels with wide-characters");
+#if HAVE_NEWPAD
+ CMDS(TRUE, ONLY(pad_test), 'p', "exercise pad features"),
#endif
+ CMDS(TRUE, ONLY(NULL), 'q', "quit"),
+#if USE_LIBMENU
+ CMDS(TRUE, ONLY(form_test), 'r', "exercise form library"),
#endif
- (void) puts("p = exercise pad features");
- (void) puts("P = exercise pad features, using color");
- (void) puts("q = quit");
-#if USE_LIBFORM
- (void) puts("r = exercise forms code");
+#if HAVE_COPYWIN
+ CMDS(TRUE, ONLY(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
+ 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
- (void) puts("v = show terminal name and settings");
- (void) puts("? = repeat this command summary");
+ printf("%c\t= %s\n", cmds[n].code, cmds[n].help);
+ }
+ }
(void) fputs("> ", stdout);
(void) fflush(stdout); /* necessary under SVr4 curses */
}
}
- 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
bool assumed_colors = FALSE;
bool default_colors = FALSE;
#endif
- char *palette_file = 0;
bool monochrome = FALSE;
+#if HAVE_COLOR_CONTENT
bool xterm_colors = FALSE;
+ char *palette_file = 0;
+#endif
setlocale(LC_ALL, "");
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);
save_trace = (unsigned) strtol(optarg, 0, 0);
break;
#endif
+#if HAVE_COLOR_CONTENT
case 'x':
xterm_colors = TRUE;
break;
+#endif
default:
usage();
}
#endif
max_pairs = COLOR_PAIRS; /* was > 256 ? 256 : COLOR_PAIRS */
+#if HAVE_COLOR_CONTENT
if (can_change_color()) {
init_all_colors(xterm_colors, palette_file);
}
+#endif
}
/*
projects / ncurses.git / blobdiff