/****************************************************************************
- * Copyright (c) 1998-2011,2012 Free Software Foundation, Inc. *
+ * Copyright (c) 1998-2013,2014 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
Author: Eric S. Raymond <esr@snark.thyrsus.com> 1993
Thomas E. Dickey (beginning revision 1.27 in 1996).
-$Id: ncurses.c,v 1.371 2012/06/09 20:30:32 tom Exp $
+$Id: ncurses.c,v 1.416 2014/08/16 23:30:20 tom Exp $
***************************************************************************/
static int max_pairs; /* ...and the number of color pairs */
typedef struct {
- short red;
- short green;
- short blue;
+ NCURSES_COLOR_T red;
+ NCURSES_COLOR_T green;
+ NCURSES_COLOR_T blue;
} RGB_DATA;
static RGB_DATA *all_colors;
static void main_menu(bool);
+static void
+failed(const char *s)
+{
+ perror(s);
+ endwin();
+ ExitProgram(EXIT_FAILURE);
+}
+
/* The behavior of mvhline, mvvline for negative/zero length is unspecified,
* though we can rely on negative x/y values to stop the macro.
*/
#if USE_WIDEC_SUPPORT
static wchar_t
-fullwidth_of(int ch)
+fullwidth_digit(int ch)
{
- return (ch + 0xff10 - '0');
+ return (wchar_t) (ch + 0xff10 - '0');
}
static void
{
int ch;
while ((ch = *source++) != 0) {
- *target++ = fullwidth_of(ch);
+ *target++ = fullwidth_digit(ch);
}
*target = 0;
}
{
int ch;
while ((ch = *source++) != 0) {
- *target++ = ch;
+ *target++ = (wchar_t) ch;
}
*target = 0;
}
{
wchar_t source[2];
- source[0] = fullwidth_of(digit + '0');
+ source[0] = fullwidth_digit(digit + '0');
source[1] = 0;
setcchar(target, source, A_NORMAL, 0, 0);
}
len_winstack = need;
winstack = typeRealloc(WINSTACK, len_winstack, winstack);
}
+ if (!winstack)
+ failed("remember_boxes");
winstack[level].text = txt_win;
winstack[level].frame = box_win;
}
#define remember_boxes(level,text,frame) /* nothing */
#endif
+/*
+ * Return-code is OK/ERR or a keyname.
+ */
+static const char *
+ok_keyname(int code)
+{
+ return ((code == OK) ? "OK" : ((code == ERR) ? "ERR" : keyname(code)));
+}
+
static void
wgetch_test(unsigned level, WINDOW *win, int delay)
{
} else if (c == 'g') {
waddstr(win, "getstr test: ");
echo();
- wgetnstr(win, buf, sizeof(buf) - 1);
+ c = wgetnstr(win, buf, sizeof(buf) - 1);
noecho();
- wprintw(win, "I saw %d characters:\n\t`%s'.", (int) strlen(buf), buf);
+ wprintw(win, "I saw %d characters:\n\t`%s' (%s).",
+ (int) strlen(buf), buf,
+ ok_keyname(c));
wclrtoeol(win);
wgetch_wrap(win, first_y);
} else if (c == 'k') {
free(result);
result = 0;
}
+ } else {
+ failed("wcstos");
}
}
return result;
} else if (c == 'g') {
waddstr(win, "getstr test: ");
echo();
- code = wgetn_wstr(win, wint_buf, sizeof(wint_buf) - 1);
+ code = wgetn_wstr(win, wint_buf, BUFSIZ - 1);
noecho();
if (code == ERR) {
wprintw(win, "wgetn_wstr returns an error.");
#define termattrs() my_termattrs()
#endif
-#define MAX_ATTRSTRING 31
-#define LEN_ATTRSTRING 26
+#define ATTRSTRING_1ST 32 /* ' ' */
+#define ATTRSTRING_END 126 /* '~' */
+
+#define COL_ATTRSTRING 25
+#define MARGIN_4_ATTRS (COL_ATTRSTRING + 8)
+#define LEN_ATTRSTRING (COLS - MARGIN_4_ATTRS)
+#define MAX_ATTRSTRING (ATTRSTRING_END + 1 - ATTRSTRING_1ST)
static char attr_test_string[MAX_ATTRSTRING + 1];
" a/A toggle ACS (alternate character set) mapping");
MvWPrintw(helpwin, row, col,
" v/V toggle video attribute to combine with each line");
+#if USE_WIDEC_SUPPORT
+ MvWPrintw(helpwin, row, col,
+ " w/W toggle normal/wide (double-width) test-characters");
+#endif
}
static void
}
static bool
-cycle_color_attr(int ch, short *fg, short *bg, short *tx)
+cycle_color_attr(int ch, NCURSES_COLOR_T *fg, NCURSES_COLOR_T *bg, NCURSES_COLOR_T *tx)
{
bool error = FALSE;
if (use_colors) {
switch (ch) {
case 'f':
- *fg = (short) (*fg + 1);
+ *fg = (NCURSES_COLOR_T) (*fg + 1);
break;
case 'F':
- *fg = (short) (*fg - 1);
+ *fg = (NCURSES_COLOR_T) (*fg - 1);
break;
case 'b':
- *bg = (short) (*bg + 1);
+ *bg = (NCURSES_COLOR_T) (*bg + 1);
break;
case 'B':
- *bg = (short) (*bg - 1);
+ *bg = (NCURSES_COLOR_T) (*bg - 1);
break;
case 't':
- *tx = (short) (*tx + 1);
+ *tx = (NCURSES_COLOR_T) (*tx + 1);
break;
case 'T':
- *tx = (short) (*tx - 1);
+ *tx = (NCURSES_COLOR_T) (*tx - 1);
break;
default:
beep();
break;
}
if (*fg >= COLORS)
- *fg = (short) min_colors;
+ *fg = (NCURSES_COLOR_T) min_colors;
if (*fg < min_colors)
- *fg = (short) (COLORS - 1);
+ *fg = (NCURSES_COLOR_T) (COLORS - 1);
if (*bg >= COLORS)
- *bg = (short) min_colors;
+ *bg = (NCURSES_COLOR_T) min_colors;
if (*bg < min_colors)
- *bg = (short) (COLORS - 1);
+ *bg = (NCURSES_COLOR_T) (COLORS - 1);
if (*tx >= COLORS)
*tx = -1;
if (*tx < -1)
- *tx = (short) (COLORS - 1);
+ *tx = (NCURSES_COLOR_T) (COLORS - 1);
} else {
beep();
error = TRUE;
static void
adjust_attr_string(int adjust)
{
- int first = ((int) UChar(attr_test_string[0])) + adjust;
- int last = first + LEN_ATTRSTRING;
+ char save = attr_test_string[0];
+ int first = ((int) UChar(save)) + adjust;
+ int j, k;
- if (first >= ' ' && last <= '~') { /* 32..126 */
- int j, k;
- for (j = 0, k = first; j < MAX_ATTRSTRING && k <= last; ++j, ++k) {
+ if (first >= ATTRSTRING_1ST) {
+ for (j = 0, k = first; j < MAX_ATTRSTRING; ++j, ++k) {
+ if (k > ATTRSTRING_END)
+ break;
attr_test_string[j] = (char) k;
if (((k + 1 - first) % 5) == 0) {
if (++j >= MAX_ATTRSTRING)
attr_test_string[j] = ' ';
}
}
- while (j < MAX_ATTRSTRING)
- attr_test_string[j++] = ' ';
- attr_test_string[j] = '\0';
- } else {
- beep();
+ if ((LEN_ATTRSTRING - j) > 5) {
+ attr_test_string[0] = save;
+ adjust_attr_string(adjust - 1);
+ } else {
+ while (j < MAX_ATTRSTRING)
+ attr_test_string[j++] = ' ';
+ attr_test_string[j] = '\0';
+ }
}
}
+/*
+ * Prefer the right-end of the string for starting, since that maps to the
+ * VT100 line-drawing.
+ */
+static int
+default_attr_string(void)
+{
+ int result = (ATTRSTRING_END - LEN_ATTRSTRING);
+ result += (LEN_ATTRSTRING / 5);
+ if (result < ATTRSTRING_1ST)
+ result = ATTRSTRING_1ST;
+ return result;
+}
+
static void
init_attr_string(void)
{
- attr_test_string[0] = 'a';
+ attr_test_string[0] = (char) default_attr_string();
adjust_attr_string(0);
}
static int
-show_attr(int row, int skip, bool arrow, chtype attr, const char *name)
+show_attr(WINDOW *win, int row, int skip, bool arrow, chtype attr, const char *name)
{
int ncv = get_ncv();
chtype test = attr & (chtype) (~A_ALTCHARSET);
if (arrow)
MvPrintw(row, 5, "-->");
MvPrintw(row, 8, "%s mode:", name);
- MvPrintw(row, 24, "|");
+ MvPrintw(row, COL_ATTRSTRING - 1, "|");
if (skip)
printw("%*s", skip, " ");
/*
* character at a time (to pass its rendition directly), and use the
* string operation for the other attributes.
*/
+ wmove(win, 0, 0);
+ werase(win);
if (attr & A_ALTCHARSET) {
const char *s;
chtype ch;
for (s = attr_test_string; *s != '\0'; ++s) {
ch = UChar(*s);
- addch(ch | attr);
+ (void) waddch(win, ch | attr);
}
} else {
- (void) attrset(attr);
- addstr(attr_test_string);
- attroff(attr);
+ (void) wattrset(win, AttrArg(attr, 0));
+ (void) waddstr(win, attr_test_string);
+ (void) wattroff(win, (int) attr);
}
if (skip)
printw("%*s", skip, " ");
- printw("|");
+ MvPrintw(row, COL_ATTRSTRING + LEN_ATTRSTRING, "|");
if (test != A_NORMAL) {
if (!(termattrs() & test)) {
printw(" (N/A)");
A_BOLD,
#ifdef A_INVIS
A_INVIS,
+#endif
+#ifdef A_ITALIC
+ A_ITALIC,
#endif
A_PROTECT,
A_ALTCHARSET
}
return row + 2;
}
+
+typedef struct {
+ attr_t attr;
+ NCURSES_CONST char *name;
+} ATTR_TBL;
/* *INDENT-OFF* */
-static const struct {
- chtype attr;
- NCURSES_CONST char * name;
-} attrs_to_test[] = {
+static const ATTR_TBL attrs_to_test[] = {
{ A_STANDOUT, "STANDOUT" },
{ A_REVERSE, "REVERSE" },
{ A_BOLD, "BOLD" },
{ A_PROTECT, "PROTECT" },
#ifdef A_INVIS
{ A_INVIS, "INVISIBLE" },
+#endif
+#ifdef A_ITALIC
+ { A_ITALIC, "ITALIC" },
#endif
{ A_NORMAL, "NORMAL" },
};
/* *INDENT-ON* */
+static unsigned
+init_attr_list(ATTR_TBL * target, attr_t attrs)
+{
+ unsigned result = 0;
+ size_t n;
+
+ for (n = 0; n < SIZEOF(attrs_to_test); ++n) {
+ attr_t test = attrs_to_test[n].attr;
+ if (test == A_NORMAL || (test & attrs) != 0) {
+ target[result++] = attrs_to_test[n];
+ }
+ }
+ return result;
+}
+
static bool
-attr_getc(int *skip, short *fg, short *bg, short *tx, int *ac, unsigned *kc)
+attr_getc(int *skip,
+ NCURSES_COLOR_T *fg,
+ NCURSES_COLOR_T *bg,
+ NCURSES_COLOR_T *tx,
+ int *ac,
+ unsigned *kc,
+ unsigned limit)
{
bool result = TRUE;
bool error = FALSE;
break;
case 'v':
if (*kc == 0)
- *kc = SIZEOF(attrs_to_test) - 1;
+ *kc = limit - 1;
else
*kc -= 1;
break;
case 'V':
*kc += 1;
- if (*kc >= SIZEOF(attrs_to_test))
+ if (*kc >= limit)
*kc = 0;
break;
case '<':
{
int n;
int skip = get_xmc();
- short fg = COLOR_BLACK; /* color pair 0 is special */
- short bg = COLOR_BLACK;
- short tx = -1;
+ NCURSES_COLOR_T fg = COLOR_BLACK; /* color pair 0 is special */
+ NCURSES_COLOR_T bg = COLOR_BLACK;
+ NCURSES_COLOR_T tx = -1;
int ac = 0;
unsigned j, k;
+ WINDOW *my_wins[SIZEOF(attrs_to_test)];
+ ATTR_TBL my_list[SIZEOF(attrs_to_test)];
+ unsigned my_size = init_attr_list(my_list, termattrs());
+
+ if (my_size > 1) {
+ for (j = 0; j < my_size; ++j) {
+ my_wins[j] = subwin(stdscr,
+ 1, LEN_ATTRSTRING,
+ 2 + (int) (2 * j), COL_ATTRSTRING);
+ scrollok(my_wins[j], FALSE);
+ }
- if (skip < 0)
- skip = 0;
+ if (skip < 0)
+ skip = 0;
- n = skip; /* make it easy */
- k = SIZEOF(attrs_to_test) - 1;
- init_attr_string();
+ n = skip; /* make it easy */
+ k = my_size - 1;
+ init_attr_string();
- do {
- int row = 2;
- chtype normal = A_NORMAL | BLANK;
- chtype extras = (chtype) ac;
+ do {
+ int row = 2;
+ chtype normal = A_NORMAL | BLANK;
+ chtype extras = (chtype) ac;
- if (use_colors) {
- short pair = (short) (fg != COLOR_BLACK || bg != COLOR_BLACK);
- if (pair != 0) {
- pair = 1;
- if (init_pair(pair, fg, bg) == ERR) {
- beep();
- } else {
- normal |= (chtype) COLOR_PAIR(pair);
+ if (use_colors) {
+ NCURSES_PAIRS_T pair = 0;
+ if ((fg != COLOR_BLACK) || (bg != COLOR_BLACK)) {
+ pair = 1;
+ if (init_pair(pair, fg, bg) == ERR) {
+ beep();
+ } else {
+ normal |= (chtype) COLOR_PAIR(pair);
+ }
}
- }
- if (tx >= 0) {
- pair = 2;
- if (init_pair(pair, tx, bg) == ERR) {
- beep();
- } else {
- extras |= (chtype) COLOR_PAIR(pair);
+ if (tx >= 0) {
+ pair = 2;
+ if (init_pair(pair, tx, bg) == ERR) {
+ beep();
+ } else {
+ extras |= (chtype) COLOR_PAIR(pair);
+ normal &= ~A_COLOR;
+ }
}
}
- }
- bkgd(normal);
- bkgdset(normal);
- erase();
-
- box(stdscr, 0, 0);
- MvAddStr(0, 20, "Character attribute test display");
+ bkgd(normal);
+ bkgdset(normal);
+ erase();
- 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);
- }
+ box(stdscr, 0, 0);
+ MvAddStr(0, 20, "Character attribute test display");
+
+ for (j = 0; j < my_size; ++j) {
+ bool arrow = (j == k);
+ row = show_attr(my_wins[j], row, n, arrow,
+ normal |
+ extras |
+ my_list[j].attr |
+ my_list[k].attr,
+ my_list[j].name);
+ }
- MvPrintw(row, 8,
- "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);
+ 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 (attr_getc(&n, &fg, &bg, &tx, &ac, &k));
+ refresh();
+ } while (attr_getc(&n, &fg, &bg, &tx, &ac, &k, my_size));
- bkgdset(A_NORMAL | BLANK);
- erase();
- endwin();
+ bkgdset(A_NORMAL | BLANK);
+ erase();
+ endwin();
+ } else {
+ Cannot("does not support video attributes.");
+ }
}
#if USE_WIDEC_SUPPORT
+static bool use_fullwidth;
static wchar_t wide_attr_test_string[MAX_ATTRSTRING + 1];
+#define FULL_LO 0xff00
+#define FULL_HI 0xff5e
+#define HALF_LO 0x20
+
+#define isFullWidth(ch) ((int)(ch) >= FULL_LO && (int)(ch) <= FULL_HI)
+#define ToNormalWidth(ch) (wchar_t) (((int)(ch) - FULL_LO) + HALF_LO)
+#define ToFullWidth(ch) (wchar_t) (((int)(ch) - HALF_LO) + FULL_LO)
+
+/*
+ * Returns an ASCII code in [32..126]
+ */
+static wchar_t
+normal_wchar(int ch)
+{
+ wchar_t result = (wchar_t) ch;
+ if (isFullWidth(ch))
+ result = ToNormalWidth(ch);
+ return result;
+}
+
+/*
+ * Returns either an ASCII code in in [32..126] or full-width in
+ * [0xff00..0xff5e], according to use_fullwidth setting.
+ */
+static wchar_t
+target_wchar(int ch)
+{
+ wchar_t result = (wchar_t) ch;
+ if (use_fullwidth) {
+ if (!isFullWidth(ch))
+ result = ToFullWidth(ch);
+ } else {
+ if (isFullWidth(ch))
+ result = ToNormalWidth(ch);
+ }
+ return result;
+}
+
static void
wide_adjust_attr_string(int adjust)
{
- int first = ((int) UChar(wide_attr_test_string[0])) + adjust;
- int last = first + LEN_ATTRSTRING;
+ wchar_t save = wide_attr_test_string[0];
+ int first = ((int) normal_wchar(save)) + adjust;
+ int j, k;
- 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 (first >= ATTRSTRING_1ST) {
+ for (j = 0, k = first; j < MAX_ATTRSTRING; ++j, ++k) {
+ if (k > ATTRSTRING_END)
+ break;
+ wide_attr_test_string[j] = target_wchar(k);
if (((k + 1 - first) % 5) == 0) {
if (++j >= MAX_ATTRSTRING)
break;
wide_attr_test_string[j] = ' ';
}
}
- while (j < MAX_ATTRSTRING)
- wide_attr_test_string[j++] = ' ';
- wide_attr_test_string[j] = '\0';
- } else {
- beep();
+ if ((LEN_ATTRSTRING - j) > 5) {
+ wide_attr_test_string[0] = save;
+ wide_adjust_attr_string(adjust - 1);
+ } else {
+ while (j < MAX_ATTRSTRING)
+ wide_attr_test_string[j++] = ' ';
+ wide_attr_test_string[j] = '\0';
+ }
}
}
static void
wide_init_attr_string(void)
{
- wide_attr_test_string[0] = 'a';
+ use_fullwidth = FALSE;
+ wide_attr_test_string[0] = (wchar_t) default_attr_string();
wide_adjust_attr_string(0);
}
static void
-set_wide_background(short pair)
+set_wide_background(NCURSES_PAIRS_T pair)
{
cchar_t normal;
wchar_t blank[2];
attr_t result = A_NORMAL;
attr_t attr;
cchar_t ch;
- short pair;
+ NCURSES_PAIRS_T pair;
wchar_t wch[10];
+ memset(&ch, 0, sizeof(ch));
if (getbkgrnd(&ch) != ERR) {
if (getcchar(&ch, wch, &attr, &pair, 0) != ERR) {
result = attr;
}
static int
-wide_show_attr(int row, int skip, bool arrow, chtype attr, short pair, const char *name)
+wide_show_attr(WINDOW *win,
+ int row,
+ int skip,
+ bool arrow,
+ chtype attr,
+ NCURSES_PAIRS_T pair,
+ const char *name)
{
int ncv = get_ncv();
chtype test = attr & ~WA_ALTCHARSET;
if (arrow)
MvPrintw(row, 5, "-->");
MvPrintw(row, 8, "%s mode:", name);
- MvPrintw(row, 24, "|");
+ MvPrintw(row, COL_ATTRSTRING - 1, "|");
if (skip)
printw("%*s", skip, " ");
* character at a time (to pass its rendition directly), and use the
* string operation for the other attributes.
*/
+ wmove(win, 0, 0);
+ werase(win);
if (attr & WA_ALTCHARSET) {
const wchar_t *s;
cchar_t ch;
fill[0] = *s;
fill[1] = L'\0';
setcchar(&ch, fill, attr, pair, 0);
- add_wch(&ch);
+ (void) wadd_wch(win, &ch);
}
} else {
attr_t old_attr = 0;
- short old_pair = 0;
+ NCURSES_PAIRS_T old_pair = 0;
- (void) attr_get(&old_attr, &old_pair, 0);
- (void) attr_set(attr, pair, 0);
- addwstr(wide_attr_test_string);
- (void) attr_set(old_attr, old_pair, 0);
+ (void) (wattr_get) (win, &old_attr, &old_pair, 0);
+ (void) wattr_set(win, attr, pair, 0);
+ (void) waddwstr(win, wide_attr_test_string);
+ (void) wattr_set(win, old_attr, old_pair, 0);
}
if (skip)
printw("%*s", skip, " ");
- printw("|");
+ MvPrintw(row, COL_ATTRSTRING + LEN_ATTRSTRING, "|");
if (test != A_NORMAL) {
if (!(term_attrs() & test)) {
printw(" (N/A)");
}
static bool
-wide_attr_getc(int *skip, short *fg, short *bg, short *tx, int *ac, unsigned *kc)
+wide_attr_getc(int *skip,
+ NCURSES_COLOR_T *fg, NCURSES_COLOR_T *bg,
+ NCURSES_COLOR_T *tx, int *ac,
+ unsigned *kc, unsigned limit)
{
bool result = TRUE;
bool error = FALSE;
break;
case 'v':
if (*kc == 0)
- *kc = SIZEOF(attrs_to_test) - 1;
+ *kc = limit - 1;
else
*kc -= 1;
break;
case 'V':
*kc += 1;
- if (*kc >= SIZEOF(attrs_to_test))
+ if (*kc >= limit)
*kc = 0;
break;
+ case 'w':
+ use_fullwidth = FALSE;
+ wide_adjust_attr_string(0);
+ break;
+ case 'W':
+ use_fullwidth = TRUE;
+ wide_adjust_attr_string(0);
+ break;
case '<':
wide_adjust_attr_string(-1);
break;
{
int n;
int skip = get_xmc();
- short fg = COLOR_BLACK; /* color pair 0 is special */
- short bg = COLOR_BLACK;
- short tx = -1;
+ NCURSES_COLOR_T fg = COLOR_BLACK; /* color pair 0 is special */
+ NCURSES_COLOR_T bg = COLOR_BLACK;
+ NCURSES_COLOR_T tx = -1;
int ac = 0;
unsigned j, k;
+ ATTR_TBL my_list[SIZEOF(attrs_to_test)];
+ WINDOW *my_wins[SIZEOF(attrs_to_test)];
+ unsigned my_size = init_attr_list(my_list, term_attrs());
+
+ if (my_size > 1) {
+ for (j = 0; j < my_size; ++j) {
+ my_wins[j] = subwin(stdscr,
+ 1, LEN_ATTRSTRING,
+ 2 + (int) (2 * j), COL_ATTRSTRING);
+ scrollok(my_wins[j], FALSE);
+ }
- if (skip < 0)
- skip = 0;
+ if (skip < 0)
+ skip = 0;
- n = skip; /* make it easy */
- k = SIZEOF(attrs_to_test) - 1;
- wide_init_attr_string();
+ n = skip; /* make it easy */
+ k = my_size - 1;
+ wide_init_attr_string();
- do {
- int row = 2;
- short pair = 0;
- short extras = 0;
+ do {
+ int row = 2;
+ NCURSES_PAIRS_T pair = 0;
+ NCURSES_PAIRS_T extras = 0;
- if (use_colors) {
- pair = (short) (fg != COLOR_BLACK || bg != COLOR_BLACK);
- if (pair != 0) {
- pair = 1;
- if (init_pair(pair, fg, bg) == ERR) {
- beep();
+ if (use_colors) {
+ pair = (NCURSES_PAIRS_T) (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();
+ extras = pair;
+ if (tx >= 0) {
+ extras = 2;
+ if (init_pair(extras, tx, bg) == ERR) {
+ beep();
+ }
}
}
- }
- set_wide_background(pair);
- erase();
+ set_wide_background(pair);
+ erase();
- box_set(stdscr, 0, 0);
- MvAddStr(0, 20, "Character attribute test display");
+ 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,
- ((attr_t) ac |
- attrs_to_test[j].attr |
- attrs_to_test[k].attr),
- extras,
- attrs_to_test[j].name);
- }
+ for (j = 0; j < my_size; ++j) {
+ row = wide_show_attr(my_wins[j], row, n, (j == k),
+ ((attr_t) ac |
+ my_list[j].attr |
+ my_list[k].attr),
+ extras,
+ my_list[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);
+ 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));
+ refresh();
+ } while (wide_attr_getc(&n, &fg, &bg, &tx, &ac, &k, my_size));
- set_wide_background(0);
- erase();
- endwin();
+ set_wide_background(0);
+ erase();
+ endwin();
+ } else {
+ Cannot("does not support extended video attributes.");
+ }
}
#endif
} else if (color < 0) {
strcpy(temp, "default");
} else {
- strcpy(temp, the_color_names[color]);
+ sprintf(temp, "%.*s", 16, the_color_names[color]);
}
printw("%-*.*s", width, width, temp);
}
" a/A toggle altcharset off/on");
MvWPrintw(helpwin, row++, col,
" b/B toggle bold off/on");
+ if (has_colors()) {
+ MvWPrintw(helpwin, row++, col,
+ " c/C cycle used-colors through 8,16,...,COLORS");
+ }
MvWPrintw(helpwin, row++, col,
" n/N toggle text/number on/off");
MvWPrintw(helpwin, row++, col,
#define set_color_test(name, value) if (name != value) { name = value; base_row = 0; }
+static int
+color_cycle(int current, int step)
+{
+ int result = current;
+ if (step < 0) {
+ if (current <= 8) {
+ result = COLORS;
+ } else {
+ result = 8;
+ if ((result * 2) > COLORS) {
+ result = COLORS;
+ } else {
+ while ((result * 2) < current) {
+ result *= 2;
+ }
+ }
+ }
+ } else {
+ if (current >= COLORS) {
+ result = 8;
+ } else {
+ result *= 2;
+ }
+ if (result > COLORS)
+ result = COLORS;
+ }
+ return result;
+}
+
/* generate a color test pattern */
static void
color_test(void)
{
- short i;
+ NCURSES_PAIRS_T 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 pairs_max;
+ int colors_max = COLORS;
int row_limit;
int per_row;
char numbered[80];
bool opt_wide = FALSE;
WINDOW *helpwin;
- if (COLORS * COLORS == COLOR_PAIRS) {
- int limit = (COLORS - min_colors) * (COLORS - min_colors);
- if (pairs_max > limit)
- pairs_max = limit;
- } else {
- if (pairs_max > COLOR_PAIRS)
- pairs_max = COLOR_PAIRS;
- }
-
while (!done) {
int shown = 0;
+ pairs_max = PAIR_NUMBER(A_COLOR) + 1;
+ if (colors_max * colors_max <= COLOR_PAIRS) {
+ int limit = (colors_max - min_colors) * (colors_max - min_colors);
+ if (pairs_max > limit)
+ pairs_max = limit;
+ } else {
+ if (pairs_max > COLOR_PAIRS)
+ pairs_max = COLOR_PAIRS;
+ }
+
/* this assumes an 80-column line */
if (opt_wide) {
width = 4;
hello = "Test";
- per_row = (COLORS > 8) ? 16 : 8;
+ per_row = (colors_max > 8) ? 16 : 8;
} else {
width = 8;
hello = "Hello";
row_limit = (pairs_max + per_row - 1) / per_row;
move(0, 0);
- (void) printw("There are %d color pairs and %d colors%s\n",
- pairs_max, COLORS,
- min_colors ? " besides 'default'" : "");
+ (void) printw("There are %d color pairs and %d colors",
+ pairs_max, COLORS);
+ if (colors_max != COLORS)
+ (void) printw(" (using %d colors)", colors_max);
+ if (min_colors)
+ (void) addstr(" besides 'default'");
clrtobot();
MvPrintw(top + 1, 0,
show_color_name(top + 2, (i + 1) * width, i + min_colors, opt_wide);
/* show a grid of colors, with color names/ numbers on the left */
- for (i = (short) (base_row * per_row); i < pairs_max; i++) {
+ for (i = (NCURSES_PAIRS_T) (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;
+ NCURSES_PAIRS_T pair = i;
-#define InxToFG(i) (short) ((i % (COLORS - min_colors)) + min_colors)
-#define InxToBG(i) (short) ((i / (COLORS - min_colors)) + min_colors)
+#define InxToFG(i) (NCURSES_COLOR_T) ((i % (colors_max - min_colors)) + min_colors)
+#define InxToBG(i) (NCURSES_COLOR_T) ((i / (colors_max - min_colors)) + min_colors)
if (row >= 0 && move(row, col) != ERR) {
- short fg = InxToFG(i);
- short bg = InxToBG(i);
+ NCURSES_COLOR_T fg = InxToFG(i);
+ NCURSES_COLOR_T bg = InxToBG(i);
init_pair(pair, fg, bg);
- attron((attr_t) COLOR_PAIR(pair));
+ attron(COLOR_PAIR(pair));
if (opt_acsc)
- attron((attr_t) A_ALTCHARSET);
+ attron(A_ALTCHARSET);
if (opt_bold)
- attron((attr_t) A_BOLD);
+ attron(A_BOLD);
if (opt_revs)
- attron((attr_t) A_REVERSE);
+ attron(A_REVERSE);
if (opt_nums) {
- sprintf(numbered, "{%02X}", i);
+ sprintf(numbered, "{%02X}", (int) i);
hello = numbered;
}
printw("%-*.*s", width, width, hello);
case 'B':
opt_bold = TRUE;
break;
+ case 'c':
+ colors_max = color_cycle(colors_max, -1);
+ break;
+ case 'C':
+ colors_max = color_cycle(colors_max, 1);
+ break;
case 'n':
opt_nums = FALSE;
break;
int grid_top = top + 3;
int page_size = (LINES - grid_top);
int pairs_max = (unsigned short) (-1);
+ int colors_max = COLORS;
int row_limit;
int per_row;
char numbered[80];
bool opt_wide = FALSE;
bool opt_nums = FALSE;
bool opt_xchr = FALSE;
- wchar_t buffer[10];
+ wchar_t buffer[80];
WINDOW *helpwin;
- if (COLORS * COLORS == COLOR_PAIRS) {
- int limit = (COLORS - min_colors) * (COLORS - min_colors);
- if (pairs_max > limit)
- pairs_max = limit;
- } else {
- if (pairs_max > COLOR_PAIRS)
- pairs_max = COLOR_PAIRS;
- }
-
while (!done) {
int shown = 0;
+ pairs_max = (unsigned short) (-1);
+ if (colors_max * colors_max <= COLOR_PAIRS) {
+ int limit = (colors_max - min_colors) * (colors_max - min_colors);
+ if (pairs_max > limit)
+ pairs_max = limit;
+ } else {
+ if (pairs_max > COLOR_PAIRS)
+ pairs_max = COLOR_PAIRS;
+ }
+
/* this assumes an 80-column line */
if (opt_wide) {
width = 4;
hello = "Test";
- per_row = (COLORS > 8) ? 16 : 8;
+ per_row = (colors_max > 8) ? 16 : 8;
} else {
width = 8;
hello = "Hello";
row_limit = (pairs_max + per_row - 1) / per_row;
move(0, 0);
- (void) printw("There are %d color pairs and %d colors%s\n",
- pairs_max, COLORS,
- min_colors ? " besides 'default'" : "");
+ (void) printw("There are %d color pairs and %d colors",
+ pairs_max, COLORS);
+ if (colors_max != COLORS)
+ (void) printw(" (using %d colors)", colors_max);
+ if (min_colors)
+ (void) addstr(" besides 'default'");
clrtobot();
MvPrintw(top + 1, 0,
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 = (short) i;
+ NCURSES_PAIRS_T pair = (NCURSES_PAIRS_T) i;
if (row >= 0 && move(row, col) != ERR) {
init_pair(pair, InxToFG(i), InxToBG(i));
- color_set(pair, NULL);
+ (void) color_set(pair, NULL);
if (opt_acsc)
- attr_on((attr_t) A_ALTCHARSET, NULL);
+ attr_on(A_ALTCHARSET, NULL);
if (opt_bold)
- attr_on((attr_t) A_BOLD, NULL);
+ attr_on(A_BOLD, NULL);
if (opt_revs)
- attr_on((attr_t) A_REVERSE, NULL);
+ attr_on(A_REVERSE, NULL);
if (opt_nums) {
sprintf(numbered, "{%02X}", i);
case 'B':
opt_bold = TRUE;
break;
+ case 'c':
+ colors_max = color_cycle(colors_max, -1);
+ break;
+ case 'C':
+ colors_max = color_cycle(colors_max, 1);
+ break;
case 'n':
opt_nums = FALSE;
break;
#endif /* USE_WIDEC_SUPPORT */
static void
-change_color(short current, int field, int value, int usebase)
+change_color(NCURSES_PAIRS_T current, int field, int value, int usebase)
{
- short red, green, blue;
+ NCURSES_COLOR_T red, green, blue;
color_content(current, &red, &green, &blue);
switch (field) {
case 0:
- red = (short) (usebase ? (red + value) : value);
+ red = (NCURSES_COLOR_T) (usebase ? (red + value) : value);
break;
case 1:
- green = (short) (usebase ? (green + value) : value);
+ green = (NCURSES_COLOR_T) (usebase ? (green + value) : value);
break;
case 2:
- blue = (short) (usebase ? (blue + value) : value);
+ blue = (NCURSES_COLOR_T) (usebase ? (blue + value) : value);
break;
}
static void
init_all_colors(void)
{
- short c;
+ NCURSES_PAIRS_T c;
for (c = 0; c < COLORS; ++c)
init_color(c,
refresh();
for (i = 0; i < max_colors; i++)
- init_pair((short) i, (short) COLOR_WHITE, (short) i);
+ init_pair((NCURSES_PAIRS_T) i,
+ (NCURSES_COLOR_T) COLOR_WHITE,
+ (NCURSES_COLOR_T) i);
MvPrintw(LINES - 2, 0, "Number: %d", value);
do {
- short red, green, blue;
+ NCURSES_COLOR_T red, green, blue;
attron(A_BOLD);
MvAddStr(0, 20, "Color RGB Value Editing");
attroff(A_BOLD);
- for (i = (short) top_color;
+ for (i = (NCURSES_COLOR_T) top_color;
(i - top_color < page_size)
&& (i < max_colors); i++) {
char numeric[80];
(i == current ? '>' : ' '),
(i < (int) SIZEOF(the_color_names)
? the_color_names[i] : numeric));
- (void) attrset((attr_t) COLOR_PAIR(i));
+ (void) attrset(AttrArg(COLOR_PAIR(i), 0));
addstr(" ");
(void) attrset(A_NORMAL);
- color_content((short) i, &red, &green, &blue);
+ color_content((NCURSES_PAIRS_T) i, &red, &green, &blue);
addstr(" R = ");
if (current == i && field == 0)
attron(A_STANDOUT);
- printw("%04d", red);
+ printw("%04d", (int) red);
if (current == i && field == 0)
(void) attrset(A_NORMAL);
addstr(", G = ");
if (current == i && field == 1)
attron(A_STANDOUT);
- printw("%04d", green);
+ printw("%04d", (int) green);
if (current == i && field == 1)
(void) attrset(A_NORMAL);
addstr(", B = ");
if (current == i && field == 2)
attron(A_STANDOUT);
- printw("%04d", blue);
+ printw("%04d", (int) blue);
if (current == i && field == 2)
(void) attrset(A_NORMAL);
(void) attrset(A_NORMAL);
printw(" ( %3d %3d %3d )",
- scaled_rgb(red),
- scaled_rgb(green),
- scaled_rgb(blue));
+ (int) scaled_rgb(red),
+ (int) scaled_rgb(green),
+ (int) scaled_rgb(blue));
}
MvAddStr(LINES - 3, 0,
break;
case '+':
- change_color((short) current, field, value, 1);
+ change_color((NCURSES_PAIRS_T) current, field, value, 1);
break;
case '-':
- change_color((short) current, field, -value, 1);
+ change_color((NCURSES_PAIRS_T) current, field, -value, 1);
break;
case '=':
- change_color((short) current, field, value, 0);
+ change_color((NCURSES_PAIRS_T) current, field, value, 0);
break;
case '?':
endwin();
main_menu(FALSE);
for (i = 0; i < max_colors; i++)
- init_pair((short) i, (short) COLOR_WHITE, (short) i);
+ init_pair((NCURSES_PAIRS_T) i,
+ (NCURSES_COLOR_T) COLOR_WHITE,
+ (NCURSES_COLOR_T) i);
refresh();
break;
* Alternate character-set stuff
*
****************************************************************************/
-/* *INDENT-OFF* */
-static struct {
- chtype attr;
- const char *name;
-} attrs_to_cycle[] = {
- { A_NORMAL, "normal" },
- { A_BOLD, "bold" },
- { A_BLINK, "blink" },
- { A_REVERSE, "reverse" },
- { A_UNDERLINE, "underline" },
-};
-/* *INDENT-ON* */
-
static bool
-cycle_attr(int ch, unsigned *at_code, chtype *attr)
+cycle_attr(int ch, unsigned *at_code, chtype *attr, ATTR_TBL * list, unsigned limit)
{
bool result = TRUE;
switch (ch) {
case 'v':
- if ((*at_code += 1) >= SIZEOF(attrs_to_cycle))
+ if ((*at_code += 1) >= limit)
*at_code = 0;
break;
case 'V':
if (*at_code == 0)
- *at_code = SIZEOF(attrs_to_cycle) - 1;
+ *at_code = limit - 1;
else
*at_code -= 1;
break;
break;
}
if (result)
- *attr = attrs_to_cycle[*at_code].attr;
+ *attr = list[*at_code].attr;
return result;
}
static bool
-cycle_colors(int ch, int *fg, int *bg, short *pair)
+cycle_colors(int ch, int *fg, int *bg, NCURSES_PAIRS_T *pair)
{
bool result = FALSE;
break;
}
if (result) {
- *pair = (short) (*fg != COLOR_BLACK || *bg != COLOR_BLACK);
+ *pair = (NCURSES_PAIRS_T) (*fg != COLOR_BLACK || *bg != COLOR_BLACK);
if (*pair != 0) {
*pair = 1;
- if (init_pair(*pair, (short) *fg, (short) *bg) == ERR) {
+ if (init_pair(*pair,
+ (NCURSES_COLOR_T) *fg,
+ (NCURSES_COLOR_T) *bg) == ERR) {
result = FALSE;
}
}
static void
call_slk_color(int fg, int bg)
{
- init_pair(1, (short) bg, (short) fg);
+ init_pair(1, (NCURSES_COLOR_T) bg, (NCURSES_COLOR_T) fg);
slk_color(1);
MvPrintw(SLK_WORK, 0, "Colors %d/%d\n", fg, bg);
clrtoeol();
#if HAVE_SLK_COLOR
int fg = COLOR_BLACK;
int bg = COLOR_WHITE;
- short pair = 0;
+ NCURSES_PAIRS_T pair = 0;
#endif
+ ATTR_TBL my_list[SIZEOF(attrs_to_test)];
+ unsigned my_size = init_attr_list(my_list, termattrs());
c = CTRL('l');
#if HAVE_SLK_COLOR
MvAddStr(SLK_WORK, 0, "Please enter the label value: ");
strcpy(buf, "");
if ((s = slk_label(c - '0')) != 0) {
- strncpy(buf, s, 8);
+ strncpy(buf, s, (size_t) 8);
}
wGetstring(stdscr, buf, 8);
slk_set((c - '0'), buf, fmt);
#endif
default:
- if (cycle_attr(c, &at_code, &attr)) {
+ if (cycle_attr(c, &at_code, &attr, my_list, my_size)) {
slk_attrset(attr);
slk_touch();
slk_noutrefresh();
unsigned at_code = 0;
int fg = COLOR_BLACK;
int bg = COLOR_WHITE;
- short pair = 0;
+ NCURSES_PAIRS_T pair = 0;
+ ATTR_TBL my_list[SIZEOF(attrs_to_test)];
+ unsigned my_size = init_attr_list(my_list, term_attrs());
c = CTRL('l');
if (use_colors) {
case 'F':
if (use_colors) {
- fg = (short) ((fg + 1) % COLORS);
+ fg = (NCURSES_COLOR_T) ((fg + 1) % COLORS);
call_slk_color(fg, bg);
}
break;
case 'B':
if (use_colors) {
- bg = (short) ((bg + 1) % COLORS);
+ bg = (NCURSES_COLOR_T) ((bg + 1) % COLORS);
call_slk_color(fg, bg);
}
break;
break;
#endif
default:
- if (cycle_attr(c, &at_code, &attr)) {
- slk_attr_set(attr, (short) (fg || bg), NULL);
+ if (cycle_attr(c, &at_code, &attr, my_list, my_size)) {
+ slk_attr_set(attr, (NCURSES_COLOR_T) (fg || bg), NULL);
slk_touch();
slk_noutrefresh();
break;
#endif
#endif /* SLK_INIT */
-/* ISO 6429: codes 0x80 to 0x9f may be control characters that cause the
+static void
+show_256_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
+{
+ unsigned first = 0;
+ unsigned last = 255;
+ unsigned code;
+ int count;
+
+ erase();
+ attron(A_BOLD);
+ MvPrintw(0, 20, "Display of Character Codes %#0x to %#0x",
+ first, last);
+ attroff(A_BOLD);
+ refresh();
+
+ for (code = first; code <= last; ++code) {
+ int row = (int) (2 + (code / 16));
+ int col = (int) (5 * (code % 16));
+ IGNORE_RC(mvaddch(row, col, colored_chtype(code, attr, pair)));
+ for (count = 1; count < repeat; ++count) {
+ addch(colored_chtype(code, attr, pair));
+ }
+ }
+
+}
+
+/*
+ * Show a slice of 32 characters, allowing those to be repeated up to the
+ * screen's width.
+ *
+ * ISO 6429: codes 0x80 to 0x9f may be control characters that cause the
* terminal to perform functions. The remaining codes can be graphic.
*/
static void
-show_upper_chars(unsigned first, int repeat, attr_t attr, short pair)
+show_upper_chars(int base, int pagesize, int repeat, attr_t attr, NCURSES_PAIRS_T pair)
{
- bool C1 = (first == 128);
unsigned code;
- unsigned last = first + 31;
+ unsigned first = (unsigned) base;
+ unsigned last = first + (unsigned) pagesize - 2;
+ bool C1 = (first == 128);
int reply;
erase();
for (code = first; code <= last; code++) {
int count = repeat;
- int row = 2 + ((int) (code - first) % 16);
- int col = ((int) (code - first) / 16) * COLS / 2;
+ int row = 2 + ((int) (code - first) % (pagesize / 2));
+ int col = ((int) (code - first) / (pagesize / 2)) * COLS / 2;
char tmp[80];
sprintf(tmp, "%3u (0x%x)", code, code);
MvPrintw(row, col, "%*s: ", COLS / 4, tmp);
#define PC_COLS 4
static void
-show_pc_chars(int repeat, attr_t attr, short pair)
+show_pc_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
{
unsigned code;
}
static void
-show_box_chars(int repeat, attr_t attr, short pair)
+show_box_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
{
(void) repeat;
}
static void
-show_acs_chars(int repeat, attr_t attr, short pair)
+show_acs_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
/* display the ACS character set */
{
int n;
acs_display(void)
{
int c = 'a';
+ int pagesize = 32;
char *term = getenv("TERM");
const char *pch_kludge = ((term != 0 && strstr(term, "linux"))
? "p=PC, "
int fg = COLOR_BLACK;
int bg = COLOR_BLACK;
unsigned at_code = 0;
- short pair = 0;
- void (*last_show_acs) (int, attr_t, short) = 0;
+ NCURSES_PAIRS_T pair = 0;
+ void (*last_show_acs) (int, attr_t, NCURSES_PAIRS_T) = 0;
+ ATTR_TBL my_list[SIZEOF(attrs_to_test)];
+ unsigned my_size = init_attr_list(my_list, termattrs());
do {
switch (c) {
else
beep();
break;
+ case 'w':
+ if (pagesize == 32) {
+ pagesize = 256;
+ } else {
+ pagesize = 32;
+ }
+ break;
case 'x':
ToggleAcs(last_show_acs, show_box_chars);
break;
--repeat;
break;
default:
- if (cycle_attr(c, &at_code, &attr)
+ if (cycle_attr(c, &at_code, &attr, my_list, my_size)
|| cycle_colors(c, &fg, &bg, &pair)) {
break;
} else {
}
break;
}
- if (last_show_acs != 0)
+ if (pagesize != 32) {
+ show_256_chars(repeat, attr, pair);
+ } else if (last_show_acs != 0) {
last_show_acs(repeat, attr, pair);
- else
- show_upper_chars((unsigned) (digit * 32 + 128), repeat, attr, pair);
+ } else {
+ show_upper_chars(digit * pagesize + 128, pagesize, repeat, attr, pair);
+ }
MvPrintw(LINES - 3, 0,
"Note: ANSI terminals may not display C1 characters.");
MvPrintw(LINES - 2, 0,
- "Select: a=ACS, x=box, %s0=C1, 1-3,+/- non-ASCII, </> repeat, ESC=quit",
+ "Select: a=ACS, w=all x=box, %s0=C1, 1-3,+/- non-ASCII, </> repeat, ESC=quit",
pch_kludge);
if (use_colors) {
MvPrintw(LINES - 1, 0,
"v/V, f/F, b/B cycle through video attributes (%s) and color %d/%d.",
- attrs_to_cycle[at_code].name,
+ my_list[at_code].name,
fg, bg);
} else {
MvPrintw(LINES - 1, 0,
"v/V cycles through video attributes (%s).",
- attrs_to_cycle[at_code].name);
+ my_list[at_code].name);
}
refresh();
} while (!isQuit(c = Getchar()));
#if USE_WIDEC_SUPPORT
static cchar_t *
-merge_wide_attr(cchar_t *dst, const cchar_t *src, attr_t attr, short pair)
+merge_wide_attr(cchar_t *dst, const cchar_t *src, attr_t attr, NCURSES_PAIRS_T pair)
{
int count;
return dst;
}
+/*
+ * Header/legend take up no more than 8 lines, leaving 16 lines on a 24-line
+ * display. If there are no repeats, we could normally display 16 lines of 64
+ * characters (1024 total). However, taking repeats and double-width cells
+ * into account, use 256 characters for the page.
+ */
static void
-show_upper_widechars(int first, int repeat, int space, attr_t attr, short pair)
+show_paged_widechars(int base,
+ int pagesize,
+ int repeat,
+ int space,
+ attr_t attr,
+ NCURSES_PAIRS_T pair)
+{
+ int first = base * pagesize;
+ int last = first + pagesize - 1;
+ int per_line = 16;
+ cchar_t temp;
+ wchar_t code;
+ wchar_t codes[10];
+
+ erase();
+ attron(A_BOLD);
+ MvPrintw(0, 20, "Display of Character Codes %#x to %#x", first, last);
+ attroff(A_BOLD);
+
+ for (code = (wchar_t) first; (int) code <= last; code++) {
+ int row = (2 + ((int) code - first) / per_line);
+ int col = 5 * ((int) code % per_line);
+ int count;
+
+ memset(&codes, 0, sizeof(codes));
+ codes[0] = code;
+ setcchar(&temp, codes, attr, pair, 0);
+ move(row, col);
+ if (wcwidth(code) == 0 && code != 0) {
+ addch((chtype) space |
+ (A_REVERSE ^ attr) |
+ (attr_t) COLOR_PAIR(pair));
+ }
+ add_wch(&temp);
+ for (count = 1; count < repeat; ++count) {
+ add_wch(&temp);
+ }
+ }
+}
+
+static void
+show_upper_widechars(int first, int repeat, int space, attr_t attr, NCURSES_PAIRS_T pair)
{
cchar_t temp;
wchar_t code;
MvPrintw(0, 20, "Display of Character Codes %d to %d", first, last);
attroff(A_BOLD);
- for (code = first; (int) code <= last; code++) {
+ for (code = (wchar_t) first; (int) code <= last; code++) {
int row = 2 + ((code - first) % 16);
int col = ((code - first) / 16) * COLS / 2;
wchar_t codes[10];
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);
+
+ memset(&codes, 0, sizeof(codes));
+ codes[0] = code;
setcchar(&temp, codes, attr, pair, 0);
+
do {
/*
* Give non-spacing characters something to combine with. If we
(attr_t) COLOR_PAIR(pair));
}
/*
- * This could use add_wch(), but is done for comparison with the
- * normal 'f' test (and to make a test-case for echo_wchar()).
- * The screen will flicker because the erase() at the top of the
- * function is met by the builtin refresh() in echo_wchar().
+ * This uses echo_wchar(), for comparison with the normal 'f'
+ * test (and to make a test-case for echo_wchar()). The screen
+ * may flicker because the erase() at the top of the function
+ * is met by the builtin refresh() in echo_wchar().
*/
echo_wchar(&temp);
/*
#define MERGE_ATTR(wch) merge_wide_attr(&temp, wch, attr, pair)
static void
-show_wacs_chars(int repeat, attr_t attr, short pair)
+show_wacs_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
/* display the wide-ACS character set */
{
cchar_t temp;
#ifdef WACS_D_PLUS
static void
-show_wacs_chars_double(int repeat, attr_t attr, short pair)
+show_wacs_chars_double(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
/* display the wide-ACS character set */
{
cchar_t temp;
#ifdef WACS_T_PLUS
static void
-show_wacs_chars_thick(int repeat, attr_t attr, short pair)
+show_wacs_chars_thick(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
/* display the wide-ACS character set */
{
cchar_t temp;
#define MERGE_ATTR(n,wch) merge_wide_attr(&temp[n], wch, attr, pair)
static void
-show_wbox_chars(int repeat, attr_t attr, short pair)
+show_wbox_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
{
cchar_t temp[8];
#undef MERGE_ATTR
static int
-show_2_wacs(int n, const char *name, const char *code, attr_t attr, short pair)
+show_2_wacs(int n, const char *name, const char *code, attr_t attr, NCURSES_PAIRS_T pair)
{
const int height = 16;
int row = 2 + (n % height);
MvPrintw(row, col, "%*s : ", COLS / 4, name);
(void) attr_set(attr, pair, 0);
- addstr(strcpy(temp, code));
+ addstr(strncpy(temp, code, 20));
(void) 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(int repeat, attr_t attr, short pair)
+show_utf8_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
{
int n;
int digit = 0;
int repeat = 1;
int space = ' ';
+ int pagesize = 32;
chtype attr = A_NORMAL;
int fg = COLOR_BLACK;
int bg = COLOR_BLACK;
unsigned at_code = 0;
- short pair = 0;
- void (*last_show_wacs) (int, attr_t, short) = 0;
+ NCURSES_PAIRS_T pair = 0;
+ void (*last_show_wacs) (int, attr_t, NCURSES_PAIRS_T) = 0;
+ ATTR_TBL my_list[SIZEOF(attrs_to_test)];
+ unsigned my_size = init_attr_list(my_list, term_attrs());
do {
switch (c) {
ToggleAcs(last_show_wacs, show_wacs_chars_thick);
break;
#endif
+ case 'w':
+ if (pagesize == 32) {
+ pagesize = 256;
+ } else {
+ pagesize = 32;
+ }
+ break;
case 'x':
ToggleAcs(last_show_wacs, show_wbox_chars);
break;
} else if (c == '_') {
space = (space == ' ') ? '_' : ' ';
last_show_wacs = 0;
- } else if (cycle_attr(c, &at_code, &attr)
+ } else if (cycle_attr(c, &at_code, &attr, my_list, my_size)
|| cycle_colors(c, &fg, &bg, &pair)) {
if (last_show_wacs != 0)
break;
}
break;
}
- if (last_show_wacs != 0)
+ if (pagesize != 32) {
+ show_paged_widechars(digit, pagesize, repeat, space, attr, pair);
+ } else if (last_show_wacs != 0) {
last_show_wacs(repeat, attr, pair);
- else
+ } else {
show_upper_widechars(digit * 32 + 128, repeat, space, attr, pair);
+ }
- MvPrintw(LINES - 3, 0,
- "Select: a/d/t WACS, x box, u UTF-8, 0-9,+/- non-ASCII, </> repeat, ESC=quit");
+ MvPrintw(LINES - 4, 0,
+ "Select: a/d/t WACS, w=all x=box, u UTF-8, ^L repaint");
+ MvPrintw(LINES - 3, 2,
+ "0-9,+/- non-ASCII, </> repeat, _ space, ESC=quit");
if (use_colors) {
- MvPrintw(LINES - 2, 0,
+ MvPrintw(LINES - 2, 2,
"v/V, f/F, b/B cycle through video attributes (%s) and color %d/%d.",
- attrs_to_cycle[at_code].name,
+ my_list[at_code].name,
fg, bg);
} else {
- MvPrintw(LINES - 2, 0,
+ MvPrintw(LINES - 2, 2,
"v/V cycles through video attributes (%s).",
- attrs_to_cycle[at_code].name);
+ my_list[at_code].name);
}
refresh();
} while (!isQuit(c = Getchar()));
/* Use non-default colors if possible to exercise bce a little */
if (use_colors) {
init_pair(1, COLOR_WHITE, COLOR_BLUE);
- normal |= COLOR_PAIR(1);
+ normal |= (chtype) COLOR_PAIR(1);
}
bkgdset(normal);
erase();
outerbox(ul, lr, TRUE);
refresh();
- wrefresh(rwindow);
+ if (rwindow != 0)
+ wrefresh(rwindow);
move(0, 0);
clrtoeol();
transient((FRAME *) 0, (char *) 0);
switch (c) {
case CTRL('C'):
- if ((neww = typeCalloc(FRAME, 1)) == 0) {
+ if ((neww = typeCalloc(FRAME, (size_t) 1)) == 0) {
+ failed("acs_and_scroll");
goto breakout;
}
if ((neww->wind = getwindow()) == (WINDOW *) 0) {
+ failed("acs_and_scroll");
free(neww);
goto breakout;
}
if ((fp = fopen(DUMPFILE, "r")) == (FILE *) 0) {
transient(current, "Can't open screen dump file");
} else {
- if ((neww = typeCalloc(FRAME, 1)) != 0) {
+ if ((neww = typeCalloc(FRAME, (size_t) 1)) != 0) {
neww->next = current ? current->next : 0;
neww->last = current;
neww->wind = getwin(fp);
wrefresh(neww->wind);
+ } else {
+ failed("acs_and_scroll");
}
(void) fclose(fp);
}
mkpanel(rows,cols,tly,tlx) - alloc a win and panel and associate them
--------------------------------------------------------------------------*/
static PANEL *
-mkpanel(short color, int rows, int cols, int tly, int tlx)
+mkpanel(NCURSES_COLOR_T color, int rows, int cols, int tly, int tlx)
{
WINDOW *win;
PANEL *pan = 0;
if ((pan = new_panel(win)) == 0) {
delwin(win);
} else if (use_colors) {
- short fg = (short) ((color == COLOR_BLUE) ? COLOR_WHITE : COLOR_BLACK);
- short bg = color;
+ NCURSES_COLOR_T fg = (NCURSES_COLOR_T) ((color == COLOR_BLUE)
+ ? COLOR_WHITE
+ : COLOR_BLACK);
+ NCURSES_COLOR_T bg = color;
init_pair(color, fg, bg);
wbkgdset(win, (attr_t) (COLOR_PAIR(color) | ' '));
fill_panel(win)
--------------------------------------------------------------------------*/
static void
-init_panel(void)
+init_panel(WINDOW *win)
{
register int y, x;
for (y = 0; y < LINES - 1; y++) {
for (x = 0; x < COLS; x++)
- wprintw(stdscr, "%d", (y + x) % 10);
+ wprintw(win, "%d", (y + x) % 10);
}
}
#if USE_WIDEC_SUPPORT
static void
-init_wide_panel(void)
+init_wide_panel(WINDOW *win)
{
int digit;
cchar_t temp[10];
int y, x;
getyx(stdscr, y, x);
digit = (y + x / 2) % 10;
- } while (add_wch(&temp[digit]) != ERR);
+ } while (wadd_wch(win, &temp[digit]) != ERR);
}
static void
}
static void
-demo_panels(void (*InitPanel) (void), void (*FillPanel) (PANEL *))
+demo_panels(void (*InitPanel) (WINDOW *), void (*FillPanel) (PANEL *))
{
int count;
int itmp;
scrollok(stdscr, FALSE); /* we don't want stdscr to scroll! */
refresh();
- InitPanel();
+ InitPanel(stdscr);
for (count = 0; count < 5; count++) {
px[1] = mkpanel(COLOR_RED,
LINES / 2 - 2,
for (n = 0; t_tbl[n].name != 0; n++)
need += strlen(t_tbl[n].name) + 2;
buf = typeMalloc(char, need);
+ if (!buf)
+ failed("tracetrace");
}
sprintf(buf, "0x%02x = {", tlevel);
if (tlevel == 0) {
set_form_sub(f, derwin(w, rows, cols, 1, 2));
box(w, 0, 0);
keypad(w, TRUE);
+ if (post_form(f) != E_OK)
+ wrefresh(w);
}
-
- if (post_form(f) != E_OK)
- wrefresh(w);
}
static void
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, source ? source : "");
- len = (long) (char *) field_userptr(me);
- if (c <= KEY_MAX) {
- if (isgraph(c) && (len + 1) < (int) sizeof(temp)) {
- temp[len++] = (char) c;
- temp[len] = 0;
- set_field_buffer(me, 1, temp);
- c = '*';
- } else {
- c = 0;
- }
- } else {
- switch (c) {
- case REQ_BEG_FIELD:
- case REQ_CLR_EOF:
- case REQ_CLR_EOL:
- case REQ_DEL_LINE:
- case REQ_DEL_WORD:
- case REQ_DOWN_CHAR:
- case REQ_END_FIELD:
- case REQ_INS_CHAR:
- case REQ_INS_LINE:
- case REQ_LEFT_CHAR:
- case REQ_NEW_LINE:
- case REQ_NEXT_WORD:
- case REQ_PREV_WORD:
- case REQ_RIGHT_CHAR:
- case REQ_UP_CHAR:
- c = 0; /* we don't want to do inline editing */
- break;
- case REQ_CLR_FIELD:
- if (len) {
- temp[0] = 0;
+ size_t have = (source ? strlen(source) : 0) + 1;
+ size_t need = 80 + have;
+ char *temp = malloc(need);
+ size_t len;
+
+ if (temp != 0) {
+ strncpy(temp, source ? source : "", have + 1);
+ len = (size_t) (char *) field_userptr(me);
+ if (c <= KEY_MAX) {
+ if (isgraph(c) && (len + 1) < sizeof(temp)) {
+ temp[len++] = (char) c;
+ temp[len] = 0;
set_field_buffer(me, 1, temp);
+ c = '*';
+ } else {
+ c = 0;
}
- break;
- case REQ_DEL_CHAR:
- case REQ_DEL_PREV:
- if (len) {
- temp[--len] = 0;
- set_field_buffer(me, 1, temp);
+ } else {
+ switch (c) {
+ case REQ_BEG_FIELD:
+ case REQ_CLR_EOF:
+ case REQ_CLR_EOL:
+ case REQ_DEL_LINE:
+ case REQ_DEL_WORD:
+ case REQ_DOWN_CHAR:
+ case REQ_END_FIELD:
+ case REQ_INS_CHAR:
+ case REQ_INS_LINE:
+ case REQ_LEFT_CHAR:
+ case REQ_NEW_LINE:
+ case REQ_NEXT_WORD:
+ case REQ_PREV_WORD:
+ case REQ_RIGHT_CHAR:
+ case REQ_UP_CHAR:
+ c = 0; /* we don't want to do inline editing */
+ break;
+ case REQ_CLR_FIELD:
+ if (len) {
+ temp[0] = 0;
+ set_field_buffer(me, 1, temp);
+ }
+ break;
+ case REQ_DEL_CHAR:
+ case REQ_DEL_PREV:
+ if (len) {
+ temp[--len] = 0;
+ set_field_buffer(me, 1, temp);
+ }
+ break;
}
- break;
}
+ set_field_userptr(me, (void *) len);
+ free(temp);
}
- set_field_userptr(me, (void *) len);
}
return c;
}
static void
overlap_test_1_attr(WINDOW *win, int flavor, int col)
{
- short cpair = (short) (1 + (flavor * 2) + col);
+ NCURSES_PAIRS_T cpair = (NCURSES_PAIRS_T) (1 + (flavor * 2) + col);
switch (flavor) {
case 0:
break;
case 2:
init_pair(cpair, COLOR_BLUE, COLOR_WHITE);
- (void) wattrset(win, (int) (COLOR_PAIR(cpair) | A_NORMAL));
+ (void) wattrset(win, AttrArg(COLOR_PAIR(cpair), A_NORMAL));
break;
case 3:
init_pair(cpair, COLOR_WHITE, COLOR_BLUE);
- (void) wattrset(win, (int) (COLOR_PAIR(cpair) | A_BOLD));
+ (void) wattrset(win, AttrArg(COLOR_PAIR(cpair), A_BOLD));
break;
}
}
static void
overlap_test_2_attr(WINDOW *win, int flavor, int col)
{
- short cpair = (short) (9 + (flavor * 2) + col);
+ NCURSES_PAIRS_T cpair = (NCURSES_PAIRS_T) (9 + (flavor * 2) + col);
switch (flavor) {
case 0:
," -a f,b set default-colors (assumed white-on-black)"
," -d use default-colors if terminal supports them"
#endif
+#if HAVE_USE_ENV
+ ," -E call use_env(FALSE) to ignore $LINES and $COLUMNS"
+#endif
#if USE_SOFTKEYS
," -e fmt specify format for soft-keys test (e)"
#endif
#if USE_LIBPANEL
," -s msec specify nominal time for panel-demo (default: 1, to hold)"
#endif
+#if defined(NCURSES_VERSION_PATCH) && (NCURSES_VERSION_PATCH >= 20120714) && !defined(__MINGW32__)
+ ," -T call use_tioctl(TRUE) to allow SIGWINCH to override environment"
+#endif
#ifdef TRACE
," -t mask specify default trace-level (may toggle with ^T)"
#endif
}
#ifdef SIGUSR1
-static RETSIGTYPE
+static void
announce_sig(int sig)
{
(void) fprintf(stderr, "Handled signal %d\r\n", sig);
command = 0;
for (;;) {
char ch = '\0';
- if (read(fileno(stdin), &ch, 1) <= 0) {
+ if (read(fileno(stdin), &ch, (size_t) 1) <= 0) {
if (command == 0)
command = 'q';
break;
setlocale(LC_ALL, "");
- while ((c = getopt(argc, argv, "a:de:fhmp:s:t:")) != -1) {
+ while ((c = getopt(argc, argv, "a:dEe:fhmp:s:Tt:")) != -1) {
switch (c) {
#ifdef NCURSES_VERSION
case 'a':
assumed_colors = TRUE;
- sscanf(optarg, "%d,%d", &default_fg, &default_bg);
+ switch (sscanf(optarg, "%d,%d", &default_fg, &default_bg)) {
+ case 0:
+ default_fg = COLOR_WHITE;
+ /* FALLTHRU */
+ case 1:
+ default_bg = COLOR_BLACK;
+ break;
+ }
break;
case 'd':
default_colors = TRUE;
break;
+#endif
+#if HAVE_USE_ENV
+ case 'E':
+ use_env(FALSE);
+ break;
#endif
case 'e':
my_e_param = atoi(optarg);
nap_msec = (int) atol(optarg);
break;
#endif
+#if defined(NCURSES_VERSION_PATCH) && (NCURSES_VERSION_PATCH >= 20120714) && !defined(__MINGW32__)
+ case 'T':
+ use_tioctl(TRUE);
+ break;
+#endif
#ifdef TRACE
case 't':
save_trace = (unsigned) strtol(optarg, 0, 0);
bkgdset(BLANK);
/* tests, in general, will want these modes */
- use_colors = monochrome ? FALSE : has_colors();
+ use_colors = (bool) (monochrome ? FALSE : has_colors());
if (use_colors) {
start_color();
max_pairs = COLOR_PAIRS; /* was > 256 ? 256 : COLOR_PAIRS */
if (can_change_color()) {
- short cp;
+ NCURSES_PAIRS_T cp;
all_colors = typeMalloc(RGB_DATA, (unsigned) max_colors);
+ if (!all_colors)
+ failed("all_colors");
for (cp = 0; cp < max_colors; ++cp) {
color_content(cp,
&all_colors[cp].red,
&& okRGB(red)
&& okRGB(green)
&& okRGB(blue)) {
- all_colors[c].red = (short) ((red * 1000) / scale);
- all_colors[c].green = (short) ((green * 1000) / scale);
- all_colors[c].blue = (short) ((blue * 1000) / scale);
+#define Scaled(n) (NCURSES_COLOR_T) (((n) * 1000) / scale)
+ all_colors[c].red = Scaled(red);
+ all_colors[c].green = Scaled(green);
+ all_colors[c].blue = Scaled(blue);
}
}
fclose(fp);
projects / ncurses.git / blobdiff