curs_getch(3X)                                     curs_getch(3X)

NAME
       getch,  wgetch,  mvgetch, mvwgetch, ungetch - get (or push
       back) characters from curses terminal keyboard

SYNOPSIS
       #include <curses.h>

       int getch(void);
       int wgetch(WINDOW *win);
       int mvgetch(int y, int x);
       int mvwgetch(WINDOW *win, int y, int x);
       int ungetch(int ch);
       int has_key(int ch);

DESCRIPTION
       The getch, wgetch, mvgetch and mvwgetch, routines  read  a
       character  from the window.  In no-delay mode, if no input
       is waiting, the value ERR is returned.  In delay mode, the
       program  waits until the system passes text through to the
       program.  Depending on the  setting  of  cbreak,  this  is
       after one character (cbreak mode), or after the first new-
       line (nocbreak mode).  In  half-delay  mode,  the  program
       waits  until a character is typed or the specified timeout
       has been reached.

       If noecho has been set, then the character  will  also  be
       echoed into the designated window according to the follow-
       ing rules: If the character is the current  erase  charac-
       ter,  left  arrow,  or  backspace, the cursor is moved one
       space to the left and that screen position is erased as if
       delch  had  been  called.   If  the character value is any
       other KEY_ define, the user is alerted with a  beep  call.
       Otherwise the character is simply output to the screen.

       If the window is not a pad, and it has been moved or modi-
       fied since the last call to  wrefresh,  wrefresh  will  be
       called before another character is read.

       If  keypad  is  TRUE,  and  a function key is pressed, the
       token for that function key is returned instead of the raw
       characters.    Possible   function  keys  are  defined  in
       <curses.h> as macros with  values  outside  the  range  of
       8-bit  characters  whose  names  begin  with KEY_. Thus, a
       variable intended to hold the return value of  a  function
       key must be of short size or larger.

       When a character that could be the beginning of a function
       key is received (which,  on  modern  terminals,  means  an
       escape  character), curses sets a timer.  If the remainder
       of the sequence does not come  in  within  the  designated
       time,  the  character  is  passed  through; otherwise, the
       function key value is returned.   For  this  reason,  many
       terminals  experience  a  delay  between  the  time a user
       presses the escape key and the escape is returned  to  the
       program.

       The ungetch routine places ch back onto the input queue to
       be returned by the next call to wgetch.  Note  that  there
       is, in effect, just one input queue for all windows.

   Function Keys
       The  following function keys, defined in <curses.h>, might
       be returned by getch if keypad  has  been  enabled.   Note
       that  not  all  of  these are necessarily supported on any
       particular terminal.

           Name            Key name

           KEY_BREAK       Break key
           KEY_DOWN        The four arrow keys ...
           KEY_UP
           KEY_LEFT
           KEY_RIGHT
           KEY_HOME        Home key (upward+left arrow)
           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 (lower left).
           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
           KEY_BTAB        Back tab key
           KEY_BEG         Beg(inning) 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_MOUSE       Mouse event read
           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   Ref(erence) key
           KEY_REFRESH     Refresh key
           KEY_REPLACE     Replace key
           KEY_RESIZE      Screen resized
           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

       Keypad is arranged like this:

                         +-----+------+-------+
                         | A1  |  up  |  A3   |
                         +-----+------+-------+
                         |left |  B2  | right |
                         +-----+------+-------+
                         | C1  | down |  C3   |
                         +-----+------+-------+
       The has_key routine takes a key value from the above list,
       and returns TRUE or FALSE according as the current  termi-
       nal type recognizes a key with that value.

RETURN VALUE
       All  routines  return  the integer ERR upon failure and an
       integer value other than ERR (OK in the case of ungetch())
       upon successful completion.

NOTES
       Use of the escape key by a programmer for a single charac-
       ter function is discouraged, as it will cause a  delay  of
       up to one second while the keypad code looks for a follow-
       ing function-key sequence.

       When using getch, wgetch, mvgetch, or  mvwgetch,  nocbreak
       mode (nocbreak) and echo mode (echo) should not be used at
       the same time.  Depending on the state of the  tty  driver
       when  each  character  is  typed,  the program may produce
       undesirable results.

       Note that getch, mvgetch, and mvwgetch may be macros.

       Historically, the set of keypad macros was largely defined
       by  the  extremely  function-key-rich keyboard of the AT&T
       7300, aka 3B1, aka Safari 4.   Modern  personal  computers
       usually  have  only a small subset of these.  IBM PC-style
       consoles  typically  support  little  more  than   KEY_UP,
       KEY_DOWN,    KEY_LEFT,   KEY_RIGHT,   KEY_HOME,   KEY_END,
       KEY_NPAGE, KEY_PPAGE, and function keys 1 through 12.  The
       Ins key is usually mapped to KEY_IC.

PORTABILITY
       The  *get* functions are described in the XSI Curses stan-
       dard, Issue 4.  They  read  single-byte  characters  only.
       The  standard  specifies  that they return ERR on failure,
       but specifies no error conditions.

       The echo behavior of these functions on input of  KEY_  or
       backspace  characters  was not specified in the SVr4 docu-
       mentation.  This  description  is  adopted  from  the  XSI
       Curses standard.

       The  behavior of getch and friends in the presence of han-
       dled signals is unspecified in the  SVr4  and  XSI  Curses
       documentation.   Under  historical curses implementations,
       it varied depending  on  whether  the  operating  system's
       implementation  of  handled  signal  receipt  interrupts a
       read(2) call in progress or not, and also (in some  imple-
       mentations)  depending on whether an input timeout or non-
       blocking mode hsd been set.

       Programmers concerned about portability should be prepared
       for  either  of  two  cases:  (a)  signal receipt does not
       interrupt getch; (b) signal receipt interrupts  getch  and
       causes  it  to  return ERR with errno set to EINTR.  Under
       the ncurses implementation, handled signals  never  inter-
       rupt getch.

       The  has_key  function is unique to ncurses.  We recommend
       that  any  code  using  it  be  conditionalized   on   the
       NCURSES_VERSION feature macro.

SEE ALSO
       curses(3X),        curs_inopts(3X),        curs_mouse(3X),
       curs_move(3X), curs_refresh(3X).  resizeterm(3X).

                                                                1