curses库使用

最新推荐文章于 2024-02-18 11:30:25 发布

「已注销」

最新推荐文章于 2024-02-18 11:30:25 发布

阅读量2.1k

点赞数 3

分类专栏： Linux应用文章标签： linux

原文链接：https://www.cnblogs.com/dandingyy/archive/2012/08/23/2651644.html

版权

Linux应用专栏收录该内容

17 篇文章 3 订阅

订阅专栏

文章目录

curses术语和概念
屏幕
键盘
窗口
通用函数
移动和更新窗口
优化屏幕刷新
子窗口
keypad模式
彩色显示
pad

curses术语和概念

stdscr是指curses窗口，它与显示器的物理屏幕的尺寸完全一样。curses函数库用两个数据结构来映射终端屏幕，即stdscr和curscr。

stdscr：对应的是标准屏幕，它的工作方式与stdout相似，是curses程序中的默认输出窗口。
curscr：对应的是当前屏幕，在程序调用refresh函数之前，输出到stdscr上的内容不会显示在屏幕上。curses函数库会在refresh函数被调用时比较stdscr与第二个数据结构curscr之间的不同之处，然后用这两个数据结构之间的差异来刷新屏幕。

逻辑屏幕的布局通过一个字符数组来实现，它以屏幕的左上角即坐标(0, 0)为起点，通过行号和列号来组织。所有cueses函数使用的坐标都是y值(行号)在前，x值(列号)在后。每个位置不仅包含该屏幕处的字符，还包含它的属性(粗体、下划线、反白显示、色彩)。

#include <unistd.h>
#include <stdlib.h>
#include <ncurses.h>

int main() {
    initscr();
    move ( 5, 15 );
    printw ( "%s", "Hello World" );
    refresh();
    sleep ( 2 );
    endwin();
    exit ( EXIT_SUCCESS );
}

由于curses函数库在使用时需要创建和删除一些临时的数据结构，所以所有的curses程序必须在开始使用curses函数库之前对其进行初始化，并在结束使用后允许curses恢复原先设置。这两项工作由initscr和endwin函数分别完成。

屏幕

initscr函数与endwin函数：所有的curses程序必须以initscr函数开始，以endwin函数结束。initscr函数原型如下：

#include <curses.h>
WINDOW *initscr ( void );

如果成功，它返回一个指向stdscr结构的指针；如果失败，输出一条诊断错误信息并使程序退出。initscr函数在一个程序中只能调用一次。
endwin函数原型如下：

int endwin ( void );

调用成功时返回OK，失败时返回ERR。
输出到屏幕：curses函数库提供了一些用于刷新屏幕的基本函数。chtype等同于unsigned long，由typedef定义。

#include <curses.h>

int addch ( const chtype char_to_add ); /* 在光标的当前位置添加指定的字符 */
int addchstr ( chtype *const string_to_add ); /* 在光标的当前位置添加指定的字符串 */
int printw ( char *format, ... ); /* 对字符串进行格式化，并将其添加到光标的当前位置 */
int refresh ( void ); /* 刷新物理屏幕，成功时返回OK，错误时返回ERR */
int box ( WINDOW *win_ptr, chtype vertical_char, chtype horizontal_char ); /* 用来围绕一个窗口绘制方框 */
int insch ( chtype char_to_insert ); /* 插入一个字符，将已有的字符向右移 */
int insertIn ( void ); /* 插入一个空白行，将现有行依次向下移一行 */
int delch ( void ); /* 删除一个字符，将已有的字符向左移 */
int deleteIn ( void ); /* 删除一行，将现有行向上移一行 */
int beep ( void ); /* 在终端上发出声音 */
int flash ( void ); /* 使屏幕闪烁 */

清除屏幕：清除屏幕上的某个区域主要有4种方法：

#include <curses.h>
int erase ( void ); /* 在每个屏幕位置写上空白字符 */
int clear ( void ); /* 用于清屏，但在下次调用refresh函数时重现屏幕原文 */
int clrtobot ( void ); /* 清除当前光标位置直到屏幕结尾的所有内容 */
int clrtoeol ( void ); /* 清除当前光标位置直到光标所处行行尾的所有内容 */

move函数：用来将逻辑光标的位置移到指定地点，屏幕坐标以左上角(0, 0)为起点。并且有两个包含物理屏幕尺寸大小的外部整数LINES和COLUMNS，它们可用于决定参数new_y和new_x的最大值。

#include <curses.h>
int move ( int new_y, int new_x );

调用move函数本身并不会使物理光标移动，它仅改变逻辑屏幕上的光标位置，下次的输出内容就将出现在该位置上。如果希望物理屏幕上的光标位置在调用move函数之后立刻有变化，则需在它之后立刻调用refresh函数
leaveok函数：设置一个标志，该标志用于控制在屏幕刷新后curses将物理光标放置的位置：

#include <curses.h>
int leaveok ( WINDOW *window_ptr, bool leave_flag );

默认情况下，该标志为false，意为屏幕刷新后，硬件光标将停留在屏幕上逻辑光标所处的位置；如果该标志设置为true，则硬件光标会被随机地放置在屏幕上的任意位置。一般来说，默认选项更符合用户的需求，这能确保光标停留在一个有意义的位置。
字符属性：每个curses字符都可以有一些属性用于控制该字符在屏幕上的显示方式，前提是用于显示的硬件设备能够支持要求的属性。预定义的属性有A_BLINK、A_BOLD、A_DIM、A_REVERSE、A_STANDOUT和A_UNDERLINE。

属性	说明
`A_NORMAL`	Normal display (no highlight)
`A_STANDOUT`	Best highlighting mode of the terminal
`A_UNDERLINE`	Underlining
`A_REVERSE`	Reverse video
`A_BLINK`	Blinking
`A_DIM`	Half bright
`A_BOLD`	Extra bright or bold
`A_PROTECT`	Protected mode
`A_INVIS`	Invisible or blank mode
`A_ALTCHARSET`	Alternate character set

函数如下：

#include <curses.h>

int attron ( chtype attribute ); /* 启用指定的属性 */
int attroff ( chtype attribute ); /* 关闭指定的属性 */
int attrset ( chtype attribute ); /* 设置curses属性 */
int standout ( void ); /* 提供了一种强调或“突出”模式，在大多数终端上，通常被映射为反白显示 */

示例代码如下：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <curses.h>

int main() {
    const char witch_one[] = " First Witch  ";
    const char witch_two[] = " Second Witch  ";
    const char *scan_ptr;
    initscr();
    move ( 5, 15 );
    attron ( A_BOLD );
    printw ( "%s", "Macbeth" );
    attroff ( A_BOLD );
    refresh();
    sleep ( 1 );
    move ( 8, 15 );
    attron ( A_STANDOUT );
    printw ( "%s", "Thunder and Lightning" );
    attroff ( A_STANDOUT );
    refresh();
    sleep ( 1 );
    move ( 10, 10 );
    printw ( "%s", "When shall we three meet again" );
    move ( 11, 23 );
    printw ( "%s", "In thunder, lightning, or in rain?" );
    move ( 13, 10 );
    printw ( "%s", "When the hurlyburly's done," );
    move ( 14, 23 );
    printw ( "%s", "When the battle's lost and won." );
    refresh();
    sleep ( 1 );
    attron ( A_DIM );
    scan_ptr = witch_one + strlen ( witch_one ) - 1;

    while ( scan_ptr != witch_one ) {
        move ( 10, 10 );
        insch ( *scan_ptr-- );
    }

    scan_ptr = witch_two + strlen ( witch_two ) - 1;

    while ( scan_ptr != witch_two ) {
        move ( 13, 10 );
        insch ( *scan_ptr-- );
    }

    attroff ( A_DIM );
    refresh();
    sleep ( 1 );
    move ( LINES - 1, COLS - 1 );
    refresh();
    sleep ( 1 );
    endwin();
    exit ( EXIT_SUCCESS );
}

输出效果：先在第5行第15列的位置输出Macbeth加粗，再在第8行第15列的位置输出Thunder and Lightning加亮。之后很短的间隔，在第10行第10列的位置输出When shall we three meet again，在第11行第23列的位置同时输出In thunder, lightning, or in rain?，在第13行第10列的位置同时输出When the hurlyburly's done,，在第14行第23列的位置同时输出When the battle's lost and won.。再经过很短的间隔，在第一句和第三句前分别加上两个数组的内容。在第10行第10列的位置插入(space)First Witch(space)(space)，在第13行第10列的位置同时插入(space)Second Witch(space)(space)。

键盘

输入字符的回显：键盘读取例程由键盘模式控制。用于设置键盘模式的函数有：

#include <curses.h>
int echo ( void );
int noecho ( void );

用于开启或关闭输入字符的回显功能。键盘模式如下：

cooked：所有处理是基于行的。
cbreak：字符一经键入，就立刻被传送给程序。

以下函数用于控制在终端上输入的字符传送给curses程序的方式：

int cbreak ( void );
int nocbreak ( void );

当curses程序通过调用initscr函数开始运行时，输入模式被设置为预处理模式(或称cooked模式)。这意味着所有处理都是基于行的，也就是说，只有在用户按下回车键后，输入的数据才会被传送给程序。在该模式下，键盘特殊字符被启用，所以按下合适的组合键即可在程序中产生一个信号。程序可通过调用cbreak函数将输入模式设置为cbreak模式，在这种模式下，字符一经键入就立刻被传递给程序，在此模式下，键盘特殊字符也被启用。但一些简单的字符，如Backspace会直接传递给程序处理，所以如果想让退格键保底原来的功能，就必须自己在程序中实现它。
关闭特殊字符的处理：

int raw ( void );
int noraw ( void );

raw函数调用的作用是关闭特殊字符的处理，所以执行该函数调用后，再想通过输入特殊字符序列来产生信号或进行流控就不可能了。noraw函数调用同时恢复cooked模式和特殊字符处理模式。
键盘输入：

#include <curses.h>
int getch ( void );
int getstr ( char *string );
int getnstr ( char *string, int number_of_characters );
int scanw ( char *format, ... );

类似于getchar、gets和scanf，但要注意的是，getstr函数对其返回的字符串的长度没有限制，要尽可能使用getnstr来代替getstr。

#include <unistd.h>
#include <stdlib.h>
#include <curses.h>
#include <string.h>

#define PW_LEN 256
#define NAME_LEN 256

int main() {
    char name[NAME_LEN];
    char password[PW_LEN];
    const char *real_password = "xyzzy";
    int i = 0;

    initscr();
    move ( 5, 10 );
    printw ( "%s", "Please login:" );
    move ( 7, 10 );
    printw ( "%s", "User name: " );
    getstr ( name );
    move ( 8, 10 );
    printw ( "%s", "Password: " );
    refresh();
    cbreak();
    noecho();
    memset ( password, '\0', sizeof ( password ) );

    while ( i < PW_LEN ) {
        password[i] = getch();

        if ( password[i] == '\n' ) {
            break;
        }

        move ( 8, 20 + i );
        addch ( '*' );
        refresh();
        i++;
    }

    echo();
    nocbreak();
    move ( 11, 10 );

    if ( strncmp ( real_password, password, strlen ( real_password ) ) == 0 ) {
        printw ( "%s", "Correct" );
    } else {
        printw ( "%s", "Wrong" );
    }

    printw ( "%s", " password" );
    refresh();
    sleep ( 2 );
    endwin();
    exit ( EXIT_SUCCESS );
}

在第5行第10列的位置输出Please login:，在第7行第10列的位置输出User name:(space)。输入用户名(随意命名)，然后回车。在第8行第10列的位置输出Password:(space)，然后输入密码；若密码不为xyzzy，在第11行第10列的位置输出Wrong password，有背景填充；若相符，则在第11行第10列的位置输出Correct password，无背景。

窗口

以上程序一直将终端作为一个全屏幕的输出介质，但curses函数库在物理屏幕上可同时显示多个不同尺寸的窗口。
WINDOW结构：标准屏幕stdscr只是WINDOW结构的一个特例，就像标准输出stdout是文件流的一个特例一样。可以用函数调用newwin和delwin来创建和销毁窗口。newwin函数原型如下：

#include <curses.h>
WINDOW *newwin ( int num_of_lines, int num_of_cols, int start_y, intstart_x );

该窗口从屏幕位置(start_y, start_x)开始，行数和列数分别由参数num_of_lines和num_of_cols指定。如果想让新窗口的右下角正好落在屏幕的右下角上，可以将函数的行、列参数设为0。该函数返回一个指向新窗口的指针，如果新窗口创建失败则返回null。
注意，所有的窗口范围都必须在当前屏幕范围之内，如果新窗口的任何部分落在当前屏幕范围之外，则newwin函数调用失败；通过newwin函数创建的新窗口完全独立于所有已存在的窗口。默认情况下，它被放置在任何已有窗口之上，覆盖(但不是改变)它们的内容。
delwin函数原型如下：

int delwin ( WINDOW *window_to_delete );

因为调用newwin函数可能会给新窗口分配内存，所以当不再需要这些窗口时，不要忘记通过delwin函数将其删除。注意，不要删除curses自己的窗口stdscr和curscr。

通用函数

在本章中以前学过的函数都可以加上一些前缀变为通用函数。前缀w用于窗口，但必须在该函数的参数表的最前面增加一个WINDOW指针参数；前缀mv用于光标移动，但需要在函数的参数表的最前面增加两个参数，分别是纵坐标y和横坐标x，这两个坐标值指定了执行操作的位置。坐标值y和x是相对于窗口而不是相对于屏幕的，坐标(0, 0)代表窗口的左上角；前缀mvw用于在窗口中移动光标，但需要传递3个参数，即一个WINDOW指针、y和x坐标值，并且WINDOW指针参数总是出现在屏幕坐标值之前。

#include <curses.h>
int addch ( const chtype char );
int waddch ( WINDOW *window_pointer, const chtype char );
int mvaddch ( int y, int x, const chtype char );
int mvwaddch ( WINDOW *window_pointer, int y, int x, const chtype char );
int printw ( char *format, ... );
int wprintw ( WINDOW *window_pointer, char *format, ... );
int mvprintw ( int, intx, char *format, ... );
int mvwprintw ( WINDOW *window_pointer, int y, int x, char *format, ... );

移动和更新窗口

通过以下函数，可以移动和重新绘制窗口：

#include <curses.h>
int mvwin ( WINDOW *window_to_move, int new_y, int new_x );

因为不允许窗口的任何部分超出屏幕范围，所以如果在调用mvwin函数时，将窗口的某个部分移动到屏幕区域之外，mvwin函数调用将会失败。

int wrefresh ( WINDOW *window_ptr );
int wclear ( WINDOW *window_ptr );
int werase ( WINDOW *window_ptr );
int touchwin ( WINDOW *window_ptr;

通过curses函数库，其指针参数指向的窗口内容已发生改变。这就意味着在下次调用wrefresh函数时，curses必须重新绘制该窗口，即使用户实际上并未修改该窗口中的内容。当屏幕上重叠着多个窗口时，可以通过该函数来安排要显示的窗口。

int scrollok ( WINDOW *window_ptr, bool scroll_flag );

该函数控制着窗口的卷屏。如果传递给scrollok函数的是布尔值true(通常是非零值)，则允许窗口卷屏。在默认情况下，窗口是不能卷屏的。

int scroll ( WINDOW *window_ptr );

该函数是把窗口内容上卷一行。

#include <unistd.h>
#include <stdlib.h>
#include <curses.h>

int main() {
    WINDOW *new_window_ptr;
    WINDOW *popup_window_ptr;
    int x_loop;
    int y_loop;
    char a_letter = 'a';

    initscr();
    move ( 5, 5 );
    printw ( "%s", "Testing multiple windows" );
    refresh();
    sleep ( 2 );

    for ( x_loop = 0; x_loop < COLS - 1; x_loop++ ) { /* COLS指现在屏幕列数 */
        for ( y_loop = 0; y_loop < LINES - 1; y_loop++ ) { /* LINES指现在屏幕行数 */
            mvwaddch ( stdscr, y_loop, x_loop, a_letter );
            a_letter++;

            if ( a_letter > 'z' ) {
                a_letter = 'a';
            }
        }
    }

    refresh();
    sleep ( 5 );
    new_window_ptr = newwin ( 10, 20, 5, 5 );
    mvwprintw ( new_window_ptr, 2, 2, "%s", "Hello World" );
    mvwprintw ( new_window_ptr, 5, 2, "%s", "Notice howvery long lines wrap inside the window" );
    wrefresh ( new_window_ptr );
    sleep ( 2 );
    a_letter = '0';

    for ( x_loop = 0; x_loop < COLS - 1; x_loop++ ) {
        for ( y_loop = 0; y_loop < LINES - 1; y_loop++ ) {
            mvwaddch ( stdscr, y_loop, x_loop, a_letter );
            a_letter++;

            if ( a_letter > '9' ) {
                a_letter = '0';
            }
        }
    }

    refresh();
    sleep ( 2 );
    wrefresh ( new_window_ptr );
    sleep ( 2 );
    touchwin ( new_window_ptr );
    wrefresh ( new_window_ptr );
    sleep ( 2 );
    popup_window_ptr = newwin ( 10, 20, 8, 8 );
    box ( popup_window_ptr, '|', '-' );
    mvwprintw ( popup_window_ptr, 5, 2, "%s", "Pop UpWindow!" );
    wrefresh ( popup_window_ptr );
    sleep ( 2 );
    touchwin ( new_window_ptr );
    wrefresh ( new_window_ptr );
    sleep ( 2 );
    wclear ( new_window_ptr );
    wrefresh ( new_window_ptr );
    sleep ( 2 );
    delwin ( new_window_ptr );
    touchwin ( popup_window_ptr );
    wrefresh ( popup_window_ptr );
    sleep ( 2 );
    delwin ( popup_window_ptr );
    touchwin ( stdscr );
    refresh();
    sleep ( 2 );
    endwin();
    exit ( EXIT_SUCCESS );
}

newwin(10, 20, 5, 5)参数的含义如下：

10：num_of_lines，窗口的行数为10行。
20：num_of_cols，窗口的列数为20列。
5：start_y，该窗口从屏幕位置第5行开始。
5：start_x，该窗口从屏幕位置第5列开始。

为什么要使用touchwin？因为通过curses函数库其指针参数指向的窗口内容已发生改变。这就意味着在下次调用wrefresh函数时，curses必须重新绘制该窗口，即使用户实际上并未修改该窗口中的内容。所以当屏幕上重叠着多个窗口时，可以通过该函数来安排要显示的窗口。

优化屏幕刷新

为了尽量减少需要在屏幕上绘制的字符数目，curses函数库为此提供了一种特殊手段，这需要使到下面2个函数：

#include <curses.h>
int wnoutrefresh ( WINDOW *window_ptr );
int doupdate ( void );

wnoutrefresh函数用于决定把哪些字符发送到屏幕上，但它并不真正地发送这些字符，真正将更新发送到终端的工作由doupdate函数来完成。如果只是调用wnoutrefresh函数，然后立刻调用doupdate函数，则它的效果与直接调用wrefresh完全一样。
但如果想重新绘制多个窗口，可以为每个窗口分别调用wnoutrefresh函数，然后只需在调用最后一个wnoutrefresh之后调用一次doupdate函数即可。这允许curses依次为每个窗口执行屏幕更新计算工作，最后仅把最终的更新结果输出到屏幕上，这种做法可以最大限度地减少curses需要发送的字符数目。

子窗口

子窗口的创建和删除可以用以下几个函数来完成：

#include <curses.h>
WINDOW *subwin ( WINDOW *parent, intnum_of_lines, int num_of cols, int start_y, int start_x );
int delwin ( WINDOW *window_to_delete );

子窗口与新窗口(newwin)的重要区别是，子窗口没有自己独立的屏幕字符存储空间，它们与其父窗口(在创建子窗口时指定)共享同一字符存储空间。这意味着，对子窗口中内容的任何修改都会反映到其父窗口中，所以删除子窗口时，屏幕显示不会发生任何变化。
子窗口的用途是，提供了一种简洁的方式来卷动另一窗口里的部分内容。编写curses程序时，经常会需要卷动屏幕的某个小区域。通过将这个小区域定义为一个子窗口，然后对其卷动，就能达到这种效果。

#include <unistd.h>
#include <stdlib.h>
#include <curses.h>

int main() {
    WINDOW *sub_window_ptr;
    int x_loop;
    int y_loop;
    int counter;
    char a_letter = '1';

    initscr();

    for ( y_loop = 0; y_loop < LINES - 1; y_loop++ ) {
        for ( x_loop = 0; x_loop < COLS - 1; x_loop++ ) {
            mvwaddch ( stdscr, y_loop, x_loop, a_letter );
            a_letter++;

            if ( a_letter > '9' ) {
                a_letter = '1';
            }
        }
    }

    sub_window_ptr = subwin ( stdscr, 10, 20, 10, 10 );
    scrollok ( sub_window_ptr, 1 );
    touchwin ( stdscr );
    refresh();
    sleep ( 1 );
    werase ( sub_window_ptr );
    mvwprintw ( sub_window_ptr, 2, 0, "%s", "This window willnow scroll" );
    wrefresh ( sub_window_ptr );
    sleep ( 1 );

    for ( counter = 1; counter < 10; counter++ ) {
        wprintw ( sub_window_ptr, "%s", "This text is both wrappingand scrolling." );
        wrefresh ( sub_window_ptr );
        sleep ( 1 );
    }

    delwin ( sub_window_ptr );
    touchwin ( stdscr );
    refresh();
    sleep ( 1 );
    endwin();
    exit ( EXIT_SUCCESS );
}

简要描述子窗口的处理过程：

subwin创建子窗口并且指定与其父窗口共享同一字符存储空间，子窗口只占一个指定的小区域。提供了一种简洁的方式来卷动另一窗口里的部分内容。允许子窗口卷屏，卷动其所在屏幕的某个小区域。
利用touchwin函数来安排要显示的窗口，使子窗口在指定位置输出指定字符，更新间隔很短。
delwin删除已显示过的子窗口，删除子窗口时，屏幕显示不会发生任何变化。

keypad模式

键盘上的方向键、功能键及数字小键盘等按键会发送以escape字符开头的字符串序列。curses函数库提供了一个用于管理功能键的功能。头文件curses.h通过一组以KEY_为前缀的定义来管理逻辑键。Keypad模式是指按键转义序列，此时读键盘操作不仅能够返回用户按下的键，还将返回与逻辑按键对应的KEY_定义(在curses.h头文件中定义)。

#define KEY_CODE_YES    0400           /* A wchar_t contains a key code      */
#define KEY_MIN         0401           /* Minimum curses key                 */
#define KEY_BREAK       0401           /* Break key (unreliable)             */
#define KEY_SRESET      0530           /* Soft (partial) reset(unreliable)   */
#define KEY_RESET       0531           /* Reset or hard reset(unreliable)    */
#define KEY_DOWN        0402           /* down-arrow key                     */
#define KEY_UP          0403           /* up-arrow key                       */
#define KEY_LEFT        0404           /* left-arrow key                     */
#define KEY_RIGHT       0405           /* right-arrow key                    */
#define KEY_HOME        0406           /* home key                           */
#define KEY_BACKSPACE   0407           /* backspace key                      */
#define KEY_F0          0410           /* Function keys. Space for 64        */
#define KEY_F(n)        (KEY_F0 + (n)) /* Value of function key n            */
#define KEY_DL          0510           /* delete-line key                    */
#define KEY_IL          0511           /* insert-line key                    */
#define KEY_DC          0512           /* delete-character key               */
#define KEY_IC          0513           /* insert-character key               */
#define KEY_EIC         0514           /* sent by rmir or smir in insertmode */
#define KEY_CLEAR       0515           /* clear-screen or erase key          */
#define KEY_EOS         0516           /* clear-to-end-of-screen key         */
#define KEY_EOL         0517           /* clear-to-end-of-line key           */
#define KEY_SF          0520           /* scroll-forward key                 */
#define KEY_SR          0521           /* scroll-backward key                */
#define KEY_NPAGE       0522           /* next-page key                      */
#define KEY_PPAGE       0523           /* previous-page key                  */
#define KEY_STAB        0524           /* set-tab key                        */
#define KEY_CTAB        0525           /* clear-tab key                      */
#define KEY_CATAB       0526           /* clear-all-tabs key                 */
#define KEY_ENTER       0527           /* enter/send key                     */
#define KEY_PRINT       0532           /* print key                          */
#define KEY_LL          0533           /* lower-left key (home down)         */
#define KEY_A1          0534           /* upper left of keypad               */
#define KEY_A3          0535           /* upper right of keypad              */
#define KEY_B2          0536           /* center of keypad                   */
#define KEY_C1          0537           /* lower left of keypad               */
#define KEY_C3          0540           /* lower right of keypad              */
#define KEY_BTAB        0541           /* back-tab key                       */
#define KEY_BEG         0542           /* begin key                          */
#define KEY_CANCEL      0543           /* cancel key                         */
#define KEY_CLOSE       0544           /* close key                          */
#define KEY_COMMAND     0545           /* command key                        */
#define KEY_COPY        0546           /* copy key                           */
#define KEY_CREATE      0547           /* create key                         */
#define KEY_END         0550           /* end key                            */
#define KEY_EXIT        0551           /* exit key                           */
#define KEY_FIND        0552           /* find key                           */
#define KEY_HELP        0553           /* help key                           */
#define KEY_MARK        0554           /* mark key                           */
#define KEY_MESSAGE     0555           /* message key                        */
#define KEY_MOVE        0556           /* move key                           */
#define KEY_NEXT        0557           /* next key                           */
#define KEY_OPEN        0560           /* open key                           */
#define KEY_OPTIONS     0561           /* options key                        */
#define KEY_PREVIOUS    0562           /* previous key                       */
#define KEY_REDO        0563           /* redo key                           */
#define KEY_REFERENCE   0564           /* reference key                      */
#define KEY_REFRESH     0565           /* refresh key                        */
#define KEY_REPLACE     0566           /* replace key                        */
#define KEY_RESTART     0567           /* restart key                        */
#define KEY_RESUME      0570           /* resume key                         */
#define KEY_SAVE        0571           /* save key                           */
#define KEY_SBEG        0572           /* shifted begin key                  */
#define KEY_SCANCEL     0573           /* shifted cancel key                 */
#define KEY_SCOMMAND    0574           /* shifted command key                */
#define KEY_SCOPY       0575           /* shifted copy key                   */
#define KEY_SCREATE     0576           /* shifted create key                 */
#define KEY_SDC         0577           /* shifted delete-character key       */
#define KEY_SDL         0600           /* shifted delete-line key            */
#define KEY_SELECT      0601           /* select key                         */
#define KEY_SEND        0602           /* shifted end key                    */
#define KEY_SEOL        0603           /* shifted clear-to-end-of-linekey    */
#define KEY_SEXIT       0604           /* shifted exit key                   */
#define KEY_SFIND       0605           /* shifted find key                   */
#define KEY_SHELP       0606           /* shifted help key                   */
#define KEY_SHOME       0607           /* shifted home key                   */
#define KEY_SIC         0610           /* shifted insert-character key       */
#define KEY_SLEFT       0611           /* shifted left-arrow key             */
#define KEY_SMESSAGE    0612           /* shifted message key                */
#define KEY_SMOVE       0613           /* shifted move key                   */
#define KEY_SNEXT       0614           /* shifted next key                   */
#define KEY_SOPTIONS    0615           /* shifted options key                */
#define KEY_SPREVIOUS   0616           /* shifted previous key               */
#define KEY_SPRINT      0617           /* shifted print key                  */
#define KEY_SREDO       0620           /* shifted redo key                   */
#define KEY_SREPLACE    0621           /* shifted replace key                */
#define KEY_SRIGHT      0622           /* shifted right-arrow key            */
#define KEY_SRSUME      0623           /* shifted resume key                 */
#define KEY_SSAVE       0624           /* shifted save key                   */
#define KEY_SSUSPEND    0625           /* shifted suspend key                */
#define KEY_SUNDO       0626           /* shifted undo key                   */
#define KEY_SUSPEND     0627           /* suspend key                        */
#define KEY_UNDO        0630           /* undo key                           */
#define KEY_MOUSE       0631           /* Mouse event has occurred           */
#define KEY_RESIZE      0632           /* Terminal resize event              */
#define KEY_EVENT       0633           /* We were interrupted by an event    */
#define KEY_MAX         0777           /* Maximum key value is 0633          */

curses在启动时会关闭转义序列与逻辑键之间的转换功能，该功能需要通过keypad函数来启用：

#include <curses.h>
int keypad ( WINDOW *window_ptr, bool keypad_on );

将keypad_on参数设置为true，然后调用keypad函数来启用keypad模式。函数调用成功时，返回OK；调用失败时，返回ERR。
几种特殊字符(以escape开头的转义序列)如下：

END：键盘End键。
BEGINNING：begin键(没有)。
RIGHT：向右的方向键。
LEFT：向左的方向键。
UP：向上的方向键。
DOWN：向下的方向键。

彩色显示

curses只能以一种非常有限的方式来使用色彩，屏幕上的每个字符位置都有它的前景色或背景色。但curses对字符颜色的定义及其背景色的定义并不能完全独立。必须同时定义一个字符的前景色与背景色，将它们称之为颜色组合(color pair)。
curses颜色例程初始化：

#include <curses.h>
bool has_colors ( void ); /* 如果终端支持颜色，该函数将返回true */
int start_color ( void ); /* 若该函数成功初始化了颜色显示功能，它将返回OK */

一旦start_color函数被成功调用，变量COLOR_PAIRS将被设置为终端所能支持的颜色组合数目的最大值，一般为64(8 * 8)。变量COLORS定义可用颜色数目的最大值，一般只有8种。在内部实现中，每种可用的颜色以一个从0到63的数字作为其唯一的ID号。
对使用的颜色组合进行初始化：在把颜色作为属性使用之前，必须首先调用init_pair函数对准备使用的颜色组合进行初始化，对颜色属性的访问是通过COLOR_PAIR函数来完成的。

#include <curses.h>
int init_pair ( short pair_number, short foreground, short background ); /* 初始化颜色对 */
int COLOR_PAIR ( int pair_number );
int pair_content ( short pair_number, short *foreground, short *background ); /* 获取已定义颜色信息 */

彩色显示代码如下：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <curses.h>

int main() {
    int i;
    initscr();

    if ( !has_colors() ) {
        endwin();
        fprintf ( stderr, "Error - no color support on this terminal\n" );
        exit ( 1 );
    }

    if ( start_color() != OK ) {
        endwin();
        fprintf ( stderr, "Error - could not initialize colors\n" );
        exit ( 2 );
    }

    clear();
    mvprintw ( 5, 5, "There are %d COLORS, and %d COLOR_PAIRS available", \
               COLORS, COLOR_PAIRS );
    refresh();
    init_pair ( 1, COLOR_RED, COLOR_BLACK );
    init_pair ( 2, COLOR_RED, COLOR_GREEN );
    init_pair ( 3, COLOR_GREEN, COLOR_RED );
    init_pair ( 4, COLOR_YELLOW, COLOR_BLUE );
    init_pair ( 5, COLOR_BLACK, COLOR_WHITE );
    init_pair ( 6, COLOR_MAGENTA, COLOR_BLUE );
    init_pair ( 7, COLOR_CYAN, COLOR_WHITE );

    for ( i = 1; i <= 7; i++ ) {
        attroff ( A_BOLD );
        attrset ( COLOR_PAIR ( i ) );
        mvprintw ( 5 + i, 5, "Color pair %d", i );
        attrset ( COLOR_PAIR ( i ) | A_BOLD );
        mvprintw ( 5 + i, 25, "Bold color pair %d", i );
        refresh();
        sleep ( 1 );
    }

    endwin();
    exit ( EXIT_SUCCESS );
}

pad

Pad指一个尺寸大于物理屏幕的逻辑屏幕，可一次只显示该逻辑屏幕的某个部分。在一般情况下，逻辑屏幕不允许大于物理屏幕。Pad结构非常类似于WINDOW结构，所有执行写窗口操作的curses函数同样可用于pad。
创建pad：创建pad的方式与创建正常窗口的方式基本相同：

#include <curses.h>
WINDOW *newpad ( int number_of_lines, int number_of_colums );

pad用delwin函数来删除，这与正常的窗口的删除一样：

int delwin ( WINDOW *window_to_delete );

pad刷新：Pad使用不同的函数执行刷新操作。因为一个pad并不局限于某个特定的屏幕位置，所以必须指定希望放到屏幕上的pad范围及其放置在屏幕上的位置。

#include <curses.h>

int prefresh (
    *WINDOW *pad_ptr,
    int pad_row,
    int pad_column,
    int screen_row_min,
    int screen_col_min,
    int screen_row_max,
    int screen_col_max
);

函数作用是将pad从坐标(pad_row, pad_colum)开始的区域写到屏幕上指定的显示区域，该显示区域的范围从坐标(screen_row_min, screen_col_min)到(screen_row_max, screen_col_max)。
pad的使用示例如下：

#include <unistd.h>
#include <stdlib.h>
#include <curses.h>

int main() {
    WINDOW *pad_ptr;
    int x, y;
    int pad_lines;
    int pad_cols;
    char disp_char;

    initscr();
    /* 定义长度和宽度，大于屏幕 */
    pad_lines = LINES + 50;
    pad_cols = COLS + 50;
    pad_ptr = newpad ( pad_lines, pad_cols );
    disp_char = 'a';

    for ( x = 0; x < pad_lines; x++ ) {
        for ( y = 0; y < pad_cols; y++ ) {
            mvwaddch ( pad_ptr, x, y, disp_char );

            if ( disp_char == 'z' ) {
                disp_char = 'a';
            } else {
                disp_char++;
            }
        }
    }

    /* 将pad的不同区域绘制到屏幕的不同位置上，结束程序 */
    prefresh ( pad_ptr, 5, 7, 2, 2, 9, 9 );
    sleep ( 1 );
    prefresh ( pad_ptr, LINES + 5, COLS + 7, 5, 5, 21, 19 );
    sleep ( 1 );
    delwin ( pad_ptr );
    endwin();
    exit ( EXIT_SUCCESS );
}

「已注销」

关注

3
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
curses库使用

文章目录curses术语和概念屏幕键盘窗口通用函数移动和更新窗口优化屏幕刷新子窗口keypad模式彩色显示padcurses术语和概念 stdscr是指curses窗口，它与显示器的物理屏幕的尺寸完全一样。curses函数库用两个数据结构来映射终端屏幕，即stdscr和curscr。stdscr：对应的是标准屏幕，它的工作方式与stdout相似，是curses程序中的默认输出窗口。curscr：对应的是当前屏幕，在程序调用refresh函数之前，输出到stdscr上的内容不会显示在屏幕上。cur
复制链接

扫一扫