/****************************************************************************
- * Copyright (c) 1998-2012,2013 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.392 2013/08/31 20:47:55 tom Exp $
+$Id: ncurses.c,v 1.408 2014/06/28 21:45:40 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;
#if USE_WIDEC_SUPPORT
static wchar_t
-fullwidth_of(int ch)
+fullwidth_digit(int ch)
{
return (ch + 0xff10 - '0');
}
{
int ch;
while ((ch = *source++) != 0) {
- *target++ = fullwidth_of(ch);
+ *target++ = fullwidth_digit(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);
}
#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];
}
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);
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, attr);
+ (void) waddstr(win, attr_test_string);
+ (void) wattroff(win, attr);
}
if (skip)
printw("%*s", skip, " ");
- printw("|");
+ MvPrintw(row, COL_ATTRSTRING + LEN_ATTRSTRING, "|");
if (test != A_NORMAL) {
if (!(termattrs() & test)) {
printw(" (N/A)");
}
static bool
-attr_getc(int *skip, short *fg, short *bg, short *tx, int *ac, unsigned *kc, unsigned limit)
+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;
{
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;
chtype extras = (chtype) ac;
if (use_colors) {
- short pair = (short) (fg != COLOR_BLACK || bg != COLOR_BLACK);
- if (pair != 0) {
+ NCURSES_PAIRS_T pair = 0;
+ if ((fg != COLOR_BLACK) || (bg != COLOR_BLACK)) {
pair = 1;
if (init_pair(pair, fg, bg) == ERR) {
beep();
for (j = 0; j < my_size; ++j) {
bool arrow = (j == k);
- row = show_attr(row, n, arrow,
+ row = show_attr(my_wins[j], row, n, arrow,
extras |
my_list[j].attr |
my_list[k].attr,
static void
wide_adjust_attr_string(int adjust)
{
- int first = ((int) UChar(wide_attr_test_string[0])) + adjust;
- int last = first + LEN_ATTRSTRING;
+ char save = (char) wide_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;
wide_attr_test_string[j] = k;
if (((k + 1 - first) % 5) == 0) {
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();
+ 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';
+ wide_attr_test_string[0] = 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));
}
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);
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,
+ NCURSES_COLOR_T *fg, NCURSES_COLOR_T *bg,
+ NCURSES_COLOR_T *tx, int *ac,
unsigned *kc, unsigned limit)
{
bool result = TRUE;
{
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;
do {
int row = 2;
- short pair = 0;
- short extras = 0;
+ NCURSES_PAIRS_T pair = 0;
+ NCURSES_PAIRS_T extras = 0;
if (use_colors) {
- 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, fg, bg) == ERR) {
MvAddStr(0, 20, "Character attribute test display");
for (j = 0; j < my_size; ++j) {
- row = wide_show_attr(row, n, j == k,
+ row = wide_show_attr(my_wins[j], row, n, (j == k),
((attr_t) ac |
my_list[j].attr |
my_list[k].attr),
" 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((attr_t) 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];
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));
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];
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;
}
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());
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);
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());
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;
#endif
default:
if (cycle_attr(c, &at_code, &attr, my_list, my_size)) {
- slk_attr_set(attr, (short) (fg || bg), NULL);
+ slk_attr_set(attr, (NCURSES_COLOR_T) (fg || bg), NULL);
slk_touch();
slk_noutrefresh();
break;
#endif /* SLK_INIT */
static void
-show_256_chars(int repeat, attr_t attr, short pair)
+show_256_chars(int repeat, attr_t attr, NCURSES_PAIRS_T pair)
{
unsigned first = 0;
unsigned last = 255;
for (code = first; code <= last; ++code) {
int row = (int) (2 + (code / 16));
int col = (int) (5 * (code % 16));
- mvaddch(row, col, colored_chtype(code, attr, pair));
+ IGNORE_RC(mvaddch(row, col, colored_chtype(code, attr, pair)));
for (count = 1; count < repeat; ++count) {
addch(colored_chtype(code, attr, pair));
}
* terminal to perform functions. The remaining codes can be graphic.
*/
static void
-show_upper_chars(int base, int pagesize, int repeat, attr_t attr, short pair)
+show_upper_chars(int base, int pagesize, int repeat, attr_t attr, NCURSES_PAIRS_T pair)
{
unsigned code;
unsigned first = (unsigned) base;
#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;
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());
#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;
int repeat,
int space,
attr_t attr,
- short pair)
+ NCURSES_PAIRS_T pair)
{
int first = base * pagesize;
int last = first + pagesize - 1;
}
static void
-show_upper_widechars(int first, int repeat, int space, attr_t attr, short pair)
+show_upper_widechars(int first, int repeat, int space, attr_t attr, NCURSES_PAIRS_T pair)
{
cchar_t temp;
wchar_t code;
#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);
#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 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());
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 ((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;
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,
size_t have = (source ? strlen(source) : 0) + 1;
size_t need = 80 + have;
char *temp = malloc(need);
- long len;
+ size_t len;
if (temp != 0) {
strncpy(temp, source ? source : "", have + 1);
- len = (long) (char *) field_userptr(me);
+ len = (size_t) (char *) field_userptr(me);
if (c <= KEY_MAX) {
- if (isgraph(c) && (len + 1) < (int) sizeof(temp)) {
+ if (isgraph(c) && (len + 1) < sizeof(temp)) {
temp[len++] = (char) c;
temp[len] = 0;
set_field_buffer(me, 1, temp);
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:
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:
#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)
+#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
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;
nap_msec = (int) atol(optarg);
break;
#endif
-#if defined(NCURSES_VERSION_PATCH) && (NCURSES_VERSION_PATCH >= 20120714)
+#if defined(NCURSES_VERSION_PATCH) && (NCURSES_VERSION_PATCH >= 20120714) && !defined(__MINGW32__)
case 'T':
use_tioctl(TRUE);
break;
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");
&& 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