ncurses.c

ncurses-5.4 需要的就来下把 一定会有用的哦

	    break;
	case 'B':
	    if (has_colors()) {
		bg = (bg + 1) % max_colors;
		new_color = TRUE;
	    }
	    break;

	default:
	    beep();
	}
    } while
	((c = Getchar()) != EOF);

  done:
    erase();
    endwin();
}
#endif

/****************************************************************************
 *
 * Alternate character-set stuff
 *
 ****************************************************************************/

/* 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(int first)
{
    bool C1 = (first == 128);
    int code;
    int last = first + 31;
    int reply;

    erase();
    attron(A_BOLD);
    mvprintw(0, 20, "Display of %s Character Codes %d to %d",
	     C1 ? "C1" : "GR", first, last);
    attroff(A_BOLD);
    refresh();

    for (code = first; code <= last; code++) {
	int row = 4 + ((code - first) % 16);
	int col = ((code - first) / 16) * COLS / 2;
	char tmp[80];
	sprintf(tmp, "%3d (0x%x)", code, code);
	mvprintw(row, col, "%*s: ", COLS / 4, tmp);
	if (C1)
	    nodelay(stdscr, TRUE);
	echochar(code);
	if (C1) {
	    /* (yes, this _is_ crude) */
	    while ((reply = Getchar()) != ERR) {
		addch(reply);
		napms(10);
	    }
	    nodelay(stdscr, FALSE);
	}
    }
}

static void
show_box_chars(void)
{
    erase();
    attron(A_BOLD);
    mvaddstr(0, 20, "Display of the ACS Line-Drawing Set");
    attroff(A_BOLD);
    refresh();
    box(stdscr, 0, 0);
    /* *INDENT-OFF* */
    mvhline(LINES / 2, 0,        ACS_HLINE, COLS);
    mvvline(0,         COLS / 2, ACS_VLINE, LINES);
    mvaddch(0,         COLS / 2, ACS_TTEE);
    mvaddch(LINES / 2, COLS / 2, ACS_PLUS);
    mvaddch(LINES - 1, COLS / 2, ACS_BTEE);
    mvaddch(LINES / 2, 0,        ACS_LTEE);
    mvaddch(LINES / 2, COLS - 1, ACS_RTEE);
    /* *INDENT-ON* */

}

static int
show_1_acs(int n, const char *name, chtype code)
{
    const int height = 16;
    int row = 4 + (n % height);
    int col = (n / height) * COLS / 2;
    mvprintw(row, col, "%*s : ", COLS / 4, name);
    addch(code);
    return n + 1;
}

static void
show_acs_chars(void)
/* display the ACS character set */
{
    int n;

#define BOTH(name) #name, name

    erase();
    attron(A_BOLD);
    mvaddstr(0, 20, "Display of the ACS Character Set");
    attroff(A_BOLD);
    refresh();

    n = show_1_acs(0, BOTH(ACS_ULCORNER));
    n = show_1_acs(n, BOTH(ACS_URCORNER));
    n = show_1_acs(n, BOTH(ACS_LLCORNER));
    n = show_1_acs(n, BOTH(ACS_LRCORNER));

    n = show_1_acs(n, BOTH(ACS_LTEE));
    n = show_1_acs(n, BOTH(ACS_RTEE));
    n = show_1_acs(n, BOTH(ACS_TTEE));
    n = show_1_acs(n, BOTH(ACS_BTEE));

    n = show_1_acs(n, BOTH(ACS_HLINE));
    n = show_1_acs(n, BOTH(ACS_VLINE));

    n = show_1_acs(n, BOTH(ACS_LARROW));
    n = show_1_acs(n, BOTH(ACS_RARROW));
    n = show_1_acs(n, BOTH(ACS_UARROW));
    n = show_1_acs(n, BOTH(ACS_DARROW));

    n = show_1_acs(n, BOTH(ACS_BLOCK));
    n = show_1_acs(n, BOTH(ACS_BOARD));
    n = show_1_acs(n, BOTH(ACS_LANTERN));
    n = show_1_acs(n, BOTH(ACS_BULLET));
    n = show_1_acs(n, BOTH(ACS_CKBOARD));
    n = show_1_acs(n, BOTH(ACS_DEGREE));
    n = show_1_acs(n, BOTH(ACS_DIAMOND));
    n = show_1_acs(n, BOTH(ACS_PLMINUS));
    n = show_1_acs(n, BOTH(ACS_PLUS));

    n = show_1_acs(n, BOTH(ACS_GEQUAL));
    n = show_1_acs(n, BOTH(ACS_NEQUAL));
    n = show_1_acs(n, BOTH(ACS_LEQUAL));

    n = show_1_acs(n, BOTH(ACS_STERLING));
    n = show_1_acs(n, BOTH(ACS_PI));
    n = show_1_acs(n, BOTH(ACS_S1));
    n = show_1_acs(n, BOTH(ACS_S3));
    n = show_1_acs(n, BOTH(ACS_S7));
    n = show_1_acs(n, BOTH(ACS_S9));
}

static void
acs_display(void)
{
    int c = 'a';

    do {
	switch (c) {
	case 'a':
	    show_acs_chars();
	    break;
	case 'b':
	    show_box_chars();
	    break;
	case '0':
	case '1':
	case '2':
	case '3':
	    show_upper_chars((c - '0') * 32 + 128);
	    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");
	refresh();
    } while ((c = Getchar()) != 'x' && c != 'q');

    Pause();
    erase();
    endwin();
}

#if USE_WIDEC_SUPPORT
static void
show_upper_widechars(int first, int repeat)
{
    cchar_t temp;
    wchar_t code;
    int last = first + 31;

    erase();
    attron(A_BOLD);
    mvprintw(0, 20, "Display of Character Codes %d to %d", first, last);
    attroff(A_BOLD);

    for (code = first; code <= last; code++) {
	int row = 4 + ((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;

	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);
	do {
	    /*
	     * 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().
	     */
	    echo_wchar(&temp);
	} while (--count > 0);
    }
}

static int
show_1_wacs(int n, const char *name, const cchar_t * code)
{
    const int height = 16;
    int row = 4 + (n % height);
    int col = (n / height) * COLS / 2;
    mvprintw(row, col, "%*s : ", COLS / 4, name);
    add_wchnstr(code, 1);
    return n + 1;
}

static void
show_wacs_chars(void)
/* display the wide-ACS character set */
{
    int n;

/*#define BOTH2(name) #name, &(name) */
#define BOTH2(name) #name, name

    erase();
    attron(A_BOLD);
    mvaddstr(0, 20, "Display of the Wide-ACS Character Set");
    attroff(A_BOLD);
    refresh();

    n = show_1_wacs(0, BOTH2(WACS_ULCORNER));
    n = show_1_wacs(n, BOTH2(WACS_URCORNER));
    n = show_1_wacs(n, BOTH2(WACS_LLCORNER));
    n = show_1_wacs(n, BOTH2(WACS_LRCORNER));

    n = show_1_wacs(n, BOTH2(WACS_LTEE));
    n = show_1_wacs(n, BOTH2(WACS_RTEE));
    n = show_1_wacs(n, BOTH2(WACS_TTEE));
    n = show_1_wacs(n, BOTH2(WACS_BTEE));

    n = show_1_wacs(n, BOTH2(WACS_HLINE));
    n = show_1_wacs(n, BOTH2(WACS_VLINE));

    n = show_1_wacs(n, BOTH2(WACS_LARROW));
    n = show_1_wacs(n, BOTH2(WACS_RARROW));
    n = show_1_wacs(n, BOTH2(WACS_UARROW));
    n = show_1_wacs(n, BOTH2(WACS_DARROW));

    n = show_1_wacs(n, BOTH2(WACS_BLOCK));
    n = show_1_wacs(n, BOTH2(WACS_BOARD));
    n = show_1_wacs(n, BOTH2(WACS_LANTERN));
    n = show_1_wacs(n, BOTH2(WACS_BULLET));
    n = show_1_wacs(n, BOTH2(WACS_CKBOARD));
    n = show_1_wacs(n, BOTH2(WACS_DEGREE));
    n = show_1_wacs(n, BOTH2(WACS_DIAMOND));
    n = show_1_wacs(n, BOTH2(WACS_PLMINUS));
    n = show_1_wacs(n, BOTH2(WACS_PLUS));

#ifdef CURSES_WACS_ARRAY
    n = show_1_wacs(n, BOTH2(WACS_GEQUAL));
    n = show_1_wacs(n, BOTH2(WACS_NEQUAL));
    n = show_1_wacs(n, BOTH2(WACS_LEQUAL));

    n = show_1_wacs(n, BOTH2(WACS_STERLING));
    n = show_1_wacs(n, BOTH2(WACS_PI));
    n = show_1_wacs(n, BOTH2(WACS_S1));
    n = show_1_wacs(n, BOTH2(WACS_S3));
    n = show_1_wacs(n, BOTH2(WACS_S7));
    n = show_1_wacs(n, BOTH2(WACS_S9));
#endif
}

static void
show_wbox_chars(void)
{
    erase();
    attron(A_BOLD);
    mvaddstr(0, 20, "Display of the Wide-ACS Line-Drawing Set");
    attroff(A_BOLD);
    refresh();
    box_set(stdscr, 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);
    /* *INDENT-ON* */

}

static int
show_2_wacs(int n, const char *name, const char *code)
{
    const int height = 16;
    int row = 4 + (n % height);
    int col = (n / height) * COLS / 2;
    char temp[80];

    mvprintw(row, col, "%*s : ", COLS / 4, name);
    addstr(strcpy(temp, code));
    return n + 1;
}

static void
show_utf8_chars(void)
/* display the wide-ACS character set */
{
    int n;

    erase();
    attron(A_BOLD);
    mvaddstr(0, 20, "Display of the Wide-ACS Character Set");
    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");
    /* *INDENT-ON* */

}

static void
wide_acs_display(void)
{
    int c = 'a';
    int digit = 0;
    int repeat = 0;

    do {
	switch (c) {
	case 'a':
	    show_wacs_chars();
	    break;
	case 'b':
	    show_wbox_chars();
	    break;
	case 'u':
	    show_utf8_chars();
	    break;
	default:
	    if (isdigit(c))
		digit = (c - '0');
	    else if (c == '+')
		++digit;
	    else if (c == '-' && digit > 0)
		--digit;
	    else if (c == '>')
		++repeat;
	    else if (c == '<' && repeat > 0)
		--repeat;
	    else {
		beep();
		break;
	    }
	    show_upper_widechars(digit * 32 + 128, repeat);
	    break;
	}
	mvprintw(LINES - 2, 0,
		 "Select: a WACS, b box, u UTF-8, 0-9,+/- non-ASCII, </> repeat, q=quit");
	refresh();
    } while ((c = Getchar()) != 'x' && c != 'q');

    Pause();
    erase();
    endwin();
}

#endif

/*
 * Graphic-rendition test (adapted from vttest)
 */
static void
test_sgr_attributes(void)
{
    int pass;

    for (pass = 0; pass < 2; pass++) {
	int normal = ((pass == 0 ? A_NORMAL : A_REVERSE)) | BLANK;

	/* Use non-default colors if possible to exercise bce a little */
	if (has_colors()) {
	    init_pair(1, COLOR_WHITE, COLOR_BLUE);
	    normal |= COLOR_PAIR(1);
	}
	bkgdset(normal);
	erase();
	mvprintw(1, 20, "Graphic rendition test pattern:");

	mvprintw(4, 1, "vanilla");

#define set_sgr(mask) bkgdset((normal^(mask)));
	set_sgr(A_BOLD);
	mvprintw(4, 40, "bold");

	set_sgr(A_UNDERLINE);
	mvprintw(6, 6, "underline");

	set_sgr(A_BOLD | A_UNDERLINE);
	mvprintw(6, 45, "bold underline");

	set_sgr(A_BLINK);
	mvprintw(8, 1, "blink");

	set_sgr(A_BLINK | A_BOLD);
	mvprintw(8, 40, "bold blink");

	set_sgr(A_UNDERLINE | A_BLINK);
	mvprintw(10, 6, "underline blink");

	set_sgr(A_BOLD | A_UNDERLINE | A_BLINK);
	mvprintw(10, 45, "bold underline blink");

	set_sgr(A_REVERSE);
	mvprintw(12, 1, "negative");

	set_sgr(A_BOLD | A_REVERSE);
	mvprintw(12, 40, "bold negative");

	set_sgr(A_UNDERLINE | A_REVERSE);
	mvprintw(14, 6, "underline negative");

	set_sgr(A_BOLD | A_UNDERLINE | A_REVERSE);
	mvprintw(14, 45, "bold underline negative");

	set_sgr(A_BLINK | A_REVERSE);
	mvprintw(16, 1, "blink negative");

	set_sgr(A_BOLD | A_BLINK | A_REVERSE);
	mvprintw(16, 40, "bold blink negative");

	set_sgr(A_UNDERLINE | A_BLINK | A_REVERSE);
	mvprintw(18, 6, "underline blink negative");

	set_sgr(A_BOLD | A_UNDERLINE | A_BLINK | A_REVERSE);
	mvprintw(18, 45, "bold underline blink negative");

	bkgdset(normal);
	mvprintw(LINES - 2, 1, "%s background. ", pass == 0 ? "Dark" :
		 "Light");
	clrtoeol();
	Pause();
    }

    bkgdset(A_NORMAL | BLANK);
    erase();
    endwin();
}

/****************************************************************************
 *
 * Windows and scrolling tester.
 *
 ****************************************************************************/

#define BOTLINES	4	/* number of line stolen from screen bottom */

typedef struct {
    int y, x;
} pair;

#define FRAME struct frame
FRAME
{
    FRAME *next, *last;
    bool do_scroll;
    bool do_keypad;
    WINDOW *wind;
};

#ifdef NCURSES_VERSION
#define keypad_active(win) (win)->_use_keypad
#define scroll_active(win) (win)->_scroll
#else
#define keypad_active(win) FALSE
#define scroll_active(win) FALSE
#endif

/* We need to know if these flags are actually set, so don't look in FRAME.
 * These names are known to work with SVr4 curses as well as ncurses.  The
 * _use_keypad name does not work with Solaris 8.
 */
static bool
HaveKeypad(FRAME * curp)
{
    WINDOW *win = (curp ? curp->wind : stdscr);
    return keypad_active(win);
}

static bool
HaveScroll(FRAME * curp)
{
    WINDOW *win = (curp ? curp->wind : stdscr);
    return scroll_active(win);
}

static void
newwin_legend(FRAME * curp)
{
    static const struct {
	const char *msg;
	int code;
    } legend[] = {
	{
	    "^C = create window", 0
	},
	{
	    "^N = next window", 0
	},
	{
	    "^P = previous window", 0