COHERENT manpages
This page displays the COHERENT manpage for libcurses [Library of screen-handling functions].
List of available manpages
Index
libcurses -- Library Library of screen-handling functions libcurses is the library that holds the curses screen-handling functions. With curses, you can perform rudimentary graphics, even on dumb terminals; the range of routines includes mapping portions of the screen, drawing pop- up windows, creating forms with fields for data entry, and highlighting portions of text. Implementations of curses COHERENT uses the Cornell edition of curses. This implementation of curses reads the terminfo data base. It uses eight-bit characters; thus, the COHERENT edition of curses can display characters with accents and diacritical marks. Library libcurses contains the functions needed to read terminfo capability codes; thus, to compile the program curses_ex.c, use the following command line: cc curses_ex.c -lcurses Programs that wish to use curses must not link in both libcurses and libterm; doing so will cause collisions among library routines. Rather, these programs must link in only libcurses. On the other hand, if you wish to use the functions that read terminfo descriptions, you must link library libcurses into your program, even if you are not using any curses routines. If you have special terminal descriptions under termcap, the command captoinfo converts a termcap description into its terminfo analogue. See the Lexicon entries for termcap and terminfo for more information on this rather confusing topic. How curses Works curses organizes the screen into a two-dimensional array of cells, one cell for every character that the device can display. It maintains in memory an image of the screen, called the curscr. A second image, called the stdcur, is manipulated by the user; when the user has finished a given manipulation, curses copies the changes from the stdcur to the curscr, which results in their being displayed on the physical screen. This act of copying from the stdscr to the curscr is called refreshing the screen. curses keeps track of where all changes have begun and ended between one refresh and the next; this lets it rewrite only the portions of the curscr that the user has changed, and so speed up rewriting of the screen. curses records the position of a ``logical cursor'', which points to the position in the stdscr that is being manipulated by the user, and also records the position of the physical cursor. Note that the two are not necessarily identical: it is possible to manipulate the logical cursor without repositioning the physical cursor, and vice versa, depending on the task you wish to perform. Most curses routines work by manipulating a WINDOW object. WINDOW is defined in the header curses.h. curses defines WINDOW as follows: #define WINDOW _win_st struct _win_st { short _cury, _curx; short _maxy, _maxx; short _begy, _begx; short _flags; chtype _attrs; bool _clear; bool _leave; bool _scroll; bool _idlok; bool _use_keypad;/* 0=no, 1=yes, 2=yes/timeout */ bool _use_meta;/* T=use the meta key */ bool _nodelay;/* T=don't wait for tty input */ chtype **_line; short _firstchar;/* First changed character in the line */ short *_lastchar;/* Last changed character in the line */ short *_numchngd;/* Number of changes made in the line */ short _regtop;/* Top and bottom of scrolling region */ short _regbottom; }; Type bool is defined in curses.h; an object of this type can hold the value of true (nonzero) or false (zero). The following describes selected WINDOW fields in detail. _cury, _curx Give the Y and X positions of the logical cursor. The upper left corner of the window is, by definition, position 0,0. Note that curses by convention gives positions as Y/X (row/column) rather than X/Y, as is usual elsewhere. _maxy, _maxx Width and height of the window. _begy, _begx Position of the upper left corner of the window relative to the upper left corner of the physical screen. For example, if the window's upper left corner is five rows from the top of the screen and ten columns from the left, then _begy and _begx will be set to ten and five, respectively. _flags One or more of the following flags, logically OR'd together: _SUBWIN -- Window is a sub-window _ENDLINE -- Right edge of window touches edge of the screen _FULLWIN -- Window fills the physical screen _SCROLLWIN -- Window touches lower right corner of physical screen _FULLINE -- Window extends across entire physical screen _STANDOUT -- Write text in reverse video _INSL -- Line has been inserted into window _DELL -- Line has been deleted from window _ch_off Character offset. _clear Clear the physical screen before next refresh of the screen. _leave Do not move the physical cursor after refreshing the screen. _scroll Enable scrolling for this window. _y Pointer to an array of pointers to the character arrays that hold the window's text. _firstch Pointer to an array of integers, one for each line in the window, whose value is the first character in the line to have been altered by the user. If a line has not been changed, then its corresponding entry in the array is set to _NOCHANGE. _lastch Same as _firstch, except that it indicates the last character to have been changed on the line. _nextp Point to next window. _orig Point to parent window. When curses is first invoked, it defines the entire screen as being one large window. The programmer has the choice of subdividing an existing window or creating new windows; when a window is subdivided, it shares the same curscr as its parent window, whereas a new window has its own stdscr. Multiple Terminals Some applications need to display text on more than one terminal, controlled by the same process. curses can handle this, even if the terminals are of different types. The following describes how curses output to multiple terminals. All information about the current terminal is kept in a global variable struct screen *SP. Although the screen structure is hidden from the user, the C compiler will accept declarations of variables which are pointers. The user program should declare one screen pointer variable for each terminal it wishes to handle. The function newterm() sets up a new terminal of the given terminal type that is accessed via file-descriptor fp. To use more than one terminal, call newterm() for each terminal and save the value returned as a reference to that terminal. To switch to a different terminal, call set_term(). It returns the current contents of SP. Do not assign directly to SP because certain other global variables must also be changed. All curses routines always affect the current terminal. To handle several terminals, switch to each one in turn with set_term(), and then access it. Each terminal must first be set up with newterm(), and closed down with endwin(). Video Attributes curses lets you display any combination of video attributes on any terminal. Each character position on the screen has 16 bits of information associated with it. Seven bits are the character to be displayed, leaving bits for nine video attributes. These bits are used for the following modes respectively: standout, underline, reverse video, blink, dim, bold, blank, protect, and alternate-character set. Standout is whatever highlighting works best on the terminal, and should be used by any program that does not need specific or combined attributes. Underlining, reverse video, blink, dim, and bold are the usual video attributes. Blank means that the character is displayed as a space, for security reasons. Protected and alternate character set depend on the terminal. The use of these last three bits is subject to change and not recommended. The routines to use these attributes include attron(), attroff(), attrset(), standend(), standout(), wattroff(), wattron(), wattrset(), wstandend(), and wstandout(). All are described below. Attributes, if given, can be any combination of A_STANDOUT, A_UNDERLINE, A_REVERSE, A_BLINK, A_DIM, A_BOLD, A_INVIS, A_PROTECT, and A_ALTCHARSET, OR'd together. These constants are defined in curses.h. If the particular terminal does not have the particular attribute or combination requested, curses will attempt to use some other attribute in its place. If the terminal has no highlighting, all attributes are ignored. Function Keys Many terminals have special keys, such as arrow keys, keys to erase the screen, insert or delete text, and keys intended for user functions. The particular sequences these terminals send differs from terminal to terminal. curses lets you handle these keys. A program using function keys should turn on the keypad by calling keypad() at initialization. This causes special characters to be passed through to the program by the function getch(). These keys have constants that are defined in curses.h. They have values starting at 0401, so they should not be stored in a char variable, as significant bits will be lost. A program that uses function keys should avoid using the <esc> key: most sequences start with <esc>, so an ambiguity will occur. curses sets a one-second alarm to deal with this ambiguity, which will cause delayed response to the <esc> key. It is a good idea to avoid <esc> in any case, because there is eventually pressure for nearly any screen-oriented program to accept arrow-key input. Scrolling Region Most terminals have a user-accessible scrolling region. Normally, this is set to the entire window, but the calls setscrreg() and wsetscrreg() set the scrolling region for stdscr or the given window to any combination of top and bottom margins. If scrolling has been enabled with scrollok(), scrolling takes place only within that window. TTY Mode Functions In addition to the save/restore routines savetty() and resetty(), curses contains routines for going into and out of normal tty mode. The normal routines are resetterm(), which puts the terminal back in the mode it was in when curses was started, and fixterm(), which undoes the effects of resetterm(), that is, restores the ``current curses mode''. endwin() automatically calls resetterm(). These routines are also available at the terminfo level. No-Delay Mode curses offers the call nodelay(), which puts the terminal into ``no-delay mode''. While in no-delay mode, any call to getch() returns -1 if nothing is waiting to be read. This is useful for programs that require real-time behavior, where the user watches action on the screen and presses a key when he wants something to happen. For example, the cursor can be moving across the screen, and the user can press an arrow key to change direction. This mode is especially useful for games. Portability curses contains several routines to improve portability. Because these routines do not directly relate to terminal handling, their implementation differs from system to system, and the differences can be isolated from the user program by including them in curses. Functions erasechar() and killchar() return the characters that, respectively, erase one character and kill the entire input line. The function baudrate() returns the current baud rate, as an integer. (For example, at 9600 baud, baudrate() returns the integer 9600, not the value B9600 from <sgtty.h>.) The routine flushinp() throws away all typeahead. call resetterm() to restore the tty modes. After the shell escape, fixterm() can be called to set the tty modes back to their internal settings. These calls are now required, because they perform system- dependent processing. curses Routines The following table summarizes the functions and macros that comprise the curses library. These routines are declared and defined in the header file curses.h. addch(ch) char ch; Insert a character into stdscr. addstr(str) char *str; Insert a string into stdscr. attroff(at) int at; Turn off video attributes on stdscr. attron(at) int at; Turn on video attributes on stdscr. attrset(at) int at; Set video attributes on stdscr. baudrate() Return the baud rate of the current terminal. beep() Sound the audible bell. box(win, vert, hor) WINDOW *win; char vert, hor; Draw a box. vert is the character used to draw the vertical lines, and hor is used to draw the horizontal lines. The call box(win, 0, 0) draws a box with solid lines. The call box(win, '|', '-'); draws a box around window win, using `|' to draw the vertical lines and `-' to draw the horizontal lines. Do not use non-ASCII characters unless you are very sure of the output terminal's identity. cbreak() Turn on cbreak mode. clear() Clear the stdscr. clearok(win,bf) WINDOW *win; bool bf; Set the clear flag for window win. This will clear the screen at the next refresh, but not reset the window. clrtobot() Clear from the position of the logical cursor to the bottom of the window. clrtoeol() Clear from the logical cursor to the end of the line. crmode() Turn on control-character mode; i.e., force terminal to receive cooked input. delch() Delete a character from stdscr; shift the rest of the characters on the line one position to the left. deleteln() Delete all of the current line; shift up the rest of the lines in the window. delwin(win) WINDOW *win; Delete window win. doupdate() Update the physical screen. echo() Turn on both physical and logical echoing; i.e., characters are automatically inserted into the current window and onto the physical screen. endwin() Terminate text processing with curses. erase() Erase a window; do not clear the screen. char *erasechar() Return the erase character of the current terminal. flash() Execute the visual bell. flushinp() Flush input from the current terminal. getch() Read a character from the terminal. getstr(str) char *str; Read a string from the terminal. getyx(win,y,x) WINDOW *win; short y,x; Read the position of the logical cursor in win and store it in y,x. Note that this is a macro, and due to its construction the variables y and x must be integers, not pointers to integers. idlok(win, flag) WINDOW *win; int flag; Enable insert/delete line operations for window win. flag must contain the OR'd operations you desire. inch() Read the character pointed to by the stdscr's logical cursor. WINDOW *initscr() Initialize curses. Among other things, this function initializes the global variables LINES and COLS, which give, respectively, the number of lines and the number of columns on your screen. This is of most use under X Windows. When you change the size of an xterm or xvt window, the command eval `resize` resets these variables. The next time you invoke a curses-based program, its size will reflect new the dimensions of window. insch(ch) char ch; Insert character ch into the stdscr. insertln() Insert a blank line into stdscr, above the current line. keypad(win,flag) WINDOW *win; int flag; Enable keypad-sequence mapping. char *killchar() Return the kill character for the current terminal. leaveok(win,bf) WINDOW *win; bool bf; Set win->_leave to bf. If set to TRUE, refresh will leave the cursor after the last character changed by refresh. This makes sense if you want to minimize the commands sent to the screen and it does not matter where the cursor is. char *longname(termbuf, name) char *termbuf, *name; Copy the long name for the terminal from termbuf into name. meta(win, flag) WINDOW *win; int flag; Enable use of the meta key. move(y,x) short y,x; Move logical cursor to position y,x in stdscr. mvaddbytes(y,x,da,count) int y,x; char *da; int count; Move to position y,x and print count bytes from the string pointed to by da. mvaddch(y,x,ch) short y,x; char ch; Move the logical cursor to position y,x and insert character ch. mvaddstr(y,x,str) short y,x; char *str; Move the logical cursor to position y,x and insert string str. mvcur(y_cur,x_cur,y_new,x_new) int y_cur, x_cur, y_new, x_new; Move cursor from position y_cur,x_cur to position y_new,x_new. mvdelch(y,x) short y,x; Move to position y,x and delete the character found there. mvgetch(y,x) short y,x; Move to position y,x and get a character through stdscr. mvgetstr(y,x,str) short y,x; char *str; Move to position y,x, get a string through stdscr, and copy it into string. mvinch(y,x) short y,x; Move to position y,x and get the character found there. mvinsch(y,x,ch) short y,x; char ch; Move to position y,x and insert a character into stdscr. mvwaddbytes(win,y,x,da,count) WINDOW *win; int y,x; char *da; int count; Move to position y,x and print count bytes from the string pointed to by da into window win. mvwaddch(win,y,x,ch) WINDOW *win; int y,x; char ch; Move to position y,x and insert character ch into window win. mvwaddstr(win,y,x,str) WINDOW *win; short y,x; char *str; Move to position y,x and insert string str. mvwdelch(win,y,x) WINDOW *win; int y,x; Move to position y,x and delete character ch from window win. mvwgetch(win,y,x) WINDOW *win; short y,x; Move to position y,x and get a character. mvwgetstr(win,y,x,str) WINDOW *win; short y,x; char *str; Move to position y,x, get a string, and write it into str. mvwin(win,y,x) WINDOW *win; int y,x; Move window win to position y,x. mvwinch(win,y,x) WINDOW *win; short y,x; Move to position y,x and get character found there. mvwinsch(win,y,x,ch) WINDOW *win; short y,x; char ch; Move to position y,x and insert character ch there. struct screen *newterm(type, fd) char *type; int fd; Initialize the new terminal type, which is accessed via file- descriptor fd. WINDOW *newwin(lines, cols, y1, x1) int lines, cols, y1, x1; Create a new window. The new window is lines lines high, cols columns wide, with the upper-left corner at position y1,x1. It returns a pointer to the WINDOW structure that defines the newly created window. nl() Turn on newline mode; i.e., force terminal to output <newline> after <linefeed>. nocbreak() Turn off cbreak mode. nocrmode() Turn off control-character mode; i.e., force terminal to accept raw input. nodelay(win, flag) WINDOW *win; int flag; Make getch() non-blocking. noecho() Turn off echo mode. nonl() Turn off newline mode. noraw() Turn off raw mode. overlay(win1,win2) WINDOW *win1, win2; Copy all characters, except spaces, from their current positions in win1 to identical positions in win2. overwrite(win1,win2) WINDOW *win1, win2; Copy all characters, including spaces, from win1 to their identical positions in win2. printw(format[,arg1,...argN]) char *format; [data type] arg1,..argN; Print formatted text on the standard screen. raw() Turn on raw mode; i.e., kernel does not process what is typed at the keyboard, but passes it directly to curses. In normal (or cooked) mode, the kernel intercepts and processes the control characters <ctrl-C>, <ctrl-S>, <ctrl-Q>, and <ctrl-Y>. See the entry for stty for more information. refresh() Copy the contents of stdscr to the physical screen. resetty() Reset the terminal flags to values stored by earlier call to savetty. saveterm() Save the current state of the terminal. savetty() Save the current terminal settings. scanw(format[,arg1,...argN]) char *format; [data type] arg1,..argN; Read the standard input; translate what is read into the appropriate data type. scroll(win) WINDOW *win; Scroll win up by one line. scrollok(win,bf) WINDOW *win; bool bf; Permit or forbid scrolling of window win, depending upon whether bf is set to true or false. setscrreg(top, bottom) int top, bottom; Set the scrolling region on stdscr. setterm(name) char *name; Set term variables for name. struct screen *set_term(new) struct screen *new; Switch output to terminal new. It returns a pointer to the previously used terminal. standend() Turn off standout mode. standout() Turn on standout mode for text. Usually, this means that text will be displayed in reverse video. WINDOW *subwin(win, lines, cols, y1, x1) int win,lines,cols,y1,x1; Create a sub-window in window win. The new sub-window is lines lines high, cols columns wide, and is fixed at position y1,x1. Note that the position is relative to the upper-left corner of the physical screen. This function returns a pointer to the WINDOW structure that defines the newly created sub-window. touchwin(win) WINDOW *win; Copy all characters in window win to the screen. traceoff() Turn off debugging output. traceon() Turn on debugging output unctrl(ch) char ch; Output a printable version of the control-character ch. waddch(win,ch) WINDOW *win; char ch; Add character ch to window win. waddstr(win,str) WINDOW *win; char *str; Add the string pointed to by str to window win. wattroff(win,att) WINDOW *win; int att; Turn off video attributes att for the window pointed to by win. wattron(win,att) WINDOW *win; int att; Turn on video attributes att for the window pointed to by win. wattrset(win,at) WINDOW *win; int att; Set the video attributes att for the window pointed to by win. wclear(win) WINDOW *win; Clear window win. Move cursor to position 0,0 and set the screen's clear flag. wclrtobot(win) WINDOW *win; Clear window win from current position to the bottom. wclrtoeol(win) WINDOW *win; Clear window win from the current position to the end of the line. wdelch(win) WINDOW *win; Delete the character at the current position in window win; shift all remaining characters to the right of the current position one position left. wdeleteln(win) WINDOW *win; Delete the current line and shift all lines below it one line up. werase(win) WINDOW *win; Clear window win. Move the cursor to position 0,0 but do not set the screen's clear flag. wgetch(win) WINDOW *win; Read one character from the standard input. wgetstr(win,str) WINDOW *win; char *str; Read a string from the standard input; write it in the area pointed to by str. winch(win) WINDOW *win; Force the next call to refresh() to rewrite the entire screen. winsch(win,ch) WINDOW *win; char ch; Insert character ch into window win at the current position. Shift all existing characters one position to the right. winsertln(win) WINDOW *win; Insert a blank line into window win at the current position. Move all lines down by one position. wmove(win,y,x) WINDOW *win; int y, x; Move current position in the window win to position y,x. wnoutrefresh(win) WINDOW *win; Copy the window pointed to by win to the virtual screen; do not refresh the real screen. wprintw(win,format[,arg1,...argN]) WINDOW *win; char *format; [data type] arg1,..argN; Format text and print it to the current position in window win. wrefresh(win) WINDOW *win; Refresh a window. wscanw(win,format[,arg1,...argN]) WINDOW *win; char *format; [data type] arg1,..argN; Read standard input from the current position in window win, format it, and store it in the indicated places. wstandend(win) WINDOW *win; Turn off standout (reverse video) mode for window win. wstandout(win) WINDOW *win; Turn on standout (reverse video) mode for window win. wsetscrreg(win,top,bottom) WINDOW *win; int top, bottom; Set the scrolling region on the window pointed to by win. Color Support Beginning with release 4.2, COHERENT's implementation of curses supports color. curses defines colors as a video attribute, like any other. It actually handles pairs of colors -- one for the foreground and one for the background. You must initialize a color pair and given it a unique identifying number; then pass the identifier of the color pair to the function wattron() to turn on, like any other video attribute. The header file <terminfo.h> defines the following colors, which curses recognizes: COLOR_BLACK COLOR_RED COLOR_GREEN COLOR_YELLOW COLOR_BLUE COLOR_MAGENTA COLOR_CYAN COLOR_WHITE Header file <curses.h> defines the variables COLORS, which holds the maximum number of colors that your console or terminal recognizes; and COLOR_PAIRS, which holds the maximum number of color pairs that your console or terminal recognizes. The function start_color() initializes both variables. The following gives the functions and macros with which you can manipulate colors: can_change_colors() This function returns TRUE if you can change the definition of a color on your device, and FALSE if you cannot. You should call this function before you invoke the function init_color(), described below. color_content(color,r,g,b); int color,*r,*g,*b; Read the RGB settings for color and write them at the addresses given by r, g, and b. COLOR_PAIR(pairnum); int pairnum; Return the definition of the color pair identified by pairnum. The color pair must have been initialized by a call to init_pair(). has_colors() Return TRUE if your console or terminal supports color and FALSE if it does not. init_color(color,r,g,b); int color,r,g,b; Initialize color to the RGB values r, g, and b. color must be greater than zero and less than COLORS. r,' g, and b must each be between zero and 1,000. Not every console or terminal permits you to reset its colors. Call can_change_colors() to see if you can alter your device's colors. init_pair(pairnum,fc,bc) int pairnum, fc, bc; Initialize the color pair pairnum to the foreground color fc and the background color bc. pairnum must be greater than zero and less than COLOR_PAIRS. fc and bc must be greater than -1 and less than COLORS. pair_content(pairnum,fc,bc) int pairnum,*fc,*bc; Read the foreground and background colors represented by color pair pairnum and write them into the areas pointed to by fg and bg. start_color() Turn on color processing. This function must precede all other color routines; usually, it immediately follows the function initscr(). A brief example of how to colors appears in the Examples section, below. terminfo Routines As noted above, curses reads terminal descriptions from terminfo rather than termcap. The library libcurses also holds the following functions, with which you can read a terminfo description: fixterm()......Set the terminal into program mode putp().........Write a string into stdwin resetterm()....Reset the terminal into a saved mode setupterm()....Initialize terminal capabilities tparm()........Output a parameterized string tputs()........Process a capability string vidattr()......Set the terminal's video attributes vidputs()......Set video attributes into a function For more information on these routines, see the Lexicon entry terminfo, or see each routine's entry in the Lexicon. If you define the environment variable TERMINFO, curses checks for the terminal definition in the directory that TERMINFO names rather than in the standard directory /usr/lib/terminfo. For example, if you set the environmental variable TERM is set to vt100, then the compiled terminfo definition is kept in directory /usr/lib/terminfo/v/vt100. However, if you define TERMINFO to be $HOME/testterm, curses first checks $HOME/testterm/v/vt100; if that fails, it then checks /usr/lib/terminfo/v/vt100. This is useful when you are debugging a terminfo entry. Structure of a curses Program To use the curses routines, a program must include the header file curses.h, which declares and defines the functions and macros that comprise the curses library. Before a program can perform any screen operations, it must call the function initscr() to initialize the curses environment. As noted above, curses manipulates text in a copy of the screen that it maintains in memory. After a program has manipulated text, it must call refresh() to copy these alterations from memory to the physical screen. (This is done because writing to the screen is slow; this scheme permits mass alterations to be made to copy in memory, then written to the screen in a batch.) Finally, when the program has finished working with curses, it must call the function endwin(). This frees memory allocated by curses, and generally closes down the curses environment gracefully. Examples The first example shows what modes and characters are visible on your system. #include <curses.h> #define A_ETX 0x03 main() { int c, y = 0, x = 0, attr = A_NORMAL, mask, state = 0, hibit = 0; initscr(); noecho(); raw(); erase(); move(y, 0); addstr( "+ sets - clears Normal Bold Underline blInk Reverse Standout Altmode"); move(++y, 0); refresh(); for (;;) { if (!state) { switch (c = getch()) { case '+': state = 1; break; case '-': state = 2; break; case '\b': if (!x) break; move(y, --x); addch(' '); move(y, x); refresh(); break; case '\r': case '\n': move(++y, x = 0); refresh(); break; case A_ETX: noraw(); echo(); endwin(); exit(0); default: x++; addch(c | hibit); refresh(); } } else { switch (c = getch()) { case 'A': /* turn on high bit of input */ hibit = (state & 1) << 7; state = 0; continue; case 'B': mask = A_BOLD; break; case 'U': mask = A_UNDERLINE; break; case 'I': mask = A_BLINK; break; case 'R': mask = A_REVERSE; break; case 'S': mask = A_STANDOUT; break; case 'N': /* normal is an absence of bits */ if (state == 1) { attr = A_NORMAL; hibit = state = 0; continue; } default: beep(); continue; } if (state == 1) attr |= mask; else attr &= ~mask; attrset(attr); state = 0; } } } The next example demonstrates how to use colors in a curses program. It selects colors randomly, builds color pairs, and displays a 40-character text string to demonstrate the newly build color pair. #include <curses.h> #include <stdlib.h> void goodbye() { move(23, 0); noraw(); echo(); endwin(); exit(EXIT_SUCCESS); } main() { int x, y, i; initscr(); start_color(); noecho(); raw(); srand(time(NULL)); erase(); if (!has_colors()) goodbye(); for (x = 0, y = 0, i = 1; i < COLOR_PAIRS; i++, y++) { if (y == 23) { x = 40; y = 0; } move(y, x); init_pair(i, (rand() % COLORS), (rand() % COLORS)); attrset(COLOR_PAIR(i)); addstr("Pack my box with five dozen liquor jugs."); } refresh(); goodbye(); } The next example shows how to read function keys under curses: #include <curses.h> void text(); main() { int input; initscr(); raw(); noecho(); keypad(stdscr, TRUE); refresh(); while (TRUE) { input = wgetch(stdscr); switch (input) { case 'q': case 'Q': endwin(); exit(0); case KEY_UP: text("cursor up"); break; case KEY_DOWN: text("cursor down"); break; case KEY_LEFT: text("cursor left"); break; case KEY_RIGHT: text("cursor right"); break; case KEY_F(1): text("function key 1"); break; case KEY_F(2): text("function key 2"); break; default: text("some other key"); break; } } } void text(s) register char *s; { move(0, 0); clrtoeol(); printw("Your input was: %s", s); refresh(); } See Also curses.h, libraries, termcap, terminfo Strang J: Programming with curses. Sebastopol, Calif, O'Reilly & Associates Inc., 1986. Notes The implementation of curses used by the COHERENT system was written by Pavel Curtis of Cornell University. It was ported to COHERENT by Udo Munk.