<curses.h>(5)

CURSES

NAME

curses.h — definitions for screen handling and optimisation functions

SYNOPSIS

#include <curses.h>

DESCRIPTION

Objects

The <curses.h> header provides a declaration for COLOR_PAIRS, COLORS, COLS, curscr, LINES and stdscr.

Constants

The following constants are defined:

EOF Function return value for end-of-file

ERR Function return value for failure

FALSE Boolean false value

OK Function return value for success

TRUE Boolean true value

WEOF Wide-character function return value for end-of-file, as defined in <wchar.h>.

Data Types

The following data types are defined through typedef:

attr_t An OR-ed set of attributes

bool Boolean data type

chtype A character, attributes and a colour-pair

SCREEN An opaque terminal representation

wchar_t As described in <stddef.h>

wint_t As described in <wchar.h>

cchar_t References a string of wide characters

WINDOW An opaque window representation

These data types are described in more detail in Data Types in curses_intro.

The inclusion of <curses.h> may make visible all symbols from the headers <stdio.h>, <term.h>, <termios.h> and <wchar.h>.

Attribute Bits

The following symbolic constants are used to manipulate objects of type attr_t:

WA_ALTCHARSET	Alternate character set
WA_BLINK	Blinking
WA_BOLD	Extra bright or bold
WA_DIM	Half bright
WA_HORIZONTAL	Horizontal highlight
WA_INVIS	Invisible
WA_LEFT	Left highlight
WA_LOW	Low highlight
WA_PROTECT	Protected
WA_REVERSE	Reverse video
WA_RIGHT	Right highlight
WA_STANDOUT	Best highlighting mode of the terminal
WA_TOP	Top highlight
WA_UNDERLINE	Underlining
WA_VERTICAL	Vertical highlight

These attribute flags shall be distinct.

The following symbolic constants are used to manipulate attribute bits in objects of type chtype:

A_ALTCHARSET	Alternate character set
A_BLINK	Blinking
A_BOLD	Extra bright or bold
A_DIM	Half bright
A_INVIS	Invisible
A_PROTECT	Protected
A_REVERSE	Reverse video
A_STANDOUT	Best highlighting mode of the terminal
A_UNDERLINE	Underlining

These attribute flags need not be distinct except when _XOPEN_CURSES is defined and the application sets _XOPEN_SOURCE_EXTENDED to 1.

The following symbolic constants can be used as bit-masks to extract the components of a chtype:

A_ATTRIBUTES	Bit-mask to extract attributes
A_CHARTEXT	Bit-mask to extract a character
A_COLOR	Bit-mask to extract colour-pair information

The following symbolic constants can be used as bit-masks to extract the components of a chtype:

A_ATTRIBUTES	Bit-mask to extract attributes
A_CHARTEXT	Bit-mask to extract a character
A_COLOR	Bit-mask to extract colour-pair information

Line-Drawing Constants

The <curses.h> header defines the symbolic constants shown in the leftmost two columns of the following table for use in drawing lines. The symbolic constants that begin with ACS_ are char constants. The symbolic constants that begin with WACS_ are cchar_t constants for use with the wide-character interfaces that take a pointer to a cchar_t.

In the POSIX locale, the characters shown in the POSIX Locale Default column are used when the terminal database does not specify a value using the acsc capability as described in Line Graphics in terminfo(4).

		POSIX Locale
char Constant	cchar_t Constant	Default	Glyph Description
ACS_ULCORNER	WACS_ULCORNER	+	upper left-hand corner
ACS_LLCORNER	WACS_LLCORNER	+	lower left-hand corner
ACS_URCORNER	WACS_URCORNER	+	upper right-hand corner
ACS_LRCORNER	WACS_LRCORNER	+	lower right-hand corner
ACS_RTEE	WACS_RTEE	+	right tee (−⏐)
ACS_LTEE	WACS_LTEE	+	left tee (⏐-)
ACS_BTEE	WACS_BTEE	+	bottom tee (_ ⏐)
ACS_TTEE	WACS_TTEE	+	top tee (‾ ⏐)
ACS_HLINE	WACS_HLINE	−	horizontal line
ACS_VLINE	WACS_VLINE	\|	vertical line
ACS_PLUS	WACS_PLUS	+	plus
ACS_S1	WACS_S1	-	scan line 1
ACS_S9	WACS_S9	_	scan line 9
ACS_DIAMOND	WACS_DIAMOND	+	diamond
ACS_CKBOARD	WACS_CKBOARD	:	checker board (stipple)
ACS_DEGREE	WACS_DEGREE	’	degree symbol
ACS_PLMINUS	WACS_PLMINUS	#	plus/minus
ACS_BULLET	WACS_BULLET	o	bullet
ACS_LARROW	WACS_LARROW	<	arrow pointing left
ACS_RARROW	WACS_RARROW	>	arrow pointing right
ACS_DARROW	WACS_DARROW	v	arrow pointing down
ACS_UARROW	WACS_UARROW	^	arrow pointing up
ACS_BOARD	WACS_BOARD	#	board of squares
ACS_LANTERN	WACS_LANTERN	#	lantern symbol
ACS_BLOCK	WACS_BLOCK	#	solid square block

Colour-related Macros

The following colour-related macros are defined:

COLOR_BLACK
COLOR_BLUE
COLOR_GREEN
COLOR_CYAN
COLOR_RED
COLOR_MAGENTA
COLOR_YELLOW
COLOR_WHITE

Coordinate-related Macros

The following coordinate-related macros are defined:

void   getbegyx(WINDOW *win, int y, int x);
void   getmaxyx(WINDOW *win, int y, int x);
void   getparyx(WINDOW *win, int y, int x);
void   getyx(WINDOW *win, int y, int x);

Key Codes

The following symbolic constants representing function key values are defined:

Key Code	Description
KEY_CODE_YES	Used to indicate that a wchar_t variable contains a key code
KEY_BREAK	Break key
KEY_DOWN	Down arrow key
KEY_UP	Up arrow key
KEY_LEFT	Left arrow key
KEY_RIGHT	Right arrow key
KEY_HOME	Home key
KEY_BACKSPACE	Backspace
KEY_F0	Function keys; space for 64 keys is reserved
KEY_F(n)	For 0≤\\|n≤63
KEY_DL	Delete line
KEY_IL	Insert line
KEY_DC	Delete character
KEY_IC	Insert char or enter insert mode
KEY_EIC	Exit insert char mode
KEY_CLEAR	Clear screen
KEY_EOS	Clear to end of screen
KEY_EOL	Clear to end of line
KEY_SF	Scroll 1 line forward
KEY_SR	Scroll 1 line backward (reverse)
KEY_NPAGE	Next page
KEY_PPAGE	Previous page
KEY_STAB	Set tab
KEY_CTAB	Clear tab
KEY_CATAB	Clear all tabs
KEY_ENTER	Enter or send
KEY_SRESET	Soft (partial) reset
KEY_RESET	Reset or hard reset
KEY_PRINT	Print or copy
KEY_LL	Home down or bottom
KEY_A1	Upper left of keypad
KEY_A3	Upper right of keypad
KEY_B2	Center of keypad
KEY_C1	Lower left of keypad
KEY_C3	Lower right of keypad

The virtual keypad is a 3-by-3 keypad arranged as follows:

A1	UP	A3
LEFT	B2	RIGHT
C1	DOWN	C3

Each legend, such as A1, corresponds to a symbolic constant for a key code from the preceding table, such as KEY_A1. The following symbolic constants representing function key values are also defined:

Key Code	Description
KEY_BTAB	Back tab key
KEY_BEG	Beginning key
KEY_CANCEL	Cancel key
KEY_CLOSE	Close key
KEY_COMMAND	Cmd (command) key
KEY_COPY	Copy key
KEY_CREATE	Create key
KEY_END	End key
KEY_EXIT	Exit key
KEY_FIND	Find key
KEY_HELP	Help key
KEY_MARK	Mark key
KEY_MESSAGE	Message key
KEY_MOVE	Move key
KEY_NEXT	Next object key
KEY_OPEN	Open key
KEY_OPTIONS	Options key
KEY_PREVIOUS	Previous object key
KEY_REDO	Redo key
KEY_REFERENCE	Reference key
KEY_REFRESH	Refresh key
KEY_REPLACE	Replace key
KEY_RESTART	Restart key
KEY_RESUME	Resume key
KEY_SAVE	Save key
KEY_SBEG	Shifted beginning key
KEY_SCANCEL	Shifted cancel key
KEY_SCOMMAND	Shifted command key
KEY_SCOPY	Shifted copy key
KEY_SCREATE	Shifted create key
KEY_SDC	Shifted delete char key
KEY_SDL	Shifted delete line key
KEY_SELECT	Select key
KEY_SEND	Shifted end key
KEY_SEOL	Shifted clear line key
KEY_SEXIT	Shifted exit key
KEY_SFIND	Shifted find key
KEY_SHELP	Shifted help key
KEY_SHOME	Shifted home key
KEY_SIC	Shifted input key
KEY_SLEFT	Shifted left arrow key
KEY_SMESSAGE	Shifted message key
KEY_SMOVE	Shifted move key
KEY_SNEXT	Shifted next key
KEY_SOPTIONS	Shifted options key
KEY_SPREVIOUS	Shifted prev key
KEY_SPRINT	Shifted print key
KEY_SREDO	Shifted redo key
KEY_SREPLACE	Shifted replace key
KEY_SRIGHT	Shifted right arrow
KEY_SRSUME	Shifted resume key
KEY_SSAVE	Shifted save key
KEY_SSUSPEND	Shifted suspend key
KEY_SUNDO	Shifted undo key
KEY_SUSPEND	Suspend key
KEY_UNDO	Undo key

Function Prototypes

The following are declared as functions, and may also be defined as macros:

int    addch(const chtype ch);
int    addchstr(chtype *const chstr);
int    addchnstr(chtype *const chstr, int n);
int    addnstr(char *const str, int n);
int    addstr(char *const str);
int    addnwstr(wchar_t *const wstr, int n);
int    addwstr(wchar_t *const wstr);
int    add_wch(cchar_t *const wch);
int    add_wchnstr(cchar_t *const wchstr, int n);
int    add_wchstr(cchar_t *const wchstr);
int    attroff(int attrs);
int    attron(int attrs);
int    attrset(int attrs);
attr_t attr_get(void);
int    attr_off(attr_t attrs);
int    attr_on(attr_t attrs);
int    attr_set(attr_t attrs);
int    baudrate(void);
int    beep(void);
int    bkgd(chtype ch);
void   bkgdset(chtype ch);
void   bkgrndset(cchar_t *const wch);
int    bkgrnd(cchar_t *const wch);
int    border(chtype ls, chtype rs, chtype ts, chtype bs, chtype tl,
              chtype tr, chtype bl, chtype br);
int    border_set(cchar_t *const ls, cchar_t *const rs,
                  cchar_t *const ts, cchar_t *const bs,
                  cchar_t *const tl, cchar_t *const tr,
                  cchar_t *const bl, cchar_t *const br);
int    box(WINDOW *win, chtype verch, chtype horch);
int    box_set(WINDOW *win, cchar_t *const verch,
               cchar_t *const horch);
bool   can_change_color(void);
int    cbreak(void);
int    chgat(int n, attr_t attr, short color, void *const opts);
int    clear(void);
int    clearok(WINDOW *win, bool bf);
int    clrtobot(void);
int    clrtoeol(void);
int    color_content(short color, short *red, short *green,
                     short *blue);
int    COLOR_PAIR(int n);
int    copywin(WINDOW * const srcwin, WINDOW *dstwin, int sminrow,
               int smincol, int dminrow, int dmincol, int dmaxrow,
               int dmaxcol, int overlay);
int    curs_set(int visibility);
int    def_prog_mode(void);
int    def_shell_mode(void); int    delay_output(int ms);
int    delch(void);
void   delscreen(SCREEN *sp);
int    delwin(WINDOW *win);
int    deleteln(void);
WINDOW *derwin(WINDOW *orig, int nlines, int ncols, int begin_y,
               int begin_x);
int    doupdate(void);
WINDOW *dupwin(WINDOW *win);
int    echo(void);
int    echochar(const chtype ch);
int    echo_wchar(cchar_t *const wch);
int    endwin(void);
int    erase(void);
char   erasechar(void);
int    erasewchar(wchar_t *ch);
void   filter(void);
int    flash(void);
int    flushinp(void);
chtype getbkgd(WINDOW *win);
int    getbkgrnd(cchar_t *wch);
int    getcchar(cchar_t *const wcval, wchar_t *wch, attr_t *attrs,
                short *color_pair, void *opts);
int    getch(void);
int    getnstr(char *str, int n);
int    getn_wstr(wint_t *wstr, int n);
int    getstr(char *str);
int    get_wch(wint_t *ch);
WINDOW *getwin(FILE *filep);
int    get_wstr(wint_t *wstr);
int    halfdelay(int tenths);
bool   has_colors(void);
bool   has_ic(void);
bool   has_il(void);
int    hline(chtype ch, int n);
int    hline_set(cchar_t *const wch, int n);
void   idcok(WINDOW *win, bool bf);
int    idlok(WINDOW *win, bool bf);
void   immedok(WINDOW *win, bool bf);
chtype inch(void);
int    inchnstr(chtype *chstr, int n);
int    inchstr(chtype *chstr);
WINDOW *initscr(void);
int    init_color(short color, short red, short green, short blue);
int    init_pair(short pair, short f, short b);
int    innstr(char *str, int n);
int    innwstr(wchar_t *wstr, int n); int    insch(chtype ch);
int    insdelln(int n);
int    insertln(void);
int    insnstr(char *const str, int n);
int    insstr(char *const str);
int    instr(char *str);
int    ins_nwstr(wchar_t *const wstr, int n);
int    ins_wch(cchar_t *const wch);
int    ins_wstr(wchar_t *const wstr);
int    intrflush(WINDOW *win, bool bf);
int    in_wch(cchar_t *wcval);
int    in_wchstr(cchar_t *wchstr);
int    in_wchnstr(cchar_t *wchstr, int n);
int    inwstr(wchar_t *wstr);
bool   isendwin(void);
bool   is_linetouched(WINDOW *win, int line);
bool   is_wintouched(WINDOW *win);
char *keyname(int c);
char *key_name(wchar_t c);
int    keypad(WINDOW *win, bool bf);
char   killchar(void);
int    killwchar(wchar_t *ch);
int    leaveok(WINDOW *win, bool bf);
char *longname(void);
int    meta(WINDOW *win, bool bf);
int    move(int y, int x);
int    mvaddch(int y, int x, const chtype ch);
int    mvaddchnstr(int y, int x, chtype *const chstr, int n);
int    mvaddchstr(int y, int x, chtype *const chstr);
int    mvaddnstr(int y, int x, char *const str, int n);
int    mvaddnwstr(int y, int x, wchar_t *const wstr, int n);
int    mvaddstr(int y, int x, char *const str);
int    mvaddwstr(int y, int x, wchar_t *const wstr);
int    mvadd_wch(int y, int x, cchar_t *const wch);
int    mvadd_wchnstr(int y, int x, cchar_t *const wchstr, int n);
int    mvadd_wchstr(int y, int x, cchar_t *const wchstr);
int    mvchgat(int y, int x, int n, attr_t attr, short color,
               void *const opts);
int    mvcur(int oldrow, int oldcol, int newrow, int newcol);
int    mvdelch(int y, int x);
int    mvderwin(WINDOW *win, int par_y, int par_x);
int    mvgetch(int y, int x); int    mvgetnstr(int y, int x, char *str, int n);
int    mvgetn_wstr(int y, int x, wint_t *wstr, int n);
int    mvgetstr(int y, int x, char *str);
int    mvget_wch(int y, int x, wint_t *ch);
int    mvget_wstr(int y, int x, wint_t *wstr);
int    mvhline(int y, int x, chtype ch, int n);
int    mvhline_set(int y, int x, cchar_t *const wch, int n); chtype mvinch(int y, int x);
int    mvinchnstr(int y, int x, chtype *chstr, int n);
int    mvinchstr(int y, int x, chtype *chstr);
int    mvinnstr(int y, int x, char *str, int n);
int    mvinnwstr(int y, int x, wchar_t *wstr, int n);
int    mvinsch(int y, int x, chtype ch);
int    mvinsnstr(int y, int x, char *const str, int n);
int    mvinsstr(int y, int x, char *const str);
int    mvinstr(int y, int x, char *str);
int    mvins_nwstr(int y, int x, wchar_t *const wstr, int n);
int    mvins_wch(int y, int x, cchar_t *const wch);
int    mvins_wstr(int y, int x, wchar_t *const wstr);
int    mvinwstr(int y, int x, wchar_t *wstr);
int    mvin_wch(int y, int x, cchar_t *wcval);
int    mvin_wchnstr(int y, int x, cchar_t *wchstr, int n);
int    mvin_wchstr(int y, int x, cchar_t *wchstr);
int    mvprintw(int y, int x, char *fmt, ...);
int    mvscanw(int y, int x, char *fmt, ...);
int    mvvline(int y, int x, chtype ch, int n);
int    mvvline_set(int y, int x, cchar_t *const wch, int n);
int    mvwaddch(WINDOW *win, int y, int x, const chtype ch);
int    mvwaddchnstr(WINDOW *win, int y, int x, chtype *const chstr,
                    int n);
int    mvwaddchstr(WINDOW *win, int y, int x, chtype *const chstr);
int    mvwaddnstr(WINDOW *win, int y, int x, char *const str, int n);
int    mvwaddnwstr(WINDOW *win, int y, int x, wchar_t *const wstr,
                   int n);
int    mvwaddstr(WINDOW *win, int y, int x, char *const str);
int    mvwaddwstr(WINDOW *win, int y, int x, wchar_t *const wstr);
int    mvwadd_wch(WINDOW *win, int y, int x, cchar_t *const wch);
int    mvwadd_wchnstr(WINDOW *win, int y, int x, cchar_t *const wchstr,
                      int n);
int    mvwadd_wchstr(WINDOW *win, int y, int x, cchar_t *const wchstr);
int    mvwchgat(WINDOW *win, int y, int x, int n, attr_t attr,
                short color, void *const opts);
int    mvwdelch(WINDOW *win, int y, int x);
int    mvwgetch(WINDOW *win, int y, int x);
int    mvwgetnstr(WINDOW *win, int y, int x, char *str, int n);
int    mvwgetn_wstr(WINDOW *win, int y, int x, wint_t *wstr, int n);
int    mvwgetstr(WINDOW *win, int y, int x, char *str);
int    mvwget_wch(WINDOW *win, int y, int x, wint_t *ch);
int    mvwget_wstr(WINDOW *win, int y, int x, wint_t *wstr);
int    mvwhline(WINDOW *win, int y, int x, chtype ch, int n);
int    mvwhline_set(WINDOW *win, int y, int x, cchar_t *const wch,
                    int n);
int    mvwin(WINDOW *win, int y, int x);
chtype mvwinch(WINDOW *win, int y, int x);
int    mvwinchnstr(WINDOW *win, int y, int x, chtype *chstr, int n);
int    mvwinchstr(WINDOW *win, int y, int x, chtype *chstr);
int    mvwinnstr(WINDOW *win, int y, int x, char *str, int n);
int    mvwinnwstr(WINDOW *win, int y, int x, wchar_t *wstr, int n); int    mvwinsch(WINDOW *win, int y, int x, chtype ch);
int    mvwinsnstr(WINDOW *win, int y, int x, char *const str, int n);
int    mvwinsstr(WINDOW *win, int y, int x, char *const str);
int    mvwinstr(WINDOW *win, int y, int x, char *str);
int    mvwins_nwstr(WINDOW *win, int y, int x, wchar_t *const wstr,
                    int n);
int    mvwins_wch(WINDOW *win, int y, int x, cchar_t *const wch);
int    mvwins_wstr(WINDOW *win, int y, int x, wchar_t *const wstr);
int    mvwinwstr(WINDOW *win, int y, int x, wchar_t *wstr);
int    mvwin_wch(WINDOW *win, int y, int x, cchar_t *wcval);
int    mvwin_wchnstr(WINDOW *win, int y, int x, cchar_t *wchstr,
                     int n);
int    mvwin_wchstr(WINDOW *win, int y, int x, cchar_t *wchstr);
int    mvwprintw(WINDOW *win, int y, int x, char *fmt, ...);
int    mvwscanw(WINDOW *win, int y, int x, char *fmt, ...);
int    mvwvline(WINDOW *win, int y, int x, chtype ch, int n);
int    mvwvline_set(WINDOW *win, int y, int x, cchar_t *const wch,
                    int n);
int    napms(int ms);
WINDOW *newpad(int nlines, int ncols);
SCREEN *newterm(char *type, FILE *outfile, FILE *infile);
WINDOW *newwin(int nlines, int ncols, int begin_y, int begin_x);
int    nl(void);
int    nonl(void);
int    nocbreak(void);
int    nodelay(WINDOW *win, bool bf);
int    noecho(void);
void   noqiflush(void);
int    noraw(void);
int    notimeout(WINDOW *win, bool bf);
int    overlay(WINDOW * const srcwin, WINDOW *dstwin);
int    overwrite(WINDOW * const srcwin, WINDOW *dstwin);
int    pair_content(short pair, short *f, short *b);
int    PAIR_NUMBER(int value);
int    pechochar(WINDOW *pad, chtype *ch);
int    pecho_wchar(WINDOW *pad, cchar_t *const wch);
int    pnoutrefresh(WINDOW *pad, int pminrow, int pmincol, int sminrow,
                    int smincol, int smaxrow, int smaxcol);
int    prefresh(WINDOW *pad, int pminrow, int pmincol, int sminrow,
                int smincol, int smaxrow, int smaxcol);
int    printw(char *fmt, ...);
int    putp(char *const str);
int    putwin(WINDOW *win, FILE *filep);
void   qiflush(void);
int    raw(void);
int    redrawwin(WINDOW *win);
int    refresh(void);
int    resetty(void);
int    reset_prog_mode(void);
int    reset_shell_mode(void);
int    ripoffline(int line, int (*init)(WINDOW *win, int columns)); int    savetty(void);
int    scanw(char *fmt, ...);
int    scr_dump(char *const filename);
int    scr_init(char *const filename);
int    scrl(int n);
int    scroll(WINDOW *win);
int    scrollok(WINDOW *win, bool bf);
int    scr_restore(char *const filename);
int    scr_set(char *const filename);
int    setcchar(cchar_t *wcval, wchar_t *const wch,
                const attr_t attrs, short color_pair,
                void *const opts);
int    setscrreg(int top, int bot);
SCREEN *set_term(SCREEN *new);
int    slk_attroff(const chtype attrs);
int    slk_attr_off(const attr_t attrs);
int    slk_attron(const chtype attrs);
int    slk_attr_on(const attr_t attrs);
int    slk_attrset(const chtype attrs);
int    slk_attr_set(const attr_t attrs);
int    slk_clear(void);
int    slk_init(int fmt);
char *slk_label(int labnum);
int    slk_noutrefresh(void);
int    slk_refresh(void);
int    slk_restore(void);
int    slk_set(int labnum, char *const label, int justify);
int    slk_touch(void);
int    slk_wset(int labnum, wchar_t *const label, int justify);
int    standend(void);
int    standout(void);
int    start_color(void);
WINDOW *subpad(WINDOW *orig, int nlines, int ncols, int begin_y,
               int begin_x);
WINDOW *subwin(WINDOW *orig, int nlines, int ncols, int begin_y,
               int begin_x);
int    syncok(WINDOW *win, bool bf);
attr_t termattrs(void);
char *termname(void);
int    tigetflag(char *capname);
int    tigetnum(char *capname);
char *tigetstr(char *capname);
void   timeout(int delay);
int    touchline(WINDOW *win, int start, int count);
int    touchwin(WINDOW *win);
char *tparm(char *cap, long p1, long p2, long p3, long p4,
             long p5, long p6, long p7, long p8, long p9);
int    typeahead(int fildes);
int    ungetch(int ch);
int    unget_wch(const wchar_t wch);
int    untouchwin(WINDOW *win);
void   use_env(char boolvalue);
int    vidattr(chtype attr);
int    vid_attr(attr_t attr);
int    vidputs(chtype attr, int (*putfunc)(int));
int    vid_puts(attr_t attr, wint_t (*putwfunc)(wint_t));
int    vline(chtype ch, int n);
int    vline_set(cchar_t *const wch, int n);
int    vwprintw(WINDOW *win, char *fmt, void *varglist);
int    vw_printw(WINDOW *win, char *fmt, void *varglist);
int    vwscanw(WINDOW *win, char *fmt, void *varglist);
int    vw_scanw(WINDOW *win, char *fmt, void *varglist);
int    waddch(WINDOW *win, const chtype ch);
int    waddchnstr(WINDOW *win, chtype *const chstr, int n);
int    waddchstr(WINDOW *win, chtype *const chstr);
int    waddnstr(WINDOW *win, char *const str, int n);
int    waddnwstr(WINDOW *win, wchar_t *const wstr, int n);
int    waddstr(WINDOW *win, char *const str);
int    waddwstr(WINDOW *win, wchar_t *const wstr);
int    wadd_wch(WINDOW *win, cchar_t *const wch);
int    wadd_wchnstr(WINDOW *win, cchar_t *const wchstr, int n);
int    wadd_wchstr(WINDOW *win, cchar_t *const wchstr);
int    wattroff(WINDOW *win, int attrs);
int    wattron(WINDOW *win, int attrs);
int    wattrset(WINDOW *win, int attrs);
attr_t wattr_get(WINDOW *win);
int    wattr_off(WINDOW *win, attr_t attrs);
int    wattr_on(WINDOW *win, attr_t attrs);
int    wattr_set(WINDOW *win, attr_t attrs);
int    wbkgd(WINDOW *win, chtype ch);
void   wbkgdset(WINDOW *win, chtype ch);
int    wbkgrnd(WINDOW *win, cchar_t *const wch);
void   wbkgrndset(WINDOW *win, cchar_t *const wch);
int    wborder(WINDOW *win, chtype ls, chtype rs, chtype ts, chtype bs,
               chtype tl, chtype tr, chtype bl, chtype br);
int    wborder_set(WINDOW *win, cchar_t *const ls, cchar_t *const rs,
                   cchar_t *const ts, cchar_t *const bs,
                   cchar_t *const tl, cchar_t *const tr,
                   cchar_t *const bl, cchar_t *const br);
int    wchgat(WINDOW *win, int n, attr_t attr, short color,
              void *const opts);
int    wclear(WINDOW *win);
int    wclrtobot(WINDOW *win);
int    wclrtoeol(WINDOW *win);
void   wcursyncup(WINDOW *win);
int    wdelch(WINDOW *win);
int    wdeleteln(WINDOW *win);
int    wechochar(WINDOW *win, const chtype ch);
int    wecho_wchar(WINDOW *win, cchar_t *const wch);
int    werase(WINDOW *win);
int    wgetbkgrnd(WINDOW *win, cchar_t *wch); int    wgetch(WINDOW *win);
int    wgetnstr(WINDOW *win, char *str, int n);
int    wgetn_wstr(WINDOW *win, wint_t *wstr, int n);
int    wgetstr(WINDOW *win, char *str);
int    wget_wch(WINDOW *win, wint_t *ch);
int    wget_wstr(WINDOW *win, wint_t *wstr);
int    whline(WINDOW *win, chtype ch, int n);
int    whline_set(WINDOW *win, cchar_t *const wch, int n);
chtype winch(WINDOW *win);
int    winchnstr(WINDOW *win, chtype *chstr, int n);
int    winchstr(WINDOW *win, chtype *chstr);
int    winnstr(WINDOW *win, char *str, int n);
int    winnwstr(WINDOW *win, wchar_t *wstr, int n);
int    winsch(WINDOW *win, chtype ch);
int    winsdelln(WINDOW *win, int n);
int    winsertln(WINDOW *win);
int    winsnstr(WINDOW *win, char *const str, int n);
int    winsstr(WINDOW *win, char *const str);
int    winstr(WINDOW *win, char *str);
int    wins_nwstr(WINDOW *win, wchar_t *const wstr, int n);
int    wins_wch(WINDOW *win, cchar_t *const wch);
int    wins_wstr(WINDOW *win, wchar_t *const wstr);
int    winwstr(WINDOW *win, wchar_t *wstr);
int    win_wch(WINDOW *win, cchar_t *wcval);
int    win_wchnstr(WINDOW *win, cchar_t *wchstr, int n);
int    win_wchstr(WINDOW *win, cchar_t *wchstr);
int    wmove(WINDOW *win, int y, int x);
int    wnoutrefresh(WINDOW *win);
int    wprintw(WINDOW *win, char *fmt, ...);
int    wredrawln(WINDOW *win, int beg_line, int num_lines);
int    wrefresh(WINDOW *win);
int    wscanw(WINDOW *win, char *fmt, ...);
int    wscrl(WINDOW *win, int n);
int    wsetscrreg(WINDOW *win, int top, int bot);
int    wstandend(WINDOW *win);
int    wstandout(WINDOW *win);
void   wsyncdown(WINDOW *win);
void   wsyncup(WINDOW *win);
void   wtimeout(WINDOW *win, int delay);
int    wtouchln(WINDOW *win, int y, int n, int changed);
wchar_t *wunctrl(cchar_t *wc);
int    wvline(WINDOW *win, chtype ch, int n);
int    wvline_set(WINDOW *win, cchar_t *const wch, int n);

APPLICATION USAGE

In order to support historical applications that include <curses.h> and use <varargs.h> the following interfaces using va_list are declared as having a third argument of type (void *): vw_printw(), vw_scanw(), vwprintw(), vwscanw().

CHANGE HISTORY

First released in X/Open Curses, Issue 2.

X/Open Curses, Issue 4

The entry is completely rewritten to include new constants, data types and function prototypes.

Hewlett-Packard Company — HP-UX Release 10.20: July 1996

Museum