X-Git-Url: http://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=test%2Fncurses.c;h=91acade3c8daea53b3edaf1c2f0adfd82aa73f3c;hp=791c3a4157c9eeafec9c2d041a335247e13e1a8f;hb=8144a95f5729b46a1ad4f4c3c4ba29800304e4c0;hpb=a8987e73ec254703634802b4f7ee30d3a485524d diff --git a/test/ncurses.c b/test/ncurses.c index 791c3a41..91acade3 100644 --- a/test/ncurses.c +++ b/test/ncurses.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1998-2003,2004 Free Software Foundation, Inc. * + * Copyright (c) 1998-2006,2007 Free Software Foundation, Inc. * * * * Permission is hereby granted, free of charge, to any person obtaining a * * copy of this software and associated documentation files (the * @@ -40,12 +40,16 @@ AUTHOR Author: Eric S. Raymond 1993 Thomas E. Dickey (beginning revision 1.27 in 1996). -$Id: ncurses.c,v 1.202 2004/02/07 20:24:08 tom Exp $ +$Id: ncurses.c,v 1.296 2007/12/29 21:05:43 tom Exp $ ***************************************************************************/ #include +#ifdef __hpux +#undef mvwdelch /* HPUX 11.23 macro will not compile */ +#endif + #if HAVE_GETTIMEOFDAY #if HAVE_SYS_TIME_H && HAVE_SYS_TIME_SELECT #include @@ -69,15 +73,20 @@ $Id: ncurses.c,v 1.202 2004/02/07 20:24:08 tom Exp $ #ifdef NCURSES_VERSION +#define NCURSES_CONST_PARAM const void + #ifdef TRACE -static int save_trace = TRACE_ORDINARY | TRACE_CALLS; -extern int _nc_tracing; +static unsigned save_trace = TRACE_ORDINARY | TRACE_CALLS; +extern unsigned _nc_tracing; #endif #else +#define NCURSES_CONST_PARAM char + #define mmask_t chtype /* not specified in XSI */ +#ifndef ACS_S3 #ifdef CURSES_ACS_ARRAY #define ACS_S3 (CURSES_ACS_ARRAY['p']) /* scan line 3 */ #define ACS_S7 (CURSES_ACS_ARRAY['r']) /* scan line 7 */ @@ -95,6 +104,7 @@ extern int _nc_tracing; #define ACS_NEQUAL (A_ALTCHARSET + '|') /* not equal */ #define ACS_STERLING (A_ALTCHARSET + '}') /* UK pound sign */ #endif +#endif /* ACS_S3 */ #ifdef CURSES_WACS_ARRAY #define WACS_S3 (&(CURSES_WACS_ARRAY['p'])) /* scan line 3 */ @@ -114,10 +124,22 @@ extern int _nc_tracing; #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 */ #undef max_pairs static int max_pairs; /* ...and the number of color pairs */ +typedef struct { + short red; + short green; + short blue; +} RGB_DATA; + +static RGB_DATA *all_colors; + +static void main_menu(bool); + /* The behavior of mvhline, mvvline for negative/zero length is unspecified, * though we can rely on negative x/y values to stop the macro. */ @@ -135,6 +157,21 @@ do_v_line(int y, int x, chtype c, int to) mvvline(y, x, c, (to) - (y)); } +static void +Repaint(void) +{ + touchwin(stdscr); + touchwin(curscr); + wrefresh(curscr); +} + +static bool +isQuit(int c) +{ + return ((c) == QUIT || (c) == ESCAPE); +} +#define case_QUIT case QUIT: case ESCAPE + /* Common function to allow ^T to toggle trace-mode in the middle of a test * so that trace-files can be made smaller. */ @@ -232,7 +269,7 @@ wGetstring(WINDOW *win, char *buffer, int limit) #if USE_WIDEC_SUPPORT static int -wGet_wchar(WINDOW *win, wint_t * result) +wGet_wchar(WINDOW *win, wint_t *result) { int c; #ifdef TRACE @@ -257,11 +294,12 @@ wGet_wchar(WINDOW *win, wint_t * result) /* replaces wgetn_wstr(), since we want to be able to edit values */ static void -wGet_wstring(WINDOW *win, wchar_t * buffer, int limit) +wGet_wstring(WINDOW *win, wchar_t *buffer, int limit) { int y0, x0, x; wint_t ch; bool done = FALSE; + bool fkey = FALSE; echo(); getyx(win, y0, x0); @@ -271,32 +309,46 @@ wGet_wstring(WINDOW *win, wchar_t * buffer, int limit) while (!done) { if (x > (int) wcslen(buffer)) x = (int) wcslen(buffer); + + /* clear the "window' */ + wmove(win, y0, x0); + wprintw(win, "%*s", limit, " "); + + /* write the existing buffer contents */ wmove(win, y0, x0); waddnwstr(win, buffer, limit); - if (x < limit) - wprintw(win, "%*s", limit - x, " "); - wmove(win, y0, x0 + x); + + /* positions the cursor past character 'x' */ + wmove(win, y0, x0); + waddnwstr(win, buffer, x); + switch (wGet_wchar(win, &ch)) { case KEY_CODE_YES: + fkey = TRUE; switch (ch) { case KEY_ENTER: ch = '\n'; + fkey = FALSE; break; case KEY_BACKSPACE: case KEY_DC: ch = '\b'; + fkey = FALSE; break; case KEY_LEFT: case KEY_RIGHT: break; default: - ch = (wint_t) - 1; + ch = (wint_t) -1; break; } + break; case OK: + fkey = FALSE; break; default: - ch = (wint_t) - 1; + ch = (wint_t) -1; + fkey = TRUE; break; } @@ -321,14 +373,14 @@ wGet_wstring(WINDOW *win, wchar_t * buffer, int limit) if (x > 0) { --x; } else { - flash(); + beep(); } break; case KEY_RIGHT: ++x; break; default: - if (!isprint(ch) || ch >= KEY_MIN) { + if (fkey) { beep(); } else if ((int) wcslen(buffer) < limit) { int j; @@ -337,7 +389,7 @@ wGet_wstring(WINDOW *win, wchar_t * buffer, int limit) } buffer[x++] = ch; } else { - flash(); + beep(); } } } @@ -378,44 +430,70 @@ ShellOut(bool message) } #ifdef NCURSES_MOUSE_VERSION +/* + * This function is the same as _tracemouse(), but we cannot count on that + * being available in the non-debug library. + */ static const char * mouse_decode(MEVENT const *ep) { - static char buf[80]; + static char buf[80 + (5 * 10) + (32 * 15)]; (void) sprintf(buf, "id %2d at (%2d, %2d, %2d) state %4lx = {", - ep->id, ep->x, ep->y, ep->z, ep->bstate); + ep->id, ep->x, ep->y, ep->z, (unsigned long) ep->bstate); #define SHOW(m, s) if ((ep->bstate & m)==m) {strcat(buf,s); strcat(buf, ", ");} + SHOW(BUTTON1_RELEASED, "release-1"); SHOW(BUTTON1_PRESSED, "press-1"); SHOW(BUTTON1_CLICKED, "click-1"); SHOW(BUTTON1_DOUBLE_CLICKED, "doubleclick-1"); SHOW(BUTTON1_TRIPLE_CLICKED, "tripleclick-1"); +#if NCURSES_MOUSE_VERSION == 1 SHOW(BUTTON1_RESERVED_EVENT, "reserved-1"); +#endif + SHOW(BUTTON2_RELEASED, "release-2"); SHOW(BUTTON2_PRESSED, "press-2"); SHOW(BUTTON2_CLICKED, "click-2"); SHOW(BUTTON2_DOUBLE_CLICKED, "doubleclick-2"); SHOW(BUTTON2_TRIPLE_CLICKED, "tripleclick-2"); +#if NCURSES_MOUSE_VERSION == 1 SHOW(BUTTON2_RESERVED_EVENT, "reserved-2"); +#endif + SHOW(BUTTON3_RELEASED, "release-3"); SHOW(BUTTON3_PRESSED, "press-3"); SHOW(BUTTON3_CLICKED, "click-3"); SHOW(BUTTON3_DOUBLE_CLICKED, "doubleclick-3"); SHOW(BUTTON3_TRIPLE_CLICKED, "tripleclick-3"); +#if NCURSES_MOUSE_VERSION == 1 SHOW(BUTTON3_RESERVED_EVENT, "reserved-3"); +#endif + SHOW(BUTTON4_RELEASED, "release-4"); SHOW(BUTTON4_PRESSED, "press-4"); SHOW(BUTTON4_CLICKED, "click-4"); SHOW(BUTTON4_DOUBLE_CLICKED, "doubleclick-4"); SHOW(BUTTON4_TRIPLE_CLICKED, "tripleclick-4"); +#if NCURSES_MOUSE_VERSION == 1 SHOW(BUTTON4_RESERVED_EVENT, "reserved-4"); +#endif + +#if NCURSES_MOUSE_VERSION == 2 + SHOW(BUTTON5_RELEASED, "release-5"); + SHOW(BUTTON5_PRESSED, "press-5"); + SHOW(BUTTON5_CLICKED, "click-5"); + SHOW(BUTTON5_DOUBLE_CLICKED, "doubleclick-5"); + SHOW(BUTTON5_TRIPLE_CLICKED, "tripleclick-5"); +#endif + SHOW(BUTTON_CTRL, "ctrl"); SHOW(BUTTON_SHIFT, "shift"); SHOW(BUTTON_ALT, "alt"); SHOW(ALL_MOUSE_EVENTS, "all-events"); SHOW(REPORT_MOUSE_POSITION, "position"); + #undef SHOW if (buf[strlen(buf) - 1] == ' ') @@ -447,15 +525,15 @@ wgetch_help(WINDOW *win, bool flags[]) { static const char *help[] = { - "e -- toggle echo mode" - ,"g -- triggers a getstr test" - ,"k -- toggle keypad/literal mode" - ,"m -- toggle meta (7-bit/8-bit) mode" - ,"q -- quit (x also exits)" - ,"s -- shell out\n" - ,"w -- create a new window" + "e -- toggle echo mode" + ,"g -- triggers a getstr test" + ,"k -- toggle keypad/literal mode" + ,"m -- toggle meta (7-bit/8-bit) mode" + ,"^q -- quit" + ,"s -- shell out\n" + ,"w -- create a new window" #ifdef SIGTSTP - ,"z -- suspend this process" + ,"z -- suspend this process" #endif }; int y, x; @@ -504,6 +582,16 @@ typedef struct { static WINSTACK *winstack = 0; static unsigned len_winstack = 0; +static void +forget_boxes(void) +{ + if (winstack != 0) { + free(winstack); + } + winstack = 0; + len_winstack = 0; +} + static void remember_boxes(unsigned level, WINDOW *txt_win, WINDOW *box_win) { @@ -520,12 +608,26 @@ remember_boxes(unsigned level, WINDOW *txt_win, WINDOW *box_win) winstack[level].frame = box_win; } +#if USE_SOFTKEYS && (NCURSES_VERSION_PATCH < 20071229) +static void +slk_repaint(void) +{ + /* this chunk is now done in resize_term() */ + slk_touch(); + slk_clear(); + slk_noutrefresh(); +} + +#else +#define slk_repaint() /* nothing */ +#endif + /* * For wgetch_test(), we create pairs of windows - one for a box, one for text. * Resize both and paint the box in the parent. */ static void -resize_boxes(int level, WINDOW *win) +resize_boxes(unsigned level, WINDOW *win) { unsigned n; int base = 5; @@ -535,12 +637,9 @@ resize_boxes(int level, WINDOW *win) touchwin(stdscr); wnoutrefresh(stdscr); - /* FIXME: this chunk should be done in resizeterm() */ - slk_touch(); - slk_clear(); - slk_noutrefresh(); + slk_repaint(); - for (n = 0; (int) n < level; ++n) { + for (n = 0; n < level; ++n) { wresize(winstack[n].frame, high, wide); wresize(winstack[n].text, high - 2, wide - 2); high -= 2; @@ -559,11 +658,12 @@ resize_boxes(int level, WINDOW *win) doupdate(); } #else +#define forget_boxes() /* nothing */ #define remember_boxes(level,text,frame) /* nothing */ #endif static void -wgetch_test(int level, WINDOW *win, int delay) +wgetch_test(unsigned level, WINDOW *win, int delay) { char buf[BUFSIZ]; int first_y, first_x; @@ -571,7 +671,6 @@ wgetch_test(int level, WINDOW *win, int delay) int incount = 0; bool flags[256]; bool blocking = (delay < 0); - int y, x; memset(flags, FALSE, sizeof(flags)); flags[UChar('k')] = (win == stdscr); @@ -598,7 +697,7 @@ wgetch_test(int level, WINDOW *win, int delay) if (c == ERR && blocking) { wprintw(win, "ERR"); wgetch_wrap(win, first_y); - } else if (c == 'x' || c == 'q') { + } else if (isQuit(c)) { break; } else if (c == 'e') { flags[UChar('e')] = !flags[UChar('e')]; @@ -656,6 +755,7 @@ wgetch_test(int level, WINDOW *win, int delay) wprintw(win, "Key pressed: %04o ", c); #ifdef NCURSES_MOUSE_VERSION if (c == KEY_MOUSE) { + int y, x; MEVENT event; getmouse(&event); @@ -674,9 +774,9 @@ wgetch_test(int level, WINDOW *win, int delay) #endif (void) waddstr(win, keyname(c)); } else if (c > 0x80) { - int c2 = (c & 0x7f); + unsigned c2 = (c & 0x7f); if (isprint(c2)) - (void) wprintw(win, "M-%c", c2); + (void) wprintw(win, "M-%c", UChar(c2)); else (void) wprintw(win, "M-%s", unctrl(c2)); waddstr(win, " (high-half character)"); @@ -685,7 +785,7 @@ wgetch_test(int level, WINDOW *win, int delay) (void) wprintw(win, "%c (ASCII printable character)", c); else (void) wprintw(win, "%s (ASCII control character)", - unctrl(c)); + unctrl(UChar(c))); } wgetch_wrap(win, first_y); } @@ -738,18 +838,21 @@ static void getch_test(void) { int delay = begin_getch_test(); + + slk_restore(); wgetch_test(0, stdscr, delay); + forget_boxes(); finish_getch_test(); } #if USE_WIDEC_SUPPORT /* - * For wgetch_test(), we create pairs of windows - one for a box, one for text. + * For wget_wch_test(), we create pairs of windows - one for a box, one for text. * Resize both and paint the box in the parent. */ #ifdef KEY_RESIZE static void -resize_wide_boxes(int level, WINDOW *win) +resize_wide_boxes(unsigned level, WINDOW *win) { unsigned n; int base = 5; @@ -759,12 +862,9 @@ resize_wide_boxes(int level, WINDOW *win) touchwin(stdscr); wnoutrefresh(stdscr); - /* FIXME: this chunk should be done in resizeterm() */ - slk_touch(); - slk_clear(); - slk_noutrefresh(); + slk_repaint(); - for (n = 0; (int) n < level; ++n) { + for (n = 0; n < level; ++n) { wresize(winstack[n].frame, high, wide); wresize(winstack[n].text, high - 2, wide - 2); high -= 2; @@ -785,7 +885,7 @@ resize_wide_boxes(int level, WINDOW *win) #endif /* KEY_RESIZE */ static char * -wcstos(const wchar_t * src) +wcstos(const wchar_t *src) { int need; mbstate_t state; @@ -794,9 +894,10 @@ wcstos(const wchar_t * src) memset(&state, 0, sizeof(state)); if ((need = wcsrtombs(0, &tmp, 0, &state)) > 0) { - result = (char *) calloc(need + 1, 1); + unsigned have = need; + result = (char *) calloc(have + 1, 1); tmp = src; - if (wcsrtombs(result, &tmp, need, &state) != (size_t) need) { + if (wcsrtombs(result, &tmp, have, &state) != have) { free(result); result = 0; } @@ -805,9 +906,10 @@ wcstos(const wchar_t * src) } static void -wget_wch_test(int level, WINDOW *win, int delay) +wget_wch_test(unsigned level, WINDOW *win, int delay) { - wchar_t buf[BUFSIZ]; + wchar_t wchar_buf[BUFSIZ]; + wint_t wint_buf[BUFSIZ]; int first_y, first_x; wint_t c; int incount = 0; @@ -841,7 +943,7 @@ wget_wch_test(int level, WINDOW *win, int delay) if (code == ERR && blocking) { wprintw(win, "ERR"); wgetch_wrap(win, first_y); - } else if (c == 'x' || c == 'q') { + } else if (isQuit((int) c)) { break; } else if (c == 'e') { flags[UChar('e')] = !flags[UChar('e')]; @@ -850,13 +952,21 @@ wget_wch_test(int level, WINDOW *win, int delay) } else if (c == 'g') { waddstr(win, "getstr test: "); echo(); - wgetn_wstr(win, (wint_t *) buf, sizeof(buf) - 1); + code = wgetn_wstr(win, wint_buf, sizeof(wint_buf) - 1); noecho(); - if ((temp = wcstos(buf)) != 0) { - wprintw(win, "I saw %d characters:\n\t`%s'.", wcslen(buf), temp); - free(temp); + if (code == ERR) { + wprintw(win, "wgetn_wstr returns an error."); } else { - wprintw(win, "I saw %d characters (cannot convert).", wcslen(buf)); + int n; + for (n = 0; (wchar_buf[n] = wint_buf[n]) != 0; ++n) ; + if ((temp = wcstos(wchar_buf)) != 0) { + wprintw(win, "I saw %d characters:\n\t`%s'.", + (int) wcslen(wchar_buf), temp); + free(temp); + } else { + wprintw(win, "I saw %d characters (cannot convert).", + (int) wcslen(wchar_buf)); + } } wclrtoeol(win); wgetch_wrap(win, first_y); @@ -919,7 +1029,7 @@ wget_wch_test(int level, WINDOW *win, int delay) resize_wide_boxes(level, win); } #endif - (void) waddstr(win, key_name(c)); + (void) waddstr(win, key_name((wchar_t) c)); } else { if (c < 256 && iscntrl(c)) { (void) wprintw(win, "%s (control character)", unctrl(c)); @@ -940,7 +1050,10 @@ static void get_wch_test(void) { int delay = begin_getch_test(); + + slk_restore(); wget_wch_test(0, stdscr, delay); + forget_boxes(); finish_getch_test(); } #endif @@ -951,10 +1064,148 @@ get_wch_test(void) * ****************************************************************************/ +#if HAVE_SETUPTERM || HAVE_TGETENT +#define get_ncv() TIGETNUM("ncv","NC") +#define get_xmc() TIGETNUM("xmc","sg") +#else +#define get_ncv() -1 +#define get_xmc() -1 +#endif + +#if !HAVE_TERMATTRS +static chtype +my_termattrs(void) +{ + static int first = TRUE; + static chtype result = 0; + + if (first) { +#if !HAVE_TIGETSTR + char buffer[4096]; + char parsed[4096]; + char *area_pointer = parsed; + + tgetent(buffer, getenv("TERM")); +#endif + + if (TIGETSTR("smso", "so")) + result |= A_STANDOUT; + if (TIGETSTR("smul", "us")) + result |= A_UNDERLINE; + if (TIGETSTR("rev", "mr")) + result |= A_REVERSE; + if (TIGETSTR("blink", "mb")) + result |= A_BLINK; + if (TIGETSTR("dim", "mh")) + result |= A_DIM; + if (TIGETSTR("bold", "md")) + result |= A_BOLD; + if (TIGETSTR("smacs", "ac")) + result |= A_ALTCHARSET; + + first = FALSE; + } + return result; +} +#define termattrs() my_termattrs() +#endif + #define MAX_ATTRSTRING 31 #define LEN_ATTRSTRING 26 -static char attr_test_string[] = "abcde fghij klmno pqrst uvwxy z"; +static char attr_test_string[MAX_ATTRSTRING + 1]; + +static void +attr_legend(WINDOW *helpwin) +{ + int row = 1; + int col = 1; + + mvwprintw(helpwin, row++, col, + "ESC to exit."); + mvwprintw(helpwin, row++, col, + "^L repaints."); + ++row; + mvwprintw(helpwin, row++, col, + "Modify the test strings:"); + mvwprintw(helpwin, row++, col, + " A digit sets gaps on each side of displayed attributes"); + mvwprintw(helpwin, row++, col, + " shifts the text left/right. "); + ++row; + mvwprintw(helpwin, row++, col, + "Toggles:"); + if (use_colors) { + mvwprintw(helpwin, row++, col, + " f/F/b/F toggle foreground/background background color"); + mvwprintw(helpwin, row++, col, + " t/T toggle text/background color attribute"); + } + mvwprintw(helpwin, row++, col, + " a/A toggle ACS (alternate character set) mapping"); + mvwprintw(helpwin, row++, col, + " v/V toggle video attribute to combine with each line"); +} + +static void +show_color_attr(int fg, int bg, int tx) +{ + if (use_colors) { + printw(" Colors (fg %d, bg %d", fg, bg); + if (tx >= 0) + printw(", text %d", tx); + printw("),"); + } +} + +static bool +cycle_color_attr(int ch, short *fg, short *bg, short *tx) +{ + bool error = FALSE; + + if (use_colors) { + switch (ch) { + case 'f': + *fg = (*fg + 1); + break; + case 'F': + *fg = (*fg - 1); + break; + case 'b': + *bg = (*bg + 1); + break; + case 'B': + *bg = (*bg - 1); + break; + case 't': + *tx = (*tx + 1); + break; + case 'T': + *tx = (*tx - 1); + break; + default: + beep(); + error = TRUE; + break; + } + if (*fg >= COLORS) + *fg = min_colors; + if (*fg < min_colors) + *fg = COLORS - 1; + if (*bg >= COLORS) + *bg = min_colors; + if (*bg < min_colors) + *bg = COLORS - 1; + if (*tx >= COLORS) + *tx = -1; + if (*tx < -1) + *tx = COLORS - 1; + } else { + beep(); + error = TRUE; + } + return error; +} static void adjust_attr_string(int adjust) @@ -964,7 +1215,7 @@ adjust_attr_string(int adjust) if (first >= ' ' && last <= '~') { /* 32..126 */ int j, k; - for (j = 0, k = first; k <= last; ++j, ++k) { + for (j = 0, k = first; j < MAX_ATTRSTRING && k <= last; ++j, ++k) { attr_test_string[j] = k; if (((k + 1 - first) % 5) == 0) { ++j; @@ -980,132 +1231,161 @@ adjust_attr_string(int adjust) } } +static void +init_attr_string(void) +{ + attr_test_string[0] = 'a'; + adjust_attr_string(0); +} + static int -show_attr(int row, int skip, chtype attr, const char *name) +show_attr(int row, int skip, bool arrow, chtype attr, const char *name) { - int ncv = tigetnum("ncv"); - chtype test = attr & ~A_ALTCHARSET; + int ncv = get_ncv(); + chtype test = attr & (chtype) (~A_ALTCHARSET); + if (arrow) + mvprintw(row, 5, "-->"); mvprintw(row, 8, "%s mode:", name); mvprintw(row, 24, "|"); if (skip) printw("%*s", skip, " "); - attrset(attr); /* - * If we're to write a string in the alternate character set, it is not - * sufficient to just set A_ALTCHARSET. We have to perform the mapping - * that corresponds. This is not needed for vt100-compatible devices - * because the acs_map[] is 1:1, but for PC-style devices such as Linux - * console, the acs_map[] is scattered about the range. - * - * The addch/addstr functions do not themselves do this mapping, since it - * is possible to turn off the A_ALTCHARSET flag for the characters which - * are added, and it would be an unexpected result to have the mapped - * characters visible on the screen. + * Just for testing, write text using the alternate character set one + * character at a time (to pass its rendition directly), and use the + * string operation for the other attributes. */ if (attr & A_ALTCHARSET) { const char *s; - int ch; + chtype ch; for (s = attr_test_string; *s != '\0'; ++s) { ch = UChar(*s); - addch(ch); + addch(ch | attr); } } else { + attrset(attr); addstr(attr_test_string); + attroff(attr); } - attroff(attr); if (skip) printw("%*s", skip, " "); printw("|"); if (test != A_NORMAL) { if (!(termattrs() & test)) { printw(" (N/A)"); - } else if (ncv > 0 && (getbkgd(stdscr) & A_COLOR)) { - static const chtype table[] = - { - A_STANDOUT, - A_UNDERLINE, - A_REVERSE, - A_BLINK, - A_DIM, - A_BOLD, - A_INVIS, - A_PROTECT, - A_ALTCHARSET - }; - unsigned n; - bool found = FALSE; - for (n = 0; n < SIZEOF(table); n++) { - if ((table[n] & attr) != 0 - && ((1 << n) & ncv) != 0) { - found = TRUE; - break; + } else { + if (ncv > 0 && (getbkgd(stdscr) & A_COLOR)) { + static const chtype table[] = + { + A_STANDOUT, + A_UNDERLINE, + A_REVERSE, + A_BLINK, + A_DIM, + A_BOLD, +#ifdef A_INVIS + A_INVIS, +#endif + A_PROTECT, + A_ALTCHARSET + }; + unsigned n; + bool found = FALSE; + for (n = 0; n < SIZEOF(table); n++) { + if ((table[n] & attr) != 0 + && ((1 << n) & ncv) != 0) { + found = TRUE; + break; + } } + if (found) + printw(" (NCV)"); } - if (found) - printw(" (NCV)"); + if ((termattrs() & test) != test) + printw(" (Part)"); } } return row + 2; } +/* *INDENT-OFF* */ +static const struct { + attr_t attr; + NCURSES_CONST char * name; +} attrs_to_test[] = { + { A_STANDOUT, "STANDOUT" }, + { A_REVERSE, "REVERSE" }, + { A_BOLD, "BOLD" }, + { A_UNDERLINE, "UNDERLINE" }, + { A_DIM, "DIM" }, + { A_BLINK, "BLINK" }, + { A_PROTECT, "PROTECT" }, +#ifdef A_INVIS + { A_INVIS, "INVISIBLE" }, +#endif + { A_NORMAL, "NORMAL" }, +}; +/* *INDENT-ON* */ static bool -attr_getc(int *skip, int *fg, int *bg, int *ac) +attr_getc(int *skip, short *fg, short *bg, short *tx, int *ac, unsigned *kc) { - int ch = Getchar(); + bool result = TRUE; + bool error = FALSE; + WINDOW *helpwin; - if (isdigit(ch)) { - *skip = (ch - '0'); - } else if (ch == CTRL('L')) { - touchwin(stdscr); - touchwin(curscr); - wrefresh(curscr); - } else { - switch (ch) { - case 'a': - *ac = 0; - break; - case 'A': - *ac = A_ALTCHARSET; - break; - case '<': - adjust_attr_string(-1); - break; - case '>': - adjust_attr_string(1); - break; - default: - if (has_colors()) { - switch (ch) { - case 'f': - *fg = (*fg + 1); - break; - case 'F': - *fg = (*fg - 1); - break; - case 'b': - *bg = (*bg + 1); - break; - case 'B': - *bg = (*bg - 1); - break; - default: - return FALSE; + do { + int ch = Getchar(); + + error = FALSE; + if (ch < 256 && isdigit(ch)) { + *skip = (ch - '0'); + } else { + switch (ch) { + case CTRL('L'): + Repaint(); + break; + case '?': + if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) { + box(helpwin, 0, 0); + attr_legend(helpwin); + wGetchar(helpwin); + delwin(helpwin); } - if (*fg >= max_colors) - *fg = 0; - if (*fg < 0) - *fg = max_colors - 1; - if (*bg >= max_colors) - *bg = 0; - if (*bg < 0) - *bg = max_colors - 1; + break; + case 'a': + *ac = 0; + break; + case 'A': + *ac = A_ALTCHARSET; + break; + case 'v': + if (*kc == 0) + *kc = SIZEOF(attrs_to_test) - 1; + else + *kc -= 1; + break; + case 'V': + *kc += 1; + if (*kc >= SIZEOF(attrs_to_test)) + *kc = 0; + break; + case '<': + adjust_attr_string(-1); + break; + case '>': + adjust_attr_string(1); + break; + case_QUIT: + result = FALSE; + break; + default: + error = cycle_color_attr(ch, fg, bg, tx); + break; } - break; } - } - return TRUE; + } while (error); + return result; } static void @@ -1113,29 +1393,43 @@ attr_test(void) /* test text attributes */ { int n; - int skip = tigetnum("xmc"); - int fg = COLOR_BLACK; /* color pair 0 is special */ - int bg = COLOR_BLACK; + int skip = get_xmc(); + short fg = COLOR_BLACK; /* color pair 0 is special */ + short bg = COLOR_BLACK; + short tx = -1; int ac = 0; - bool *pairs = (bool *) calloc(max_pairs, sizeof(bool)); - pairs[0] = TRUE; + unsigned j, k; if (skip < 0) skip = 0; n = skip; /* make it easy */ + k = SIZEOF(attrs_to_test) - 1; + init_attr_string(); do { int row = 2; - int normal = A_NORMAL | BLANK; - - if (has_colors()) { - int pair = (fg * max_colors) + bg; - if (!pairs[pair]) { - init_pair(pair, fg, bg); - pairs[pair] = TRUE; + chtype normal = A_NORMAL | BLANK; + chtype extras = ac; + + if (use_colors) { + short pair = (fg != COLOR_BLACK || bg != COLOR_BLACK); + if (pair != 0) { + pair = 1; + if (init_pair(pair, fg, bg) == ERR) { + beep(); + } else { + normal |= COLOR_PAIR(pair); + } + } + if (tx >= 0) { + pair = 2; + if (init_pair(pair, tx, bg) == ERR) { + beep(); + } else { + extras |= COLOR_PAIR(pair); + } } - normal |= COLOR_PAIR(pair); } bkgd(normal); bkgdset(normal); @@ -1144,148 +1438,752 @@ attr_test(void) box(stdscr, 0, 0); mvaddstr(0, 20, "Character attribute test display"); - row = show_attr(row, n, ac | A_STANDOUT, "STANDOUT"); - row = show_attr(row, n, ac | A_REVERSE, "REVERSE"); - row = show_attr(row, n, ac | A_BOLD, "BOLD"); - row = show_attr(row, n, ac | A_UNDERLINE, "UNDERLINE"); - row = show_attr(row, n, ac | A_DIM, "DIM"); - row = show_attr(row, n, ac | A_BLINK, "BLINK"); - row = show_attr(row, n, ac | A_PROTECT, "PROTECT"); - row = show_attr(row, n, ac | A_INVIS, "INVISIBLE"); - row = show_attr(row, n, ac | A_NORMAL, "NORMAL"); + for (j = 0; j < SIZEOF(attrs_to_test); ++j) { + bool arrow = (j == k); + row = show_attr(row, n, arrow, + extras | + attrs_to_test[j].attr | + attrs_to_test[k].attr, + attrs_to_test[j].name); + } mvprintw(row, 8, "This terminal does %shave the magic-cookie glitch", - tigetnum("xmc") > -1 ? "" : "not "); - mvprintw(row + 1, 8, - "Enter a digit to set gaps on each side of displayed attributes"); - mvprintw(row + 2, 8, - "^L repaints, shifts, "); - if (has_colors()) - printw("f/F/b/F toggle color (now %d/%d), a/A ACS (%d)", - fg, bg, ac != 0); - else - printw("a/A ACS (%d)", ac != 0); + get_xmc() > -1 ? "" : "not "); + mvprintw(row + 1, 8, "Enter '?' for help."); + show_color_attr(fg, bg, tx); + printw(" ACS (%d)", ac != 0); refresh(); - } while (attr_getc(&n, &fg, &bg, &ac)); + } while (attr_getc(&n, &fg, &bg, &tx, &ac, &k)); - free((char *) pairs); bkgdset(A_NORMAL | BLANK); erase(); endwin(); } -/**************************************************************************** - * - * Color support tests - * - ****************************************************************************/ +#if USE_WIDEC_SUPPORT +static wchar_t wide_attr_test_string[MAX_ATTRSTRING + 1]; -static NCURSES_CONST char *the_color_names[] = +static void +wide_adjust_attr_string(int adjust) { - "black", - "red", - "green", - "yellow", - "blue", - "magenta", - "cyan", - "white", - "BLACK", - "RED", - "GREEN", - "YELLOW", - "BLUE", - "MAGENTA", - "CYAN", - "WHITE" -}; + int first = ((int) UChar(wide_attr_test_string[0])) + adjust; + int last = first + LEN_ATTRSTRING; + + if (first >= ' ' && last <= '~') { /* 32..126 */ + int j, k; + for (j = 0, k = first; j < MAX_ATTRSTRING && k <= last; ++j, ++k) { + wide_attr_test_string[j] = k; + if (((k + 1 - first) % 5) == 0) { + ++j; + if (j < MAX_ATTRSTRING) + wide_attr_test_string[j] = ' '; + } + } + while (j < MAX_ATTRSTRING) + wide_attr_test_string[j++] = ' '; + wide_attr_test_string[j] = '\0'; + } else { + beep(); + } +} static void -show_color_name(int y, int x, int color) +wide_init_attr_string(void) { - if (max_colors > 8) - mvprintw(y, x, "%02d ", color); - else - mvaddstr(y, x, the_color_names[color]); + wide_attr_test_string[0] = 'a'; + wide_adjust_attr_string(0); } static void -color_test(void) -/* generate a color test pattern */ +set_wide_background(short pair) { - int i; - int base, top, width; - const char *hello; - - refresh(); - (void) printw("There are %d color pairs\n", COLOR_PAIRS); - - width = (max_colors > 8) ? 4 : 8; - hello = (max_colors > 8) ? "Test" : "Hello"; + cchar_t normal; + wchar_t blank[2]; + + blank[0] = ' '; + blank[1] = 0; + setcchar(&normal, blank, A_NORMAL, pair, 0); + bkgrnd(&normal); + bkgrndset(&normal); +} - for (base = 0; base < 2; base++) { - top = (max_colors > 8) ? 0 : base * (max_colors + 3); - clrtobot(); - (void) mvprintw(top + 1, 0, - "%dx%d matrix of foreground/background colors, bright *%s*\n", - max_colors, max_colors, - base ? "on" : "off"); - for (i = 0; i < max_colors; i++) - show_color_name(top + 2, (i + 1) * width, i); - for (i = 0; i < max_colors; i++) - show_color_name(top + 3 + i, 0, i); - for (i = 1; i < max_pairs; i++) { - init_pair(i, i % max_colors, i / max_colors); - attron((attr_t) COLOR_PAIR(i)); - if (base) - attron((attr_t) A_BOLD); - mvaddstr(top + 3 + (i / max_colors), (i % max_colors + 1) * - width, hello); - attrset(A_NORMAL); +static attr_t +get_wide_background(void) +{ + attr_t result = A_NORMAL; + attr_t attr; + cchar_t ch; + short pair; + wchar_t wch[10]; + + if (getbkgrnd(&ch) != ERR) { + if (getcchar(&ch, wch, &attr, &pair, 0) != ERR) { + result = attr; } - if ((max_colors > 8) || base) - Pause(); } - - erase(); - endwin(); + return result; } -static void -change_color(int current, int field, int value, int usebase) +static int +wide_show_attr(int row, int skip, bool arrow, chtype attr, short pair, const char *name) { - short red, green, blue; + int ncv = get_ncv(); + chtype test = attr & ~WA_ALTCHARSET; - if (usebase) - color_content(current, &red, &green, &blue); - else - red = green = blue = 0; + if (arrow) + mvprintw(row, 5, "-->"); + mvprintw(row, 8, "%s mode:", name); + mvprintw(row, 24, "|"); + if (skip) + printw("%*s", skip, " "); - switch (field) { - case 0: - red += value; - break; - case 1: - green += value; - break; - case 2: - blue += value; - break; - } + /* + * Just for testing, write text using the alternate character set one + * character at a time (to pass its rendition directly), and use the + * string operation for the other attributes. + */ + if (attr & WA_ALTCHARSET) { + const wchar_t *s; + cchar_t ch; + + for (s = wide_attr_test_string; *s != L'\0'; ++s) { + wchar_t fill[2]; + fill[0] = *s; + fill[1] = L'\0'; + setcchar(&ch, fill, attr, pair, 0); + add_wch(&ch); + } + } else { + attr_t old_attr; + short old_pair; + + attr_get(&old_attr, &old_pair, 0); + attr_set(attr, pair, 0); + addwstr(wide_attr_test_string); + attr_set(old_attr, old_pair, 0); + } + if (skip) + printw("%*s", skip, " "); + printw("|"); + if (test != A_NORMAL) { + if (!(term_attrs() & test)) { + printw(" (N/A)"); + } else { + if (ncv > 0 && (get_wide_background() & A_COLOR)) { + static const attr_t table[] = + { + WA_STANDOUT, + WA_UNDERLINE, + WA_REVERSE, + WA_BLINK, + WA_DIM, + WA_BOLD, + WA_INVIS, + WA_PROTECT, + WA_ALTCHARSET + }; + unsigned n; + bool found = FALSE; + for (n = 0; n < SIZEOF(table); n++) { + if ((table[n] & attr) != 0 + && ((1 << n) & ncv) != 0) { + found = TRUE; + break; + } + } + if (found) + printw(" (NCV)"); + } + if ((term_attrs() & test) != test) + printw(" (Part)"); + } + } + return row + 2; +} + +static bool +wide_attr_getc(int *skip, short *fg, short *bg, short *tx, int *ac, unsigned *kc) +{ + bool result = TRUE; + bool error = FALSE; + WINDOW *helpwin; + + do { + int ch = Getchar(); + + error = FALSE; + if (ch < 256 && isdigit(ch)) { + *skip = (ch - '0'); + } else { + switch (ch) { + case CTRL('L'): + Repaint(); + break; + case '?': + if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) { + box_set(helpwin, 0, 0); + attr_legend(helpwin); + wGetchar(helpwin); + delwin(helpwin); + } + break; + case 'a': + *ac = 0; + break; + case 'A': + *ac = A_ALTCHARSET; + break; + case 'v': + if (*kc == 0) + *kc = SIZEOF(attrs_to_test) - 1; + else + *kc -= 1; + break; + case 'V': + *kc += 1; + if (*kc >= SIZEOF(attrs_to_test)) + *kc = 0; + break; + case '<': + wide_adjust_attr_string(-1); + break; + case '>': + wide_adjust_attr_string(1); + break; + case_QUIT: + result = FALSE; + break; + default: + error = cycle_color_attr(ch, fg, bg, tx); + break; + } + } + } while (error); + return result; +} + +static void +wide_attr_test(void) +/* test text attributes using wide-character calls */ +{ + int n; + int skip = get_xmc(); + short fg = COLOR_BLACK; /* color pair 0 is special */ + short bg = COLOR_BLACK; + short tx = -1; + int ac = 0; + unsigned j, k; + + if (skip < 0) + skip = 0; + + n = skip; /* make it easy */ + k = SIZEOF(attrs_to_test) - 1; + wide_init_attr_string(); + + do { + int row = 2; + short pair = 0; + short extras = 0; + + if (use_colors) { + pair = (fg != COLOR_BLACK || bg != COLOR_BLACK); + if (pair != 0) { + pair = 1; + if (init_pair(pair, fg, bg) == ERR) { + beep(); + } + } + extras = pair; + if (tx >= 0) { + extras = 2; + if (init_pair(extras, tx, bg) == ERR) { + beep(); + } + } + } + set_wide_background(pair); + erase(); + + box_set(stdscr, 0, 0); + mvaddstr(0, 20, "Character attribute test display"); + + for (j = 0; j < SIZEOF(attrs_to_test); ++j) { + row = wide_show_attr(row, n, j == k, + ac | + attrs_to_test[j].attr | + attrs_to_test[k].attr, + extras, + attrs_to_test[j].name); + } + + mvprintw(row, 8, + "This terminal does %shave the magic-cookie glitch", + get_xmc() > -1 ? "" : "not "); + mvprintw(row + 1, 8, "Enter '?' for help."); + show_color_attr(fg, bg, tx); + printw(" ACS (%d)", ac != 0); + + refresh(); + } while (wide_attr_getc(&n, &fg, &bg, &tx, &ac, &k)); + + set_wide_background(0); + erase(); + endwin(); +} +#endif + +/**************************************************************************** + * + * Color support tests + * + ****************************************************************************/ + +static NCURSES_CONST char *the_color_names[] = +{ + "black", + "red", + "green", + "yellow", + "blue", + "magenta", + "cyan", + "white", + "BLACK", + "RED", + "GREEN", + "YELLOW", + "BLUE", + "MAGENTA", + "CYAN", + "WHITE" +}; + +static void +show_color_name(int y, int x, int color, bool wide) +{ + if (move(y, x) != ERR) { + char temp[80]; + int width = 8; + + if (wide) { + sprintf(temp, "%02d", color); + width = 4; + } else if (color >= 8) { + sprintf(temp, "[%02d]", color); + } else { + strcpy(temp, the_color_names[color]); + } + printw("%-*.*s", width, width, temp); + } +} + +static void +color_legend(WINDOW *helpwin) +{ + int row = 1; + int col = 1; + + mvwprintw(helpwin, row++, col, + "ESC to exit."); + ++row; + mvwprintw(helpwin, row++, col, + "Use up/down arrow to scroll through the display if it is"); + mvwprintw(helpwin, row++, col, + "longer than one screen. Control/N and Control/P can be used"); + mvwprintw(helpwin, row++, col, + "in place up up/down arrow. Use pageup/pagedown to scroll a"); + mvwprintw(helpwin, row++, col, + "full screen; control/B and control/F can be used here."); + ++row; + mvwprintw(helpwin, row++, col, + "Toggles:"); + mvwprintw(helpwin, row++, col, + " b/B toggle bold off/on"); + mvwprintw(helpwin, row++, col, + " n/N toggle text/number on/off"); + mvwprintw(helpwin, row++, col, + " w/W toggle width between 8/16 colors"); +} + +#define set_color_test(name, value) if (name != value) { name = value; base_row = 0; } + +/* generate a color test pattern */ +static void +color_test(void) +{ + short i; + int top = 0, width; + int base_row = 0; + int grid_top = top + 3; + int page_size = (LINES - grid_top); + int pairs_max = PAIR_NUMBER(A_COLOR) + 1; + int row_limit; + int per_row; + char numbered[80]; + const char *hello; + bool done = FALSE; + bool opt_bold = FALSE; + bool opt_wide = FALSE; + bool opt_nums = FALSE; + WINDOW *helpwin; + + if (pairs_max > COLOR_PAIRS) + pairs_max = COLOR_PAIRS; + + while (!done) { + int shown = 0; + + /* this assumes an 80-column line */ + if (opt_wide) { + width = 4; + hello = "Test"; + per_row = (COLORS > 8) ? 16 : 8; + } else { + width = 8; + hello = "Hello"; + per_row = 8; + } + + row_limit = (pairs_max + per_row - 1) / per_row; + + move(0, 0); + (void) printw("There are %d color pairs and %d colors\n", + pairs_max, COLORS); + + clrtobot(); + (void) mvprintw(top + 1, 0, + "%dx%d matrix of foreground/background colors, bold *%s*\n", + row_limit, + per_row, + 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, opt_wide); + + /* 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; + short pair = i; + + if (row >= 0 && move(row, col) != ERR) { + short fg = i % COLORS; + short bg = i / COLORS; + + init_pair(pair, fg, bg); + attron((attr_t) COLOR_PAIR(pair)); + if (opt_bold) + attron((attr_t) A_BOLD); + + if (opt_nums) { + sprintf(numbered, "{%02X}", i); + hello = numbered; + } + printw("%-*.*s", width, width, hello); + attrset(A_NORMAL); + + if ((i % per_row) == 0 && (i % COLORS) == 0) { + show_color_name(row, 0, i / COLORS, opt_wide); + } + ++shown; + } else if (shown) { + break; + } + } + + switch (wGetchar(stdscr)) { + case 'b': + opt_bold = FALSE; + break; + case 'B': + opt_bold = TRUE; + break; + case 'n': + opt_nums = FALSE; + break; + case 'N': + opt_nums = TRUE; + break; + case_QUIT: + done = TRUE; + continue; + case 'w': + set_color_test(opt_wide, FALSE); + break; + case 'W': + set_color_test(opt_wide, TRUE); + break; + case CTRL('p'): + case KEY_UP: + if (base_row <= 0) { + beep(); + } else { + base_row -= 1; + } + break; + case CTRL('n'): + case KEY_DOWN: + if (base_row + page_size >= row_limit) { + beep(); + } else { + base_row += 1; + } + break; + case CTRL('b'): + case KEY_PREVIOUS: + case KEY_PPAGE: + if (base_row <= 0) { + beep(); + } else { + base_row -= (page_size - 1); + if (base_row < 0) + base_row = 0; + } + break; + case CTRL('f'): + case KEY_NEXT: + case KEY_NPAGE: + if (base_row + page_size >= row_limit) { + beep(); + } else { + base_row += page_size - 1; + if (base_row + page_size >= row_limit) { + base_row = row_limit - page_size - 1; + } + } + break; + case '?': + if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) { + box(helpwin, 0, 0); + color_legend(helpwin); + wGetchar(helpwin); + delwin(helpwin); + } + break; + default: + beep(); + continue; + } + } + + erase(); + endwin(); +} + +#if USE_WIDEC_SUPPORT +/* generate a color test pattern */ +static void +wide_color_test(void) +{ + int c; + int i; + int top = 0, width; + int base_row = 0; + int grid_top = top + 3; + int page_size = (LINES - grid_top); + int pairs_max = COLOR_PAIRS; + int row_limit; + int per_row; + char numbered[80]; + const char *hello; + bool done = FALSE; + bool opt_bold = FALSE; + bool opt_wide = FALSE; + bool opt_nums = FALSE; + WINDOW *helpwin; + + while (!done) { + int shown = 0; + + /* this assumes an 80-column line */ + if (opt_wide) { + width = 4; + hello = "Test"; + per_row = (COLORS > 8) ? 16 : 8; + } else { + width = 8; + hello = "Hello"; + per_row = 8; + } + + row_limit = (pairs_max + per_row - 1) / per_row; + + move(0, 0); + (void) printw("There are %d color pairs and %d colors\n", + pairs_max, COLORS); + + clrtobot(); + (void) mvprintw(top + 1, 0, + "%dx%d matrix of foreground/background colors, bold *%s*\n", + row_limit, + per_row, + 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, opt_wide); + + /* 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; + int pair = i; + + if (row >= 0 && move(row, col) != ERR) { + init_pair(pair, i % COLORS, i / COLORS); + color_set(pair, NULL); + if (opt_bold) + attr_on((attr_t) A_BOLD, NULL); + + if (opt_nums) { + sprintf(numbered, "{%02X}", i); + hello = numbered; + } + printw("%-*.*s", width, width, hello); + attr_set(A_NORMAL, 0, NULL); + + if ((i % per_row) == 0 && (i % COLORS) == 0) { + show_color_name(row, 0, i / COLORS, opt_wide); + } + ++shown; + } else if (shown) { + break; + } + } + + switch (c = wGetchar(stdscr)) { + case 'b': + opt_bold = FALSE; + break; + case 'B': + opt_bold = TRUE; + break; + case 'n': + opt_nums = FALSE; + break; + case 'N': + opt_nums = TRUE; + break; + case_QUIT: + done = TRUE; + continue; + case 'w': + set_color_test(opt_wide, FALSE); + break; + case 'W': + set_color_test(opt_wide, TRUE); + break; + case CTRL('p'): + case KEY_UP: + if (base_row <= 0) { + beep(); + } else { + base_row -= 1; + } + break; + case CTRL('n'): + case KEY_DOWN: + if (base_row + page_size >= row_limit) { + beep(); + } else { + base_row += 1; + } + break; + case CTRL('b'): + case KEY_PREVIOUS: + case KEY_PPAGE: + if (base_row <= 0) { + beep(); + } else { + base_row -= (page_size - 1); + if (base_row < 0) + base_row = 0; + } + break; + case CTRL('f'): + case KEY_NEXT: + case KEY_NPAGE: + if (base_row + page_size >= row_limit) { + beep(); + } else { + base_row += page_size - 1; + if (base_row + page_size >= row_limit) { + base_row = row_limit - page_size - 1; + } + } + break; + case '?': + if ((helpwin = newwin(LINES - 1, COLS - 2, 0, 0)) != 0) { + box(helpwin, 0, 0); + color_legend(helpwin); + wGetchar(helpwin); + delwin(helpwin); + } + break; + default: + beep(); + continue; + } + } + + erase(); + endwin(); +} +#endif /* USE_WIDEC_SUPPORT */ + +static void +change_color(short current, int field, int value, int usebase) +{ + short red, green, blue; + + color_content(current, &red, &green, &blue); + + switch (field) { + case 0: + red = usebase ? red + value : value; + break; + case 1: + green = usebase ? green + value : value; + break; + case 2: + blue = usebase ? blue + value : value; + break; + } if (init_color(current, red, green, blue) == ERR) beep(); } +static void +init_all_colors(void) +{ + short c; + + for (c = 0; c < COLORS; ++c) + init_color(c, + all_colors[c].red, + all_colors[c].green, + all_colors[c].blue); +} + +#define scaled_rgb(n) ((255 * (n)) / 1000) + static void color_edit(void) /* display the color test pattern, without trying to edit colors */ { - int i, this_c = 0, value = 0, current = 0, field = 0; + short i; + short current = 0; + int this_c = 0, value = 0, field = 0; int last_c; + int top_color = 0; + int page_size = (LINES - 6); + init_all_colors(); refresh(); for (i = 0; i < max_colors; i++) @@ -1300,23 +2198,20 @@ color_edit(void) mvaddstr(0, 20, "Color RGB Value Editing"); attroff(A_BOLD); - for (i = 0; i < max_colors; i++) { - mvprintw(2 + i, 0, "%c %-8s:", + for (i = top_color; + (i - top_color < page_size) + && (i < max_colors); i++) { + char numeric[80]; + + sprintf(numeric, "[%d]", i); + mvprintw(2 + i - top_color, 0, "%c %-8s:", (i == current ? '>' : ' '), (i < (int) SIZEOF(the_color_names) - ? the_color_names[i] : "")); + ? the_color_names[i] : numeric)); attrset(COLOR_PAIR(i)); addstr(" "); attrset(A_NORMAL); - /* - * Note: this refresh should *not* be necessary! It works around - * a bug in attribute handling that apparently causes the A_NORMAL - * attribute sets to interfere with the actual emission of the - * color setting somehow. This needs to be fixed. - */ - refresh(); - color_content(i, &red, &green, &blue); addstr(" R = "); if (current == i && field == 0) @@ -1337,26 +2232,47 @@ color_edit(void) if (current == i && field == 2) attrset(A_NORMAL); attrset(A_NORMAL); - addstr(")"); + printw(" ( %3d %3d %3d )", + scaled_rgb(red), + scaled_rgb(green), + scaled_rgb(blue)); } - mvaddstr(max_colors + 3, 0, + mvaddstr(LINES - 3, 0, "Use up/down to select a color, left/right to change fields."); - mvaddstr(max_colors + 4, 0, + mvaddstr(LINES - 2, 0, "Modify field by typing nnn=, nnn-, or nnn+. ? for help."); - move(2 + current, 0); + move(2 + current - top_color, 0); last_c = this_c; this_c = Getchar(); - if (isdigit(this_c) && !isdigit(last_c)) + if (this_c < 256 && isdigit(this_c) && !isdigit(last_c)) value = 0; switch (this_c) { + case CTRL('b'): + case KEY_PPAGE: + if (current > 0) + current -= (page_size - 1); + else + beep(); + break; + + case CTRL('f'): + case KEY_NPAGE: + if (current < (max_colors - 1)) + current += (page_size - 1); + else + beep(); + break; + + case CTRL('p'): case KEY_UP: current = (current == 0 ? (max_colors - 1) : current - 1); break; + case CTRL('n'): case KEY_DOWN: current = (current == (max_colors - 1) ? 0 : current + 1); break; @@ -1407,26 +2323,48 @@ color_edit(void) P("To increment or decrement a value, use the same procedure, but finish"); P("with a `+' or `-'."); P(""); - P("To quit, do `x' or 'q'"); + P("Press 'm' to invoke the top-level menu with the current color settings."); + P("To quit, do ESC"); Pause(); erase(); break; - case 'x': - case 'q': + case 'm': + endwin(); + main_menu(FALSE); + refresh(); + break; + + case_QUIT: break; default: beep(); break; } - mvprintw(LINES - 2, 0, "Number: %d", value); + + if (current < 0) + current = 0; + if (current >= max_colors) + current = max_colors - 1; + if (current < top_color) + top_color = current; + if (current - top_color >= page_size) + top_color = current - (page_size - 1); + + mvprintw(LINES - 1, 0, "Number: %d", value); clrtoeol(); } while - (this_c != 'x' && this_c != 'q'); + (!isQuit(this_c)); erase(); + + /* + * ncurses does not reset each color individually when calling endwin(). + */ + init_all_colors(); + endwin(); } @@ -1436,6 +2374,8 @@ color_edit(void) * ****************************************************************************/ +#if USE_SOFTKEYS + #define SLK_HELP 17 #define SLK_WORK (SLK_HELP + 3) @@ -1457,7 +2397,7 @@ slk_help(void) #if HAVE_SLK_COLOR ,"F/B -- cycle through foreground/background colors" #endif - ,"x, q -- return to main menu" + ,"ESC -- return to main menu" ,"" ,"Note: if activating the soft keys causes your terminal to scroll up" ,"one line, your terminal auto-scrolls when anything is written to the" @@ -1473,6 +2413,18 @@ slk_help(void) refresh(); } +#if HAVE_SLK_COLOR +static void +call_slk_color(short fg, short bg) +{ + init_pair(1, bg, fg); + slk_color(1); + mvprintw(SLK_WORK, 0, "Colors %d/%d\n", fg, bg); + clrtoeol(); + refresh(); +} +#endif + static void slk_test(void) /* exercise the soft keys */ @@ -1483,26 +2435,16 @@ slk_test(void) #if HAVE_SLK_COLOR short fg = COLOR_BLACK; short bg = COLOR_WHITE; - bool new_color = FALSE; #endif c = CTRL('l'); #if HAVE_SLK_COLOR - if (has_colors()) { - new_color = TRUE; + if (use_colors) { + call_slk_color(fg, bg); } #endif do { -#if HAVE_SLK_COLOR - if (new_color) { - init_pair(1, bg, fg); - slk_color(1); - new_color = FALSE; - mvprintw(SLK_WORK, 0, "Colors %d/%d\n", fg, bg); - refresh(); - } -#endif move(0, 0); switch (c) { case CTRL('l'): @@ -1564,60 +2506,56 @@ slk_test(void) clrtobot(); break; - case 'x': - case 'q': + case_QUIT: goto done; #if HAVE_SLK_COLOR case 'F': - if (has_colors()) { - fg = (fg + 1) % max_colors; - new_color = TRUE; + if (use_colors) { + fg = (fg + 1) % COLORS; + call_slk_color(fg, bg); } break; case 'B': - if (has_colors()) { - bg = (bg + 1) % max_colors; - new_color = TRUE; + if (use_colors) { + bg = (bg + 1) % COLORS; + call_slk_color(fg, bg); } break; #endif +#if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE + case KEY_RESIZE: + break; +#endif default: beep(); } - } while - ((c = Getchar()) != EOF); + } while (!isQuit(c = Getchar())); done: + slk_clear(); erase(); endwin(); } #if USE_WIDEC_SUPPORT +#define SLKLEN 8 static void wide_slk_test(void) /* exercise the soft keys */ { int c, fmt = 1; - wchar_t buf[9]; + wchar_t buf[SLKLEN + 1]; char *s; short fg = COLOR_BLACK; short bg = COLOR_WHITE; - bool new_color = FALSE; c = CTRL('l'); - if (has_colors()) { - new_color = TRUE; + if (use_colors) { + call_slk_color(fg, bg); } do { - if (new_color) { - init_pair(1, bg, fg); - slk_color(1); - new_color = FALSE; - mvprintw(SLK_WORK, 0, "Colors %d/%d\n", fg, bg); - refresh(); - } move(0, 0); switch (c) { case CTRL('l'): @@ -1670,48 +2608,67 @@ wide_slk_test(void) (void) mvaddstr(SLK_WORK, 0, "Please enter the label value: "); *buf = 0; if ((s = slk_label(c - '0')) != 0) { - int j; - for (j = 0; j < 8; ++j) { - if ((buf[j] = UChar(s[j])) == 0) + char *temp = strdup(s); + size_t used = strlen(temp); + size_t want = SLKLEN; + size_t test; + mbstate_t state; + + buf[0] = L'\0'; + while (want > 0 && used != 0) { + const char *base = s; + memset(&state, 0, sizeof(state)); + test = mbsrtowcs(0, &base, 0, &state); + if (test == (size_t) -1) { + temp[--used] = 0; + } else if (test > want) { + temp[--used] = 0; + } else { + memset(&state, 0, sizeof(state)); + mbsrtowcs(buf, &base, want, &state); break; + } } - buf[j] = 0; + free(temp); } - wGet_wstring(stdscr, buf, 8); + wGet_wstring(stdscr, buf, SLKLEN); slk_wset((c - '0'), buf, fmt); slk_refresh(); move(SLK_WORK, 0); clrtobot(); break; - case 'x': - case 'q': + case_QUIT: goto done; case 'F': - if (has_colors()) { - fg = (fg + 1) % max_colors; - new_color = TRUE; + if (use_colors) { + fg = (fg + 1) % COLORS; + call_slk_color(fg, bg); } break; case 'B': - if (has_colors()) { - bg = (bg + 1) % max_colors; - new_color = TRUE; + if (use_colors) { + bg = (bg + 1) % COLORS; + call_slk_color(fg, bg); } break; - +#if defined(NCURSES_VERSION) && defined(KEY_RESIZE) && HAVE_WRESIZE + case KEY_RESIZE: + break; +#endif default: beep(); } - } while - ((c = Getchar()) != EOF); + } while (!isQuit(c = Getchar())); done: + slk_clear(); erase(); endwin(); } #endif +#endif /* SLK_INIT */ /**************************************************************************** * @@ -1723,11 +2680,11 @@ wide_slk_test(void) * terminal to perform functions. The remaining codes can be graphic. */ static void -show_upper_chars(int first) +show_upper_chars(unsigned first) { bool C1 = (first == 128); - int code; - int last = first + 31; + unsigned code; + unsigned last = first + 31; int reply; erase(); @@ -1738,10 +2695,10 @@ show_upper_chars(int first) refresh(); for (code = first; code <= last; code++) { - int row = 4 + ((code - first) % 16); + int row = 2 + ((code - first) % 16); int col = ((code - first) / 16) * COLS / 2; char tmp[80]; - sprintf(tmp, "%3d (0x%x)", code, code); + sprintf(tmp, "%3u (0x%x)", code, code); mvprintw(row, col, "%*s: ", COLS / 4, tmp); if (C1) nodelay(stdscr, TRUE); @@ -1749,7 +2706,7 @@ show_upper_chars(int first) if (C1) { /* (yes, this _is_ crude) */ while ((reply = Getchar()) != ERR) { - addch(reply); + addch(UChar(reply)); napms(10); } nodelay(stdscr, FALSE); @@ -1757,6 +2714,44 @@ show_upper_chars(int first) } } +static void +show_pc_chars(void) +{ + unsigned code; + + erase(); + attron(A_BOLD); + mvprintw(0, 20, "Display of PC Character Codes"); + attroff(A_BOLD); + refresh(); + + for (code = 0; code < 16; ++code) { + mvprintw(2, (int) code * 3 + 8, "%X", code); + } + for (code = 0; code < 256; code++) { + int row = 3 + (code / 16) + (code >= 128); + int col = 8 + (code % 16) * 3; + if ((code % 16) == 0) + mvprintw(row, 0, "0x%02x:", code); + move(row, col); + switch (code) { + case '\n': + case '\r': + case '\b': + case '\f': + case '\033': + case 0x9b: + /* + * Skip the ones that do not work. + */ + break; + default: + addch(code | A_ALTCHARSET); + break; + } + } +} + static void show_box_chars(void) { @@ -1782,7 +2777,7 @@ static int show_1_acs(int n, const char *name, chtype code) { const int height = 16; - int row = 4 + (n % height); + int row = 2 + (n % height); int col = (n / height) * COLS / 2; mvprintw(row, col, "%*s : ", COLS / 4, name); addch(code); @@ -1816,6 +2811,10 @@ show_acs_chars(void) n = show_1_acs(n, BOTH(ACS_HLINE)); n = show_1_acs(n, BOTH(ACS_VLINE)); + /* + * HPUX's ACS definitions are broken here. Just give up. + */ +#if !(defined(__hpux) && !defined(NCURSES_VERSION)) n = show_1_acs(n, BOTH(ACS_LARROW)); n = show_1_acs(n, BOTH(ACS_RARROW)); n = show_1_acs(n, BOTH(ACS_UARROW)); @@ -1841,34 +2840,49 @@ show_acs_chars(void) n = show_1_acs(n, BOTH(ACS_S3)); n = show_1_acs(n, BOTH(ACS_S7)); n = show_1_acs(n, BOTH(ACS_S9)); +#endif } static void acs_display(void) { int c = 'a'; + char *term = getenv("TERM"); + const char *pch_kludge = ((term != 0 && strstr(term, "linux")) + ? "p=PC, " + : ""); do { switch (c) { + case CTRL('L'): + Repaint(); + break; case 'a': show_acs_chars(); break; - case 'b': + case 'x': show_box_chars(); break; case '0': case '1': case '2': case '3': - show_upper_chars((c - '0') * 32 + 128); + show_upper_chars((unsigned) ((c - '0') * 32 + 128)); + break; + case 'p': + show_pc_chars(); + break; + default: + beep(); break; } mvprintw(LINES - 3, 0, "Note: ANSI terminals may not display C1 characters."); mvprintw(LINES - 2, 0, - "Select: a=ACS, b=box, 0=C1, 1,2,3=GR characters, q=quit"); + "Select: a=ACS, x=box, %s0=C1, 1,2,3=GR characters, ESC=quit", + pch_kludge); refresh(); - } while ((c = Getchar()) != 'x' && c != 'q'); + } while (!isQuit(c = Getchar())); Pause(); erase(); @@ -1876,8 +2890,29 @@ acs_display(void) } #if USE_WIDEC_SUPPORT +static cchar_t * +merge_wide_attr(cchar_t *dst, cchar_t *src, attr_t attr, short pair) +{ + int count = getcchar(src, NULL, NULL, NULL, 0); + wchar_t *wch = 0; + attr_t ignore_attr; + short ignore_pair; + + *dst = *src; + if (count > 0) { + if ((wch = typeMalloc(wchar_t, count)) != 0) { + if (getcchar(src, wch, &ignore_attr, &ignore_pair, 0) != ERR) { + attr |= (ignore_attr & A_ALTCHARSET); + setcchar(dst, wch, attr, pair, 0); + } + free(wch); + } + } + return dst; +} + static void -show_upper_widechars(int first, int repeat) +show_upper_widechars(int first, int repeat, int space, attr_t attr, short pair) { cchar_t temp; wchar_t code; @@ -1889,19 +2924,27 @@ show_upper_widechars(int first, int repeat) attroff(A_BOLD); for (code = first; code <= last; code++) { - int row = 4 + ((code - first) % 16); + int row = 2 + ((code - first) % 16); int col = ((code - first) / 16) * COLS / 2; wchar_t codes[10]; - attr_t attrs = A_NORMAL; char tmp[80]; int count = repeat; + int y, x; memset(&codes, 0, sizeof(codes)); codes[0] = code; sprintf(tmp, "%3ld (0x%lx)", (long) code, (long) code); mvprintw(row, col, "%*s: ", COLS / 4, tmp); - setcchar(&temp, codes, attrs, 0, 0); + setcchar(&temp, codes, attr, pair, 0); do { + /* + * Give non-spacing characters something to combine with. If we + * don't, they'll bunch up in a heap on the space after the ":". + * Mark them with reverse-video to make them simpler to find on + * the display. + */ + if (wcwidth(code) == 0) + addch(space | A_REVERSE); /* * This could use add_wch(), but is done for comparison with the * normal 'f' test (and to make a test-case for echo_wchar()). @@ -1909,29 +2952,39 @@ show_upper_widechars(int first, int repeat) * function is met by the builtin refresh() in echo_wchar(). */ echo_wchar(&temp); + /* + * The repeat-count may make text wrap - avoid that. + */ + getyx(stdscr, y, x); + if (x >= col + (COLS / 2) - 2) + break; } while (--count > 0); } } static int -show_1_wacs(int n, const char *name, const cchar_t * code) +show_1_wacs(int n, const char *name, const cchar_t *code) { const int height = 16; - int row = 4 + (n % height); + int row = 2 + (n % height); int col = (n / height) * COLS / 2; mvprintw(row, col, "%*s : ", COLS / 4, name); add_wchnstr(code, 1); return n + 1; } +#define MERGE_ATTR(wch) merge_wide_attr(&temp, wch, attr, pair) + static void -show_wacs_chars(void) +show_wacs_chars(attr_t attr, short pair) /* display the wide-ACS character set */ { + cchar_t temp; + int n; /*#define BOTH2(name) #name, &(name) */ -#define BOTH2(name) #name, name +#define BOTH2(name) #name, MERGE_ATTR(name) erase(); attron(A_BOLD); @@ -1981,43 +3034,57 @@ show_wacs_chars(void) #endif } +#undef MERGE_ATTR + +#define MERGE_ATTR(wch) merge_wide_attr(&temp, wch, attr, pair) + static void -show_wbox_chars(void) +show_wbox_chars(attr_t attr, short pair) { + cchar_t temp; + erase(); attron(A_BOLD); mvaddstr(0, 20, "Display of the Wide-ACS Line-Drawing Set"); attroff(A_BOLD); refresh(); + + attr_set(attr, pair, 0); box_set(stdscr, 0, 0); + attr_set(A_NORMAL, 0, 0); /* *INDENT-OFF* */ - mvhline_set(LINES / 2, 0, WACS_HLINE, COLS); - mvvline_set(0, COLS / 2, WACS_VLINE, LINES); - mvadd_wch(0, COLS / 2, WACS_TTEE); - mvadd_wch(LINES / 2, COLS / 2, WACS_PLUS); - mvadd_wch(LINES - 1, COLS / 2, WACS_BTEE); - mvadd_wch(LINES / 2, 0, WACS_LTEE); - mvadd_wch(LINES / 2, COLS - 1, WACS_RTEE); + mvhline_set(LINES / 2, 0, MERGE_ATTR(WACS_HLINE), COLS); + mvvline_set(0, COLS / 2, MERGE_ATTR(WACS_VLINE), LINES); + mvadd_wch(0, COLS / 2, MERGE_ATTR(WACS_TTEE)); + mvadd_wch(LINES / 2, COLS / 2, MERGE_ATTR(WACS_PLUS)); + mvadd_wch(LINES - 1, COLS / 2, MERGE_ATTR(WACS_BTEE)); + mvadd_wch(LINES / 2, 0, MERGE_ATTR(WACS_LTEE)); + mvadd_wch(LINES / 2, COLS - 1, MERGE_ATTR(WACS_RTEE)); /* *INDENT-ON* */ } +#undef MERGE_ATTR + static int -show_2_wacs(int n, const char *name, const char *code) +show_2_wacs(int n, const char *name, const char *code, attr_t attr, short pair) { const int height = 16; - int row = 4 + (n % height); + int row = 2 + (n % height); int col = (n / height) * COLS / 2; char temp[80]; mvprintw(row, col, "%*s : ", COLS / 4, name); + attr_set(attr, pair, 0); addstr(strcpy(temp, code)); + attr_set(A_NORMAL, 0, 0); return n + 1; } +#define SHOW_UTF8(n, name, code) show_2_wacs(n, name, code, attr, pair) + static void -show_utf8_chars(void) -/* display the wide-ACS character set */ +show_utf8_chars(attr_t attr, short pair) { int n; @@ -2027,87 +3094,195 @@ show_utf8_chars(void) attroff(A_BOLD); refresh(); /* *INDENT-OFF* */ - n = show_2_wacs(0, "WACS_ULCORNER", "\342\224\214"); - n = show_2_wacs(n, "WACS_URCORNER", "\342\224\220"); - n = show_2_wacs(n, "WACS_LLCORNER", "\342\224\224"); - n = show_2_wacs(n, "WACS_LRCORNER", "\342\224\230"); - - n = show_2_wacs(n, "WACS_LTEE", "\342\224\234"); - n = show_2_wacs(n, "WACS_RTEE", "\342\224\244"); - n = show_2_wacs(n, "WACS_TTEE", "\342\224\254"); - n = show_2_wacs(n, "WACS_BTEE", "\342\224\264"); - - n = show_2_wacs(n, "WACS_HLINE", "\342\224\200"); - n = show_2_wacs(n, "WACS_VLINE", "\342\224\202"); - - n = show_2_wacs(n, "WACS_LARROW", "\342\206\220"); - n = show_2_wacs(n, "WACS_RARROW", "\342\206\222"); - n = show_2_wacs(n, "WACS_UARROW", "\342\206\221"); - n = show_2_wacs(n, "WACS_DARROW", "\342\206\223"); - - n = show_2_wacs(n, "WACS_BLOCK", "\342\226\256"); - n = show_2_wacs(n, "WACS_BOARD", "\342\226\222"); - n = show_2_wacs(n, "WACS_LANTERN", "\342\230\203"); - n = show_2_wacs(n, "WACS_BULLET", "\302\267"); - n = show_2_wacs(n, "WACS_CKBOARD", "\342\226\222"); - n = show_2_wacs(n, "WACS_DEGREE", "\302\260"); - n = show_2_wacs(n, "WACS_DIAMOND", "\342\227\206"); - n = show_2_wacs(n, "WACS_PLMINUS", "\302\261"); - n = show_2_wacs(n, "WACS_PLUS", "\342\224\274"); - n = show_2_wacs(n, "WACS_GEQUAL", "\342\211\245"); - n = show_2_wacs(n, "WACS_NEQUAL", "\342\211\240"); - n = show_2_wacs(n, "WACS_LEQUAL", "\342\211\244"); - - n = show_2_wacs(n, "WACS_STERLING", "\302\243"); - n = show_2_wacs(n, "WACS_PI", "\317\200"); - n = show_2_wacs(n, "WACS_S1", "\342\216\272"); - n = show_2_wacs(n, "WACS_S3", "\342\216\273"); - n = show_2_wacs(n, "WACS_S7", "\342\216\274"); - n = show_2_wacs(n, "WACS_S9", "\342\216\275"); + n = SHOW_UTF8(0, "WACS_ULCORNER", "\342\224\214"); + n = SHOW_UTF8(n, "WACS_URCORNER", "\342\224\220"); + n = SHOW_UTF8(n, "WACS_LLCORNER", "\342\224\224"); + n = SHOW_UTF8(n, "WACS_LRCORNER", "\342\224\230"); + + n = SHOW_UTF8(n, "WACS_LTEE", "\342\224\234"); + n = SHOW_UTF8(n, "WACS_RTEE", "\342\224\244"); + n = SHOW_UTF8(n, "WACS_TTEE", "\342\224\254"); + n = SHOW_UTF8(n, "WACS_BTEE", "\342\224\264"); + + n = SHOW_UTF8(n, "WACS_HLINE", "\342\224\200"); + n = SHOW_UTF8(n, "WACS_VLINE", "\342\224\202"); + + n = SHOW_UTF8(n, "WACS_LARROW", "\342\206\220"); + n = SHOW_UTF8(n, "WACS_RARROW", "\342\206\222"); + n = SHOW_UTF8(n, "WACS_UARROW", "\342\206\221"); + n = SHOW_UTF8(n, "WACS_DARROW", "\342\206\223"); + + n = SHOW_UTF8(n, "WACS_BLOCK", "\342\226\256"); + n = SHOW_UTF8(n, "WACS_BOARD", "\342\226\222"); + n = SHOW_UTF8(n, "WACS_LANTERN", "\342\230\203"); + n = SHOW_UTF8(n, "WACS_BULLET", "\302\267"); + n = SHOW_UTF8(n, "WACS_CKBOARD", "\342\226\222"); + n = SHOW_UTF8(n, "WACS_DEGREE", "\302\260"); + n = SHOW_UTF8(n, "WACS_DIAMOND", "\342\227\206"); + n = SHOW_UTF8(n, "WACS_PLMINUS", "\302\261"); + n = SHOW_UTF8(n, "WACS_PLUS", "\342\224\274"); + n = SHOW_UTF8(n, "WACS_GEQUAL", "\342\211\245"); + n = SHOW_UTF8(n, "WACS_NEQUAL", "\342\211\240"); + n = SHOW_UTF8(n, "WACS_LEQUAL", "\342\211\244"); + + n = SHOW_UTF8(n, "WACS_STERLING", "\302\243"); + n = SHOW_UTF8(n, "WACS_PI", "\317\200"); + n = SHOW_UTF8(n, "WACS_S1", "\342\216\272"); + n = SHOW_UTF8(n, "WACS_S3", "\342\216\273"); + n = SHOW_UTF8(n, "WACS_S7", "\342\216\274"); + n = SHOW_UTF8(n, "WACS_S9", "\342\216\275"); /* *INDENT-ON* */ } +/* *INDENT-OFF* */ +static struct { + attr_t attr; + const char *name; +} attrs_to_cycle[] = { + { A_NORMAL, "normal" }, + { A_BOLD, "bold" }, + { A_REVERSE, "reverse" }, + { A_UNDERLINE, "underline" }, +}; +/* *INDENT-ON* */ + +static bool +cycle_attr(int ch, unsigned *at_code, chtype *attr) +{ + bool result = TRUE; + + switch (ch) { + case 'v': + if ((*at_code += 1) >= SIZEOF(attrs_to_cycle)) + *at_code = 0; + break; + case 'V': + if (*at_code == 1) + *at_code = SIZEOF(attrs_to_cycle) - 1; + else + *at_code -= 1; + break; + default: + result = FALSE; + break; + } + if (result) + *attr = attrs_to_cycle[*at_code].attr; + return result; +} + +static bool +cycle_colors(int ch, int *fg, int *bg, short *pair) +{ + bool result = FALSE; + + if (use_colors) { + result = TRUE; + switch (ch) { + case 'F': + if ((*fg -= 1) < 0) + *fg = COLORS - 1; + break; + case 'f': + if ((*fg += 1) >= COLORS) + *fg = 0; + break; + case 'B': + if ((*bg -= 1) < 0) + *bg = COLORS - 1; + break; + case 'b': + if ((*bg += 1) < 0) + *bg = 0; + break; + default: + result = FALSE; + break; + } + if (result) { + *pair = (*fg != COLOR_BLACK || *bg != COLOR_BLACK); + if (*pair != 0) { + *pair = 1; + if (init_pair(*pair, *fg, *bg) == ERR) { + result = FALSE; + } + } + } + } + return result; +} +/* display the wide-ACS character set */ static void wide_acs_display(void) { int c = 'a'; int digit = 0; int repeat = 0; + int space = ' '; + chtype attr = A_NORMAL; + int fg = COLOR_BLACK; + int bg = COLOR_BLACK; + unsigned at_code = 0; + short pair = 0; + void (*last_show_wacs) (attr_t, short) = 0; do { switch (c) { + case CTRL('L'): + Repaint(); + break; case 'a': - show_wacs_chars(); + last_show_wacs = show_wacs_chars; break; - case 'b': - show_wbox_chars(); + case 'x': + last_show_wacs = show_wbox_chars; break; case 'u': - show_utf8_chars(); + last_show_wacs = show_utf8_chars; break; default: - if (isdigit(c)) + if (c < 256 && isdigit(c)) { digit = (c - '0'); - else if (c == '+') + } else if (c == '+') { ++digit; - else if (c == '-' && digit > 0) + } else if (c == '-' && digit > 0) { --digit; - else if (c == '>') + } else if (c == '>' && repeat < (COLS / 4)) { ++repeat; - else if (c == '<' && repeat > 0) + } else if (c == '<' && repeat > 0) { --repeat; - else { + } else if (c == '_') { + space = (space == ' ') ? '_' : ' '; + } else if (cycle_attr(c, &at_code, &attr) + || cycle_colors(c, &fg, &bg, &pair)) { + if (last_show_wacs != 0) + break; + } else { beep(); break; } - show_upper_widechars(digit * 32 + 128, repeat); + last_show_wacs = 0; + show_upper_widechars(digit * 32 + 128, repeat, space, attr, pair); break; } - mvprintw(LINES - 2, 0, - "Select: a WACS, b box, u UTF-8, 0-9,+/- non-ASCII, repeat, q=quit"); + if (last_show_wacs != 0) + last_show_wacs(attr, pair); + + mvprintw(LINES - 3, 0, + "Select: a WACS, x box, u UTF-8, 0-9,+/- non-ASCII, repeat, ESC=quit"); + if (use_colors) { + mvprintw(LINES - 2, 0, + "v/V, f/F, b/B cycle through video attributes (%s) and color %d/%d.", + attrs_to_cycle[at_code].name, + fg, bg); + } else { + mvprintw(LINES - 2, 0, + "v/V cycles through video attributes (%s).", + attrs_to_cycle[at_code].name); + } refresh(); - } while ((c = Getchar()) != 'x' && c != 'q'); + } while (!isQuit(c = Getchar())); Pause(); erase(); @@ -2125,10 +3300,10 @@ test_sgr_attributes(void) int pass; for (pass = 0; pass < 2; pass++) { - int normal = ((pass == 0 ? A_NORMAL : A_REVERSE)) | BLANK; + chtype normal = ((pass == 0 ? A_NORMAL : A_REVERSE)) | BLANK; /* Use non-default colors if possible to exercise bce a little */ - if (has_colors()) { + if (use_colors) { init_pair(1, COLOR_WHITE, COLOR_BLUE); normal |= COLOR_PAIR(1); } @@ -2217,12 +3392,14 @@ FRAME WINDOW *wind; }; -#ifdef NCURSES_VERSION -#define keypad_active(win) (win)->_use_keypad -#define scroll_active(win) (win)->_scroll +#if defined(NCURSES_VERSION) +#if NCURSES_VERSION_PATCH < 20070331 +#define is_keypad(win) (win)->_use_keypad +#define is_scrollok(win) (win)->_scroll +#endif #else -#define keypad_active(win) FALSE -#define scroll_active(win) FALSE +#define is_keypad(win) FALSE +#define is_scrollok(win) FALSE #endif /* We need to know if these flags are actually set, so don't look in FRAME. @@ -2233,14 +3410,16 @@ static bool HaveKeypad(FRAME * curp) { WINDOW *win = (curp ? curp->wind : stdscr); - return keypad_active(win); + (void) win; + return is_keypad(win); } static bool HaveScroll(FRAME * curp) { WINDOW *win = (curp ? curp->wind : stdscr); - return scroll_active(win); + (void) win; + return is_scrollok(win); } static void @@ -2378,8 +3557,7 @@ selectcell(int uli, int ulj, int lri, int lrj) case KEY_RIGHT: j++; break; - case QUIT: - case ESCAPE: + case_QUIT: return ((pair *) 0); #ifdef NCURSES_MOUSE_VERSION case KEY_MOUSE: @@ -2505,9 +3683,11 @@ acs_and_scroll(void) /* Demonstrate windows */ { int c, i; - FILE *fp; FRAME *current = (FRAME *) 0, *neww; WINDOW *usescr = stdscr; +#if HAVE_PUTWIN && HAVE_GETWIN + FILE *fp; +#endif #define DUMPFILE "screendump" @@ -2577,6 +3757,7 @@ acs_and_scroll(void) } break; +#if HAVE_PUTWIN && HAVE_GETWIN case CTRL('W'): /* save and delete window */ if (current == current->next) { transient(current, "Will not save/delete ONLY window"); @@ -2608,6 +3789,7 @@ acs_and_scroll(void) wrefresh(neww->wind); } break; +#endif #if HAVE_WRESIZE case CTRL('X'): /* resize window */ @@ -2716,8 +3898,7 @@ acs_and_scroll(void) usescr = (current ? current->wind : stdscr); wrefresh(usescr); } while - ((c = wGetchar(usescr)) != QUIT - && !((c == ESCAPE) && (keypad_active(usescr))) + (!isQuit(c = wGetchar(usescr)) && (c != ERR)); breakout: @@ -2740,7 +3921,7 @@ acs_and_scroll(void) ****************************************************************************/ #if USE_LIBPANEL -static unsigned long nap_msec = 1; +static int nap_msec = 1; static NCURSES_CONST char *mod[] = { @@ -2756,7 +3937,7 @@ static NCURSES_CONST char *mod[] = wait_a_while(msec) --------------------------------------------------------------------------*/ static void -wait_a_while(unsigned long msec GCC_UNUSED) +wait_a_while(int msec GCC_UNUSED) { #if HAVE_NAPMS if (nap_msec == 1) @@ -2766,8 +3947,8 @@ wait_a_while(unsigned long msec GCC_UNUSED) #else if (nap_msec == 1) wGetchar(stdscr); - else if (msec > 1000L) - sleep((int) msec / 1000L); + else if (msec > 1000) + sleep((unsigned) msec / 1000); else sleep(1); #endif @@ -2781,14 +3962,18 @@ saywhat(NCURSES_CONST char *text) { wmove(stdscr, LINES - 1, 0); wclrtoeol(stdscr); - waddstr(stdscr, text); + if (text != 0 && *text != '\0') { + waddstr(stdscr, text); + waddstr(stdscr, "; "); + } + waddstr(stdscr, "press any key to continue"); } /* end of saywhat */ /*+------------------------------------------------------------------------- mkpanel(rows,cols,tly,tlx) - alloc a win and panel and associate them --------------------------------------------------------------------------*/ static PANEL * -mkpanel(int color, int rows, int cols, int tly, int tlx) +mkpanel(short color, int rows, int cols, int tly, int tlx) { WINDOW *win; PANEL *pan = 0; @@ -2796,11 +3981,12 @@ mkpanel(int color, int rows, int cols, int tly, int tlx) if ((win = newwin(rows, cols, tly, tlx)) != 0) { if ((pan = new_panel(win)) == 0) { delwin(win); - } else if (has_colors()) { - int fg = (color == COLOR_BLUE) ? COLOR_WHITE : COLOR_BLACK; - int bg = color; + } else if (use_colors) { + short fg = (color == COLOR_BLUE) ? COLOR_WHITE : COLOR_BLACK; + short bg = color; + init_pair(color, fg, bg); - wbkgdset(win, COLOR_PAIR(color) | ' '); + wbkgdset(win, (chtype) (COLOR_PAIR(color) | ' ')); } else { wbkgdset(win, A_BOLD | ' '); } @@ -2832,6 +4018,17 @@ pflush(void) /*+------------------------------------------------------------------------- fill_panel(win) --------------------------------------------------------------------------*/ +static void +init_panel(void) +{ + register int y, x; + + for (y = 0; y < LINES - 1; y++) { + for (x = 0; x < COLS; x++) + wprintw(stdscr, "%d", (y + x) % 10); + } +} + static void fill_panel(PANEL * pan) { @@ -2846,217 +4043,218 @@ fill_panel(PANEL * pan) for (y = 2; y < getmaxy(win) - 1; y++) { for (x = 1; x < getmaxx(win) - 1; x++) { wmove(win, y, x); - waddch(win, num); + waddch(win, UChar(num)); } } -} /* end of fill_panel */ +} +#if USE_WIDEC_SUPPORT static void -demo_panels(void) +make_fullwidth_digit(cchar_t *target, int digit) { - int itmp; - register int y, x; + wchar_t source[2]; - refresh(); + source[0] = digit + 0xff10; + source[1] = 0; + setcchar(target, source, A_NORMAL, 0, 0); +} - for (y = 0; y < LINES - 1; y++) { - for (x = 0; x < COLS; x++) - wprintw(stdscr, "%d", (y + x) % 10); - } - for (y = 0; y < 5; y++) { - PANEL *p1; - PANEL *p2; - PANEL *p3; - PANEL *p4; - PANEL *p5; - - p1 = mkpanel(COLOR_RED, - LINES / 2 - 2, - COLS / 8 + 1, - 0, - 0); - set_panel_userptr(p1, (NCURSES_CONST void *) "p1"); - - p2 = mkpanel(COLOR_GREEN, - LINES / 2 + 1, - COLS / 7, - LINES / 4, - COLS / 10); - set_panel_userptr(p2, (NCURSES_CONST void *) "p2"); - - p3 = mkpanel(COLOR_YELLOW, - LINES / 4, - COLS / 10, - LINES / 2, - COLS / 9); - set_panel_userptr(p3, (NCURSES_CONST void *) "p3"); - - p4 = mkpanel(COLOR_BLUE, - LINES / 2 - 2, - COLS / 8, - LINES / 2 - 2, - COLS / 3); - set_panel_userptr(p4, (NCURSES_CONST void *) "p4"); - - p5 = mkpanel(COLOR_MAGENTA, - LINES / 2 - 2, - COLS / 8, - LINES / 2, - COLS / 2 - 2); - set_panel_userptr(p5, (NCURSES_CONST void *) "p5"); - - fill_panel(p1); - fill_panel(p2); - fill_panel(p3); - fill_panel(p4); - fill_panel(p5); - hide_panel(p4); - hide_panel(p5); - pflush(); - saywhat("press any key to continue"); - wait_a_while(nap_msec); +static void +init_wide_panel(void) +{ + int digit; + cchar_t temp[10]; - saywhat("h3 s1 s2 s4 s5; press any key to continue"); - move_panel(p1, 0, 0); - hide_panel(p3); - show_panel(p1); - show_panel(p2); - show_panel(p4); - show_panel(p5); - pflush(); - wait_a_while(nap_msec); + for (digit = 0; digit < 10; ++digit) + make_fullwidth_digit(&temp[digit], digit); - saywhat("s1; press any key to continue"); - show_panel(p1); - pflush(); - wait_a_while(nap_msec); + do { + int y, x; + getyx(stdscr, y, x); + digit = (y + x / 2) % 10; + } while (add_wch(&temp[digit]) != ERR); +} - saywhat("s2; press any key to continue"); - show_panel(p2); - pflush(); - wait_a_while(nap_msec); +static void +fill_wide_panel(PANEL * pan) +{ + WINDOW *win = panel_window(pan); + int num = ((const char *) panel_userptr(pan))[1]; + int y, x; - saywhat("m2; press any key to continue"); - move_panel(p2, LINES / 3 + 1, COLS / 8); - pflush(); - wait_a_while(nap_msec); + wmove(win, 1, 1); + wprintw(win, "-pan%c-", num); + wclrtoeol(win); + box(win, 0, 0); + for (y = 2; y < getmaxy(win) - 1; y++) { + for (x = 1; x < getmaxx(win) - 1; x++) { + wmove(win, y, x); + waddch(win, UChar(num)); + } + } +} +#endif - saywhat("s3;"); - show_panel(p3); - pflush(); - wait_a_while(nap_msec); +#define MAX_PANELS 5 - saywhat("m3; press any key to continue"); - move_panel(p3, LINES / 4 + 1, COLS / 15); - pflush(); - wait_a_while(nap_msec); +static void +canned_panel(PANEL * px[MAX_PANELS + 1], NCURSES_CONST char *cmd) +{ + int which = cmd[1] - '0'; - saywhat("b3; press any key to continue"); - bottom_panel(p3); - pflush(); - wait_a_while(nap_msec); + saywhat(cmd); + switch (*cmd) { + case 'h': + hide_panel(px[which]); + break; + case 's': + show_panel(px[which]); + break; + case 't': + top_panel(px[which]); + break; + case 'b': + bottom_panel(px[which]); + break; + case 'd': + rmpanel(px[which]); + break; + } + pflush(); + wait_a_while(nap_msec); +} - saywhat("s4; press any key to continue"); - show_panel(p4); - pflush(); - wait_a_while(nap_msec); +static void +demo_panels(void (*InitPanel) (void), void (*FillPanel) (PANEL *)) +{ + int count; + int itmp; + PANEL *px[MAX_PANELS + 1]; + + scrollok(stdscr, FALSE); /* we don't want stdscr to scroll! */ + refresh(); - saywhat("s5; press any key to continue"); - show_panel(p5); + InitPanel(); + for (count = 0; count < 5; count++) { + px[1] = mkpanel(COLOR_RED, + LINES / 2 - 2, + COLS / 8 + 1, + 0, + 0); + set_panel_userptr(px[1], (NCURSES_CONST void *) "p1"); + + px[2] = mkpanel(COLOR_GREEN, + LINES / 2 + 1, + COLS / 7, + LINES / 4, + COLS / 10); + set_panel_userptr(px[2], (NCURSES_CONST void *) "p2"); + + px[3] = mkpanel(COLOR_YELLOW, + LINES / 4, + COLS / 10, + LINES / 2, + COLS / 9); + set_panel_userptr(px[3], (NCURSES_CONST void *) "p3"); + + px[4] = mkpanel(COLOR_BLUE, + LINES / 2 - 2, + COLS / 8, + LINES / 2 - 2, + COLS / 3); + set_panel_userptr(px[4], (NCURSES_CONST void *) "p4"); + + px[5] = mkpanel(COLOR_MAGENTA, + LINES / 2 - 2, + COLS / 8, + LINES / 2, + COLS / 2 - 2); + set_panel_userptr(px[5], (NCURSES_CONST void *) "p5"); + + FillPanel(px[1]); + FillPanel(px[2]); + FillPanel(px[3]); + FillPanel(px[4]); + FillPanel(px[5]); + + hide_panel(px[4]); + hide_panel(px[5]); pflush(); + saywhat(""); wait_a_while(nap_msec); - saywhat("t3; press any key to continue"); - top_panel(p3); + saywhat("h3 s1 s2 s4 s5"); + move_panel(px[1], 0, 0); + hide_panel(px[3]); + show_panel(px[1]); + show_panel(px[2]); + show_panel(px[4]); + show_panel(px[5]); pflush(); wait_a_while(nap_msec); - saywhat("t1; press any key to continue"); - top_panel(p1); - pflush(); - wait_a_while(nap_msec); + canned_panel(px, "s1"); + canned_panel(px, "s2"); - saywhat("t2; press any key to continue"); - top_panel(p2); + saywhat("m2"); + move_panel(px[2], LINES / 3 + 1, COLS / 8); pflush(); wait_a_while(nap_msec); - saywhat("t3; press any key to continue"); - top_panel(p3); - pflush(); - wait_a_while(nap_msec); + canned_panel(px, "s3"); - saywhat("t4; press any key to continue"); - top_panel(p4); + saywhat("m3"); + move_panel(px[3], LINES / 4 + 1, COLS / 15); pflush(); wait_a_while(nap_msec); + canned_panel(px, "b3"); + canned_panel(px, "s4"); + canned_panel(px, "s5"); + canned_panel(px, "t3"); + canned_panel(px, "t1"); + canned_panel(px, "t2"); + canned_panel(px, "t3"); + canned_panel(px, "t4"); + for (itmp = 0; itmp < 6; itmp++) { - WINDOW *w4 = panel_window(p4); - WINDOW *w5 = panel_window(p5); + WINDOW *w4 = panel_window(px[4]); + WINDOW *w5 = panel_window(px[5]); - saywhat("m4; press any key to continue"); + saywhat("m4"); wmove(w4, LINES / 8, 1); waddstr(w4, mod[itmp]); - move_panel(p4, LINES / 6, itmp * (COLS / 8)); + move_panel(px[4], LINES / 6, itmp * (COLS / 8)); wmove(w5, LINES / 6, 1); waddstr(w5, mod[itmp]); pflush(); wait_a_while(nap_msec); - saywhat("m5; press any key to continue"); + saywhat("m5"); wmove(w4, LINES / 6, 1); waddstr(w4, mod[itmp]); - move_panel(p5, LINES / 3 - 1, (itmp * 10) + 6); + move_panel(px[5], LINES / 3 - 1, (itmp * 10) + 6); wmove(w5, LINES / 8, 1); waddstr(w5, mod[itmp]); pflush(); wait_a_while(nap_msec); } - saywhat("m4; press any key to continue"); - move_panel(p4, LINES / 6, itmp * (COLS / 8)); - pflush(); - wait_a_while(nap_msec); - - saywhat("t5; press any key to continue"); - top_panel(p5); - pflush(); - wait_a_while(nap_msec); - - saywhat("t2; press any key to continue"); - top_panel(p2); - pflush(); - wait_a_while(nap_msec); - - saywhat("t1; press any key to continue"); - top_panel(p1); - pflush(); - wait_a_while(nap_msec); - - saywhat("d2; press any key to continue"); - rmpanel(p2); - pflush(); - wait_a_while(nap_msec); - - saywhat("h3; press any key to continue"); - hide_panel(p3); + saywhat("m4"); + move_panel(px[4], LINES / 6, itmp * (COLS / 8)); pflush(); wait_a_while(nap_msec); - saywhat("d1; press any key to continue"); - rmpanel(p1); - pflush(); - wait_a_while(nap_msec); - - saywhat("d4; press any key to continue"); - rmpanel(p4); - pflush(); - wait_a_while(nap_msec); + canned_panel(px, "t5"); + canned_panel(px, "t2"); + canned_panel(px, "t1"); + canned_panel(px, "d2"); + canned_panel(px, "h3"); + canned_panel(px, "d1"); + canned_panel(px, "d4"); + canned_panel(px, "d5"); + canned_panel(px, "d3"); - saywhat("d5; press any key to continue"); - rmpanel(p5); - pflush(); wait_a_while(nap_msec); if (nap_msec == 1) break; @@ -3066,6 +4264,7 @@ demo_panels(void) erase(); endwin(); } +#endif /* USE_LIBPANEL */ /**************************************************************************** * @@ -3083,10 +4282,10 @@ panner_legend(int line) { static const char *const legend[] = { - "Use arrow keys (or U,D,L,R) to pan, q to quit, ! to shell-out.", + "Use arrow keys (or U,D,L,R) to pan, ESC to quit, ! to shell-out.", "Use +,- (or j,k) to grow/shrink the panner vertically.", "Use <,> (or h,l) to grow/shrink the panner horizontally.", - "Number repeats. Toggle legend:?, timer:t, scroll mark:s." + "Number repeats. Toggle legend:? filler:a timer:t scrollmark:s." }; int n = (SIZEOF(legend) - (LINES - line)); if (line < LINES && (n >= 0)) { @@ -3113,6 +4312,35 @@ panner_v_cleanup(int from_y, int from_x, int to_y) do_v_line(from_y, from_x, ' ', to_y); } +static void +fill_pad(WINDOW *panpad, bool pan_lines) +{ + int y, x; + unsigned gridcount = 0; + + wmove(panpad, 0, 0); + for (y = 0; y < getmaxy(panpad); y++) { + for (x = 0; x < getmaxx(panpad); x++) { + if (y % GRIDSIZE == 0 && x % GRIDSIZE == 0) { + if (y == 0 && x == 0) + waddch(panpad, pan_lines ? ACS_ULCORNER : '+'); + else if (y == 0) + waddch(panpad, pan_lines ? ACS_TTEE : '+'); + else if (y == 0 || x == 0) + waddch(panpad, pan_lines ? ACS_LTEE : '+'); + else + waddch(panpad, (chtype) ((pan_lines ? 'a' : 'A') + + (gridcount++ % 26))); + } else if (y % GRIDSIZE == 0) + waddch(panpad, pan_lines ? ACS_HLINE : '-'); + else if (x % GRIDSIZE == 0) + waddch(panpad, pan_lines ? ACS_VLINE : '|'); + else + waddch(panpad, ' '); + } + } +} + static void panner(WINDOW *pad, int top_x, int top_y, int porty, int portx, @@ -3122,6 +4350,7 @@ panner(WINDOW *pad, struct timeval before, after; bool timing = TRUE; #endif + bool pan_lines = FALSE; bool scrollers = TRUE; int basex = 0; int basey = 0; @@ -3160,6 +4389,12 @@ panner(WINDOW *pad, panner_legend(LINES - 2); panner_legend(LINES - 1); break; + case 'a': + pan_lines = !pan_lines; + fill_pad(pad, pan_lines); + pending_pan = FALSE; + break; + #if HAVE_GETTIMEOFDAY case 't': timing = !timing; @@ -3357,7 +4592,7 @@ panner(WINDOW *pad, gettimeofday(&after, 0); elapsed = (after.tv_sec + after.tv_usec / 1.0e6) - (before.tv_sec + before.tv_usec / 1.0e6); - move(LINES - 1, COLS - 20); + move(LINES - 1, COLS - 12); printw("Secs: %2.03f", elapsed); refresh(); } @@ -3419,7 +4654,7 @@ padgetch(WINDOW *win) c = KEY_DC; break; case ERR: /* FALLTHRU */ - case 'q': + case_QUIT: count = 0; c = KEY_EXIT; break; @@ -3446,8 +4681,6 @@ static void demo_pad(void) /* Demonstrate pads. */ { - int i, j; - unsigned gridcount = 0; WINDOW *panpad = newpad(PAD_HIGH, PAD_WIDE); if (panpad == 0) { @@ -3455,20 +4688,8 @@ demo_pad(void) return; } - for (i = 0; i < PAD_HIGH; i++) { - for (j = 0; j < PAD_WIDE; j++) - if (i % GRIDSIZE == 0 && j % GRIDSIZE == 0) { - if (i == 0 || j == 0) - waddch(panpad, '+'); - else - waddch(panpad, (chtype) ('A' + (gridcount++ % 26))); - } else if (i % GRIDSIZE == 0) - waddch(panpad, '-'); - else if (j % GRIDSIZE == 0) - waddch(panpad, '|'); - else - waddch(panpad, ' '); - } + fill_pad(panpad, FALSE); + panner_legend(LINES - 4); panner_legend(LINES - 3); panner_legend(LINES - 2); @@ -3486,7 +4707,6 @@ demo_pad(void) endwin(); erase(); } -#endif /* USE_LIBPANEL */ /**************************************************************************** * @@ -3521,7 +4741,7 @@ flushinp_test(WINDOW *win) return; #ifdef A_COLOR - if (has_colors()) { + if (use_colors) { init_pair(2, COLOR_CYAN, COLOR_BLUE); wbkgd(subWin, COLOR_PAIR(2) | ' '); } @@ -3626,7 +4846,19 @@ menu_virtualize(int c) static const char *animals[] = { - "Lions", "Tigers", "Bears", "(Oh my!)", "Newts", "Platypi", "Lemurs", + "Lions", + "Tigers", + "Bears", + "(Oh my!)", + "Newts", + "Platypi", + "Lemurs", + "(Oh really?!)", + "Leopards", + "Panthers", + "Pumas", + "Lions, Tigers, Bears, (Oh my!), Newts, Platypi, Lemurs", + "Lions, Tigers, Bears, (Oh my!), Newts, Platypi, Lemurs, Lions, Tigers, Bears, (Oh my!), Newts, Platypi, Lemurs", (char *) 0 }; @@ -3670,6 +4902,8 @@ menu_test(void) post_menu(m); while ((c = menu_driver(m, menu_virtualize(wGetchar(menuwin)))) != E_UNKNOWN_COMMAND) { + if (c == E_NOT_POSTED) + break; if (c == E_REQUEST_DENIED) beep(); continue; @@ -3695,7 +4929,7 @@ menu_test(void) #define T_TBL(name) { #name, name } static struct { const char *name; - int mask; + unsigned mask; } t_tbl[] = { T_TBL(TRACE_DISABLE), @@ -3720,7 +4954,7 @@ static struct { }; static char * -tracetrace(int tlevel) +tracetrace(unsigned tlevel) { static char *buf; int n; @@ -3792,7 +5026,8 @@ trace_set(void) MENU *m; ITEM *items[SIZEOF(t_tbl)]; ITEM **ip = items; - int mrows, mcols, newtrace; + int mrows, mcols; + unsigned newtrace; int n; WINDOW *menuwin; @@ -3824,7 +5059,7 @@ trace_set(void) post_menu(m); for (ip = menu_items(m); *ip; ip++) { - int mask = t_tbl[item_index(*ip)].mask; + unsigned mask = t_tbl[item_index(*ip)].mask; if (mask == 0) set_item_value(*ip, _nc_tracing == 0); else if ((mask & _nc_tracing) == mask) @@ -3865,11 +5100,11 @@ trace_set(void) static FIELD * make_label(int frow, int fcol, NCURSES_CONST char *label) { - FIELD *f = new_field(1, strlen(label), frow, fcol, 0, 0); + FIELD *f = new_field(1, (int) strlen(label), frow, fcol, 0, 0); if (f) { set_field_buffer(f, 0, label); - set_field_opts(f, field_opts(f) & ~O_ACTIVE); + set_field_opts(f, (int) (field_opts(f) & ~O_ACTIVE)); } return (f); } @@ -3925,13 +5160,14 @@ edit_secure(FIELD * me, int c) if (field_info(me, &rows, &cols, &frow, &fcol, &nrow, &nbuf) == E_OK && nbuf > 0) { + char *source = field_buffer(me, 1); char temp[80]; long len; - strcpy(temp, field_buffer(me, 1)); + strcpy(temp, source ? source : ""); len = (long) (char *) field_userptr(me); if (c <= KEY_MAX) { - if (isgraph(c)) { + if (isgraph(c) && (len + 1) < (int) sizeof(temp)) { temp[len++] = c; temp[len] = 0; set_field_buffer(me, 1, temp); @@ -3981,133 +5217,63 @@ edit_secure(FIELD * me, int c) static int form_virtualize(FORM * f, WINDOW *w) { + /* *INDENT-OFF* */ static const struct { int code; int result; } lookup[] = { - { - CTRL('A'), REQ_NEXT_CHOICE - }, - { - CTRL('B'), REQ_PREV_WORD - }, - { - CTRL('C'), REQ_CLR_EOL - }, - { - CTRL('D'), REQ_DOWN_FIELD - }, - { - CTRL('E'), REQ_END_FIELD - }, - { - CTRL('F'), REQ_NEXT_PAGE - }, - { - CTRL('G'), REQ_DEL_WORD - }, - { - CTRL('H'), REQ_DEL_PREV - }, - { - CTRL('I'), REQ_INS_CHAR - }, - { - CTRL('K'), REQ_CLR_EOF - }, - { - CTRL('L'), REQ_LEFT_FIELD - }, - { - CTRL('M'), REQ_NEW_LINE - }, - { - CTRL('N'), REQ_NEXT_FIELD - }, - { - CTRL('O'), REQ_INS_LINE - }, - { - CTRL('P'), REQ_PREV_FIELD - }, - { - CTRL('R'), REQ_RIGHT_FIELD - }, - { - CTRL('S'), REQ_BEG_FIELD - }, - { - CTRL('U'), REQ_UP_FIELD - }, - { - CTRL('V'), REQ_DEL_CHAR - }, - { - CTRL('W'), REQ_NEXT_WORD - }, - { - CTRL('X'), REQ_CLR_FIELD - }, - { - CTRL('Y'), REQ_DEL_LINE - }, - { - CTRL('Z'), REQ_PREV_CHOICE - }, - { - ESCAPE, MAX_FORM_COMMAND + 1 - }, - { - KEY_BACKSPACE, REQ_DEL_PREV - }, - { - KEY_DOWN, REQ_DOWN_CHAR - }, - { - KEY_END, REQ_LAST_FIELD - }, - { - KEY_HOME, REQ_FIRST_FIELD - }, - { - KEY_LEFT, REQ_LEFT_CHAR - }, - { - KEY_LL, REQ_LAST_FIELD - }, - { - KEY_NEXT, REQ_NEXT_FIELD - }, - { - KEY_NPAGE, REQ_NEXT_PAGE - }, - { - KEY_PPAGE, REQ_PREV_PAGE - }, - { - KEY_PREVIOUS, REQ_PREV_FIELD - }, - { - KEY_RIGHT, REQ_RIGHT_CHAR - }, - { - KEY_UP, REQ_UP_CHAR - }, - { - QUIT, MAX_FORM_COMMAND + 1 - } + { CTRL('A'), REQ_NEXT_CHOICE }, + { CTRL('B'), REQ_PREV_WORD }, + { CTRL('C'), REQ_CLR_EOL }, + { CTRL('D'), REQ_DOWN_FIELD }, + { CTRL('E'), REQ_END_FIELD }, + { CTRL('F'), REQ_NEXT_PAGE }, + { CTRL('G'), REQ_DEL_WORD }, + { CTRL('H'), REQ_DEL_PREV }, + { CTRL('I'), REQ_INS_CHAR }, + { CTRL('K'), REQ_CLR_EOF }, + { CTRL('L'), REQ_LEFT_FIELD }, + { CTRL('M'), REQ_NEW_LINE }, + { CTRL('N'), REQ_NEXT_FIELD }, + { CTRL('O'), REQ_INS_LINE }, + { CTRL('P'), REQ_PREV_FIELD }, + { CTRL('R'), REQ_RIGHT_FIELD }, + { CTRL('S'), REQ_BEG_FIELD }, + { CTRL('U'), REQ_UP_FIELD }, + { CTRL('V'), REQ_DEL_CHAR }, + { CTRL('W'), REQ_NEXT_WORD }, + { CTRL('X'), REQ_CLR_FIELD }, + { CTRL('Y'), REQ_DEL_LINE }, + { CTRL('Z'), REQ_PREV_CHOICE }, + { ESCAPE, MAX_FORM_COMMAND + 1 }, + { KEY_BACKSPACE, REQ_DEL_PREV }, + { KEY_DOWN, REQ_DOWN_CHAR }, + { KEY_END, REQ_LAST_FIELD }, + { KEY_HOME, REQ_FIRST_FIELD }, + { KEY_LEFT, REQ_LEFT_CHAR }, + { KEY_LL, REQ_LAST_FIELD }, + { KEY_NEXT, REQ_NEXT_FIELD }, + { KEY_NPAGE, REQ_NEXT_PAGE }, + { KEY_PPAGE, REQ_PREV_PAGE }, + { KEY_PREVIOUS, REQ_PREV_FIELD }, + { KEY_RIGHT, REQ_RIGHT_CHAR }, + { KEY_UP, REQ_UP_CHAR }, + { QUIT, MAX_FORM_COMMAND + 1 } }; + /* *INDENT-ON* */ static int mode = REQ_INS_MODE; int c = wGetchar(w); unsigned n; FIELD *me = current_field(f); + bool current = TRUE; if (c == CTRL(']')) { - if (mode == REQ_INS_MODE) + if (mode == REQ_INS_MODE) { mode = REQ_OVL_MODE; - else + } else { mode = REQ_INS_MODE; + } c = mode; } else { for (n = 0; n < SIZEOF(lookup); n++) { @@ -4117,15 +5283,38 @@ form_virtualize(FORM * f, WINDOW *w) } } } + mvprintw(0, COLS - 6, "(%s)", mode == REQ_INS_MODE ? "INS" : "OVL"); /* * Force the field that the user is typing into to be in reverse video, * while the other fields are shown underlined. */ - if (c <= KEY_MAX) { + switch (c) { + case REQ_BEG_FIELD: + case REQ_CLR_EOF: + case REQ_CLR_EOL: + case REQ_CLR_FIELD: + case REQ_DEL_CHAR: + case REQ_DEL_LINE: + case REQ_DEL_PREV: + case REQ_DEL_WORD: + case REQ_END_FIELD: + case REQ_INS_CHAR: + case REQ_INS_LINE: + case REQ_LEFT_CHAR: + case REQ_LEFT_FIELD: + case REQ_NEXT_WORD: + case REQ_RIGHT_CHAR: + current = TRUE; + break; + default: + current = (c < KEY_MAX); + break; + } + if (current) { c = edit_secure(me, c); set_field_back(me, A_REVERSE); - } else if (c <= MAX_FORM_COMMAND) { + } else { c = edit_secure(me, c); set_field_back(me, A_UNDERLINE); } @@ -4144,11 +5333,19 @@ my_form_driver(FORM * form, int c) } } +#ifdef NCURSES_VERSION +#define FIELDCHECK_CB(func) bool func(FIELD * fld, const void * data GCC_UNUSED) +#define CHAR_CHECK_CB(func) bool func(int ch, const void *data GCC_UNUSED) +#else +#define FIELDCHECK_CB(func) int func(FIELD * fld, char * data GCC_UNUSED) +#define CHAR_CHECK_CB(func) int func(int ch, char *data GCC_UNUSED) +#endif + /* * Allow a middle initial, optionally with a '.' to end it. */ -static bool -mi_field_check(FIELD * fld, const void *data GCC_UNUSED) +static +FIELDCHECK_CB(mi_field_check) { char *s = field_buffer(fld, 0); int state = 0; @@ -4180,8 +5377,8 @@ mi_field_check(FIELD * fld, const void *data GCC_UNUSED) return TRUE; } -static bool -mi_char_check(int ch, const void *data GCC_UNUSED) +static +CHAR_CHECK_CB(mi_char_check) { return ((isalpha(ch) || ch == '.') ? TRUE : FALSE); } @@ -4189,8 +5386,8 @@ mi_char_check(int ch, const void *data GCC_UNUSED) /* * Passwords should be at least 6 characters. */ -static bool -pw_field_check(FIELD * fld, const void *data GCC_UNUSED) +static +FIELDCHECK_CB(pw_field_check) { char *s = field_buffer(fld, 0); int n; @@ -4204,8 +5401,8 @@ pw_field_check(FIELD * fld, const void *data GCC_UNUSED) return TRUE; } -static bool -pw_char_check(int ch, const void *data GCC_UNUSED) +static +CHAR_CHECK_CB(pw_char_check) { return (isgraph(ch) ? TRUE : FALSE); } @@ -4221,8 +5418,12 @@ demo_forms(void) int finished = 0, c; unsigned n = 0; +#ifdef NCURSES_MOUSE_VERSION + mousemask(ALL_MOUSE_EVENTS, (mmask_t *) 0); +#endif + move(18, 0); - addstr("Defined form-traversal keys: ^Q/ESC- exit form\n"); + addstr("Defined edit/traversal keys: ^Q/ESC- exit form\n"); addstr("^N -- go to next field ^P -- go to previous field\n"); addstr("Home -- go to first field End -- go to last field\n"); addstr("^L -- go to field to left ^R -- go to field to right\n"); @@ -4232,7 +5433,7 @@ demo_forms(void) addstr("^H -- delete previous char ^Y -- delete line\n"); addstr("^G -- delete current word ^C -- clear to end of line\n"); addstr("^K -- clear to end of field ^X -- clear field\n"); - addstr("Arrow keys move within a field as you would expect."); + addstr("Arrow keys move within a field as you would expect. ^] toggles overlay mode."); mvaddstr(4, 57, "Forms Entry Test"); @@ -4290,8 +5491,14 @@ demo_forms(void) free_form(form); for (c = 0; f[c] != 0; c++) free_field(f[c]); + free_fieldtype(fty_middle); + free_fieldtype(fty_passwd); noraw(); nl(); + +#ifdef NCURSES_MOUSE_VERSION + mousemask(ALL_MOUSE_EVENTS, (mmask_t *) 0); +#endif } #endif /* USE_LIBFORM */ @@ -4311,36 +5518,247 @@ fillwin(WINDOW *win, char ch) for (y = 0; y < y1; y++) { wmove(win, y, 0); for (x = 0; x < x1; x++) - waddch(win, ch); + waddch(win, UChar(ch)); + } +} + +static void +crosswin(WINDOW *win, char ch) +{ + int y, x; + int y1, x1; + + 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)))) { + wmove(win, y, x); + waddch(win, UChar(ch)); + } + } +} + +#define OVERLAP_FLAVORS 5 + +static void +overlap_helpitem(int state, int item, char *message) +{ + int row = (item / 2); + int col = ((item % 2) ? COLS / 2 : 0); + + move(LINES - 6 + row, col); + printw("%c%c = %s", state == row ? '>' : ' ', 'a' + item, message); + clrtoeol(); +} + +static void +overlap_test_1_attr(WINDOW *win, int flavor, int col) +{ + short cpair = 1 + (flavor * 2) + col; + + switch (flavor) { + case 0: + wattrset(win, A_NORMAL); + break; + case 1: + wattrset(win, A_BOLD); + break; + case 2: + init_pair(cpair, COLOR_BLUE, COLOR_WHITE); + wattrset(win, COLOR_PAIR(cpair) | A_NORMAL); + break; + case 3: + init_pair(cpair, COLOR_WHITE, COLOR_BLUE); + wattrset(win, COLOR_PAIR(cpair) | A_BOLD); + break; + } +} + +static void +overlap_test_2_attr(WINDOW *win, int flavor, int col) +{ + short cpair = 9 + (flavor * 2) + col; + + switch (flavor) { + case 0: + /* no effect */ + break; + case 1: + /* no effect */ + break; + case 2: + init_pair(cpair, COLOR_RED, COLOR_GREEN); + wbkgdset(win, ' ' | A_BLINK | COLOR_PAIR(cpair)); + break; + case 3: + 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; + char msg[80]; + + if (state < 0) + state += OVERLAP_FLAVORS; + state = 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: + flavors[row] = 0; + sprintf(msg, "refresh %s, then %s, then doupdate.", ths, tht); + break; + case 1: + if (use_colors) { + flavors[row] %= 4; + } else { + flavors[row] %= 2; + } + 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); + break; + case 1: + sprintf(msg, "draw box in window %s.", ths); + break; + case 2: + sprintf(msg, "set background of window %s.", ths); + break; + case 3: + sprintf(msg, "reset background of window %s.", ths); + break; + } + break; + case 3: + 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); + break; + case 1: + sprintf(msg, "copywin(FALSE) %s onto %s.", ths, tht); + break; + case 2: + sprintf(msg, "copywin(TRUE) %s onto %s.", ths, tht); + break; + case 3: + sprintf(msg, "overlay %s onto %s.", ths, tht); + break; + } + break; + } + overlap_helpitem(state, item, msg); + wattrset(stdscr, A_NORMAL); + wbkgdset(stdscr, ' ' | A_NORMAL); + } + move(LINES - 1, 0); + printw("^Q/ESC = terminate test. Up/down/space select test variations (%d %d).", + state, flavors[state]); + + return state; +} + +static void +overlap_test_0(WINDOW *a, WINDOW *b) +{ + touchwin(a); + touchwin(b); + wnoutrefresh(a); + wnoutrefresh(b); + doupdate(); +} + +static void +overlap_test_1(int flavor, int col, WINDOW *a, char fill) +{ + overlap_test_1_attr(a, flavor, col); + fillwin(a, fill); + wattrset(a, A_NORMAL); +} + +static void +overlap_test_2(int flavor, int col, WINDOW *a, char fill) +{ + overlap_test_2_attr(a, flavor, col); + switch (flavor) { + case 0: + crosswin(a, fill); + break; + case 1: + box(a, 0, 0); + break; + case 2: + /* done in overlap_test_2_attr */ + break; + case 3: + /* done in overlap_test_2_attr */ + break; } } static void -crosswin(WINDOW *win, char ch) +overlap_test_3(WINDOW *a) +{ + wclear(a); + wmove(a, 0, 0); +} + +static void +overlap_test_4(int flavor, WINDOW *a, WINDOW *b) { - int y, x; - int y1, x1; - - 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)))) { - wmove(win, y, x); - waddch(win, ch); - } + switch (flavor) { + case 0: + overwrite(a, b); + break; + case 1: + copywin(a, b, 0, 0, 0, 0, getmaxy(b), getmaxx(b), FALSE); + break; + case 2: + copywin(a, b, 0, 0, 0, 0, getmaxy(b), getmaxx(b), TRUE); + break; + case 3: + overlay(a, b); + break; } } +/* test effects of overlapping windows */ static void overlap_test(void) -/* test effects of overlapping windows */ { int ch; + int state, flavor[OVERLAP_FLAVORS]; WINDOW *win1 = newwin(9, 20, 3, 3); WINDOW *win2 = newwin(9, 20, 9, 16); + curs_set(0); raw(); refresh(); move(0, 0); @@ -4348,66 +5766,79 @@ overlap_test(void) 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"); - move(18, 0); - printw("a = refresh A, then B, then doupdate. b = refresh B, then A, then doupdaute\n"); - printw("c = fill window A with letter A. d = fill window B with letter B.\n"); - printw("e = cross pattern in window A. f = cross pattern in window B.\n"); - printw("g = clear window A. h = clear window B.\n"); - printw("i = overwrite A onto B. j = overwrite B onto A.\n"); - printw("^Q/ESC = terminate test."); - - while ((ch = Getchar()) != QUIT && ch != ESCAPE) + memset(flavor, 0, sizeof(flavor)); + state = overlap_help(0, flavor); + + while (!isQuit(ch = Getchar())) switch (ch) { case 'a': /* refresh window A first, then B */ - wnoutrefresh(win1); - wnoutrefresh(win2); - doupdate(); + overlap_test_0(win1, win2); break; case 'b': /* refresh window B first, then A */ - wnoutrefresh(win2); - wnoutrefresh(win1); - doupdate(); + overlap_test_0(win2, win1); break; case 'c': /* fill window A so it's visible */ - fillwin(win1, 'A'); + overlap_test_1(flavor[1], 0, win1, 'A'); break; case 'd': /* fill window B so it's visible */ - fillwin(win2, 'B'); + overlap_test_1(flavor[1], 1, win2, 'B'); break; case 'e': /* cross test pattern in window A */ - crosswin(win1, 'A'); + overlap_test_2(flavor[2], 0, win1, 'A'); break; case 'f': /* cross test pattern in window A */ - crosswin(win2, 'B'); + overlap_test_2(flavor[2], 1, win2, 'B'); break; case 'g': /* clear window A */ - wclear(win1); - wmove(win1, 0, 0); + overlap_test_3(win1); break; case 'h': /* clear window B */ - wclear(win2); - wmove(win2, 0, 0); + overlap_test_3(win2); break; case 'i': /* overwrite A onto B */ - overwrite(win1, win2); + overlap_test_4(flavor[4], win1, win2); break; case 'j': /* overwrite B onto A */ - overwrite(win2, win1); + overlap_test_4(flavor[4], win2, win1); + break; + + case CTRL('n'): + case KEY_DOWN: + state = overlap_help(state + 1, flavor); + break; + + case CTRL('p'): + case KEY_UP: + state = overlap_help(state - 1, flavor); + break; + + case ' ': + flavor[state] += 1; + state = overlap_help(state, flavor); + break; + + case '?': + state = overlap_help(state, flavor); + break; + + default: + beep(); break; } delwin(win2); delwin(win1); erase(); + curs_set(1); endwin(); } @@ -4436,15 +5867,30 @@ do_single_test(const char c) attr_test(); break; +#if USE_WIDEC_SUPPORT + case 'B': + wide_attr_test(); + break; +#endif + case 'c': - if (!has_colors()) + 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 (!has_colors()) + if (!use_colors) Cannot("does not support color."); else if (!can_change_color()) Cannot("has hardwired color values."); @@ -4452,9 +5898,11 @@ do_single_test(const char c) color_edit(); break; +#if USE_SOFTKEYS case 'e': slk_test(); break; +#endif #if USE_WIDEC_SUPPORT case 'E': @@ -4473,7 +5921,13 @@ do_single_test(const char c) #if USE_LIBPANEL case 'o': - demo_panels(); + demo_panels(init_panel, fill_panel); + break; +#endif + +#if USE_WIDEC_SUPPORT + case 'O': + demo_panels(init_wide_panel, fill_wide_panel); break; #endif @@ -4495,11 +5949,9 @@ do_single_test(const char c) break; #endif -#if USE_LIBPANEL case 'p': demo_pad(); break; -#endif #if USE_LIBFORM case 'r': @@ -4539,10 +5991,18 @@ usage(void) ," -a f,b set default-colors (assumed white-on-black)" ," -d use default-colors if terminal supports them" #endif +#if USE_SOFTKEYS ," -e fmt specify format for soft-keys test (e)" +#endif +#if HAVE_RIPOFFLINE ," -f rip-off footer line (can repeat)" ," -h rip-off header line (can repeat)" +#endif + ," -m do not use colors" + ," -p file rgb values to use in 'd' rather than ncurses's builtin" +#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 @@ -4572,13 +6032,14 @@ announce_sig(int sig) } #endif +#if HAVE_RIPOFFLINE static int rip_footer(WINDOW *win, int cols) { wbkgd(win, A_REVERSE); werase(win); wmove(win, 0, 0); - wprintw(win, "footer: %d columns", cols); + wprintw(win, "footer: window %p, %d columns", win, cols); wnoutrefresh(win); return OK; } @@ -4589,19 +6050,133 @@ rip_header(WINDOW *win, int cols) wbkgd(win, A_REVERSE); werase(win); wmove(win, 0, 0); - wprintw(win, "header: %d columns", cols); + wprintw(win, "header: window %p, %d columns", win, cols); wnoutrefresh(win); return OK; } +#endif /* HAVE_RIPOFFLINE */ + +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"); +#endif + (void) puts("c = color test pattern"); +#if USE_WIDEC_SUPPORT + (void) puts("C = color test pattern using wide-character calls"); +#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"); +#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"); +#endif +#if USE_LIBPANEL + (void) puts("o = exercise panels library"); +#if USE_WIDEC_SUPPORT + (void) puts("O = exercise panels with wide-characters"); +#endif +#endif + (void) puts("p = exercise pad features"); + (void) puts("q = quit"); +#if USE_LIBFORM + (void) puts("r = exercise forms code"); +#endif + (void) puts("s = overlapping-refresh test"); +#if USE_LIBMENU && defined(TRACE) + (void) puts("t = set trace level"); +#endif + (void) puts("? = repeat this command summary"); + + (void) fputs("> ", stdout); + (void) fflush(stdout); /* necessary under SVr4 curses */ + + /* + * This used to be an 'fgets()' call. However (on Linux, at least) + * mixing stream I/O and 'read()' (used in the library) causes the + * input stream to be flushed when switching between the two. + */ + command = 0; + for (;;) { + char ch; + if (read(fileno(stdin), &ch, 1) <= 0) { + if (command == 0) + command = 'q'; + break; + } else if (command == 0 && !isspace(UChar(ch))) { + command = ch; + } else if (ch == '\n' || ch == '\r') { + if ((command == 'd') && !top) { + (void) fputs("Do not nest test-d\n", stdout); + command = 0; + } + if (command != 0) + break; + (void) fputs("> ", stdout); + (void) fflush(stdout); + } + } + + if (do_single_test(command)) { + /* + * This may be overkill; it's intended to reset everything back + * to the initial terminal modes so that tests don't get in + * each other's way. + */ + flushinp(); + set_terminal_modes(); + reset_prog_mode(); + clear(); + refresh(); + endwin(); + if (command == '?') { + (void) puts("This is the ncurses capability tester."); + (void) + puts("You may select a test from the main menu by typing the"); + (void) + puts("key letter of the choice (the letter to left of the =)"); + (void) + puts("at the > prompt. Type `q' to exit."); + } + continue; + } + } while + (command != 'q'); +} /*+------------------------------------------------------------------------- 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 command, c; + int c; int my_e_param = 1; #ifdef NCURSES_VERSION int default_fg = COLOR_WHITE; @@ -4609,10 +6184,12 @@ main(int argc, char *argv[]) bool assumed_colors = FALSE; bool default_colors = FALSE; #endif + char *palette_file = 0; + bool monochrome = FALSE; setlocale(LC_ALL, ""); - while ((c = getopt(argc, argv, "a:de:fhs:t:")) != EOF) { + while ((c = getopt(argc, argv, "a:de:fhmp:s:t:")) != -1) { switch (c) { #ifdef NCURSES_VERSION case 'a': @@ -4633,12 +6210,20 @@ main(int argc, char *argv[]) usage(); #endif break; +#if HAVE_RIPOFFLINE case 'f': ripoffline(-1, rip_footer); break; case 'h': ripoffline(1, rip_header); break; +#endif /* HAVE_RIPOFFLINE */ + case 'm': + monochrome = TRUE; + break; + case 'p': + palette_file = optarg; + break; #if USE_LIBPANEL case 's': nap_msec = atol(optarg); @@ -4646,7 +6231,7 @@ main(int argc, char *argv[]) #endif #ifdef TRACE case 't': - save_trace = atoi(optarg); + save_trace = strtol(optarg, 0, 0); break; #endif default: @@ -4669,8 +6254,10 @@ main(int argc, char *argv[]) #endif /* USE_LIBMENU */ #endif /* TRACE */ +#if USE_SOFTKEYS /* tell it we're going to play with soft keys */ slk_init(my_e_param); +#endif #ifdef SIGUSR1 /* set up null signal catcher so we can see what interrupts to getch do */ @@ -4682,24 +6269,63 @@ main(int argc, char *argv[]) bkgdset(BLANK); /* tests, in general, will want these modes */ - if (has_colors()) { + use_colors = monochrome ? FALSE : has_colors(); + + if (use_colors) { start_color(); #ifdef NCURSES_VERSION_PATCH - max_colors = COLORS > 16 ? 16 : COLORS; + max_colors = COLORS; /* was > 16 ? 16 : COLORS */ #if HAVE_USE_DEFAULT_COLORS - if (default_colors) + if (default_colors) { use_default_colors(); + min_colors = -1; + } #if NCURSES_VERSION_PATCH >= 20000708 else if (assumed_colors) assume_default_colors(default_fg, default_bg); #endif #endif #else /* normal SVr4 curses */ - max_colors = COLORS > 8 ? 8 : COLORS; + max_colors = COLORS; /* was > 8 ? 8 : COLORS */ #endif - max_pairs = (max_colors * max_colors); - if (max_pairs < COLOR_PAIRS) - max_pairs = COLOR_PAIRS; + max_pairs = COLOR_PAIRS; /* was > 256 ? 256 : COLOR_PAIRS */ + + if (can_change_color()) { + short cp; + all_colors = (RGB_DATA *) malloc(max_colors * sizeof(RGB_DATA)); + 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)) { + all_colors[c].red = (red * 1000) / scale; + all_colors[c].green = (green * 1000) / scale; + all_colors[c].blue = (blue * 1000) / scale; + } + } + fclose(fp); + } + } + } } set_terminal_modes(); def_prog_mode(); @@ -4721,93 +6347,7 @@ main(int argc, char *argv[]) (void) puts("Welcome to ncurses. Press ? for help."); #endif - do { - (void) puts("This is the ncurses main menu"); - (void) puts("a = keyboard and mouse input test"); -#if USE_WIDEC_SUPPORT - (void) puts("A = wide-character keyboard and mouse input test"); -#endif - (void) puts("b = character attribute test"); - (void) puts("c = color test pattern"); - (void) puts("d = edit RGB color values"); - (void) puts("e = exercise soft keys"); -#if USE_WIDEC_SUPPORT - (void) puts("E = exercise soft keys using wide-characters"); -#endif - (void) puts("f = display ACS characters"); -#if USE_WIDEC_SUPPORT - (void) puts("F = display Wide-ACS characters"); -#endif - (void) puts("g = display windows and scrolling"); - (void) puts("i = test of flushinp()"); - (void) puts("k = display character attributes"); -#if USE_LIBMENU - (void) puts("m = menu code test"); -#endif -#if USE_LIBPANEL - (void) puts("o = exercise panels library"); - (void) puts("p = exercise pad features"); - (void) puts("q = quit"); -#endif -#if USE_LIBFORM - (void) puts("r = exercise forms code"); -#endif - (void) puts("s = overlapping-refresh test"); -#if USE_LIBMENU && defined(TRACE) - (void) puts("t = set trace level"); -#endif - (void) puts("? = repeat this command summary"); - - (void) fputs("> ", stdout); - (void) fflush(stdout); /* necessary under SVr4 curses */ - - /* - * This used to be an 'fgets()' call. However (on Linux, at least) - * mixing stream I/O and 'read()' (used in the library) causes the - * input stream to be flushed when switching between the two. - */ - command = 0; - for (;;) { - char ch; - if (read(fileno(stdin), &ch, 1) <= 0) { - if (command == 0) - command = 'q'; - break; - } else if (command == 0 && !isspace(UChar(ch))) { - command = ch; - } else if (ch == '\n' || ch == '\r') { - if (command != 0) - break; - (void) fputs("> ", stdout); - (void) fflush(stdout); - } - } - - if (do_single_test(command)) { - /* - * This may be overkill; it's intended to reset everything back - * to the initial terminal modes so that tests don't get in - * each other's way. - */ - flushinp(); - set_terminal_modes(); - reset_prog_mode(); - clear(); - refresh(); - endwin(); - if (command == '?') { - (void) puts("This is the ncurses capability tester."); - (void) - puts("You may select a test from the main menu by typing the"); - (void) - puts("key letter of the choice (the letter to left of the =)"); - (void) - puts("at the > prompt. The commands `x' or `q' will exit."); - } - continue; - } - } while - (command != 'q'); + main_menu(TRUE); ExitProgram(EXIT_SUCCESS); }