| CURSES_TTY(3) | Library Functions Manual | CURSES_TTY(3) | 
curses_tty, baudrate,
  beep, flash,
  curs_set, def_prog_mode,
  reset_prog_mode,
  def_shell_mode,
  reset_shell_mode, echo,
  noecho, delay_output,
  erasechar, flushinp,
  gettmode, halfdelay,
  has_ic, has_il,
  idcok, idlok,
  intrflush, noqiflush,
  qiflush, killchar,
  meta, napms,
  nl, nonl,
  cbreak, nocbreak,
  raw, noraw,
  typeahead, savetty,
  resetty —
#include <curses.h>
int
  
  baudrate(void);
int
  
  beep(void);
int
  
  flash(void);
int
  
  curs_set(int
    visibility);
int
  
  def_prog_mode(void);
int
  
  reset_prog_mode(void);
int
  
  def_shell_mode(void);
int
  
  reset_shell_mode(void);
int
  
  echo(void);
int
  
  noecho(void);
int
  
  delay_output(int
    ms);
char
  
  erasechar(void);
int
  
  flushinp(void);
int
  
  gettmode(void);
bool
  
  has_ic(void);
bool
  
  has_il(void);
int
  
  idcok(WINDOW
    *win, bool
  flag);
int
  
  idlok(WINDOW
    *win, bool
  flag);
int
  
  intrflush(WINDOW
    *win, bool
  flag);
void
  
  noqiflush(void);
void
  
  qiflush(void);
char
  
  killchar(void);
int
  
  meta(WINDOW
    *win, bool
  flag);
int
  
  napms(int
    ms);
int
  
  nl(void);
int
  
  nonl(void);
int
  
  cbreak(void);
int
  
  nocbreak(void);
int
  
  halfdelay(int);
int
  
  raw(void);
int
  
  noraw(void);
int
  
  typeahead(int
    filedes);
int
  
  savetty(void);
int
  
  resetty(void);
The baudrate() function extracts the
    output speed of the terminal and returns it in bits per second.
The beep() function rings the terminal
    bell, if this is possible. Failing that, the terminal screen will be
    flashed. If neither of these are possible, then no action will be taken.
    flash() will flash the terminal screen if possible.
    Failing that, the terminal bell will be rung. If neither of these are
    possible then no action will be taken.
The cursor visibility can be set by calling
    curs_set(). The following visibility settings are
    valid for curs_set():
A successful call to curs_set() will
    return the previous visibility setting for the cursor.
The delay_output() function pauses the
    output to the terminal by sending the appropriate number of terminal pad
    characters such that the transmission time of the pad characters will take
    ms milliseconds.
Calling def_prog_mode() will cause the
    current terminal curses setting to be saved. A subsequent call to
    reset_prog_mode(), will restore the saved settings.
    This is useful when calls to external programs are made that may reset the
    terminal characteristics.
The def_shell_mode() function saves the
    current terminal line settings. These settings are the ones that will be
    restored when the curses application exits. Conversely,
    reset_shell_mode() will save the current terminal
    curses settings for later restoration and restores the previously saved
    terminal line settings.
The echo() function turns on curses echo
    mode, characters entered will be echoed to the terminal by curses. The
    noecho() function disables this feature.
The current erase character for the terminal can be determined by
    calling the erasechar() function.
The flushinp() function discards any
    pending input for the current screen.
The modes for the current terminal can be reset by calling
    gettmode(), this will perform the initialisation on
    the terminal that is normally done by curses at start up.
The has_ic() function returns either
    TRUE or FALSE depending on
    whether or not the terminal has a insert character capability or not.
    Similarly the has_il() function does the same test
    but for a insert line capability.
The use of the insert character capability in curses operations
    can be enabled or disabled by calling idcok() on the
    desired window. Similarly, the use of the insert line capability can be
    controlled using the idlok() function.
The intrflush() function controls whether
    or not a flush of the input buffer is performed when an interrupt key (kill,
    suspend or quit) is pressed. The win parameter is
    ignored. The noqiflush() function is equivalent to
    intrflush(stdscr,
    FALSE). The qiflush() function
    is equivalent to
    intrflush(stdscr,
    TRUE).
The character that performs the line kill function can be
    determined by calling the killchar() function.
The meta() function turns on and off the
    generation of 8 bit characters by the terminal, if
    flag is FALSE then only 7 bit
    characters will be returned, if flag is
    TRUE then 8 bit characters will be returned by the
    terminal.
The napms() causes the application to
    sleep for the number of milliseconds specified by
  ms.
Calling nl() will cause curses to map all
    carriage returns to newlines on input, this functionality is enabled by
    default. The nonl() function disables this
    behaviour.
The cbreak() function will put the
    terminal into cbreak mode, which means that characters will be returned one
    at a time instead of waiting for a newline character, line discipline
    processing will be performed. The nocbreak()
    function disables this mode.
Calling halfdelay() puts the terminal into
    the same mode as cbreak() with the exception that if
    no character is received within the specified number of tenths of a second
    then the input routine will return ERR. This mode
    can be cancelled by calling nocbreak(). The valid
    range for the timeout is from 1 to 255 tenths of a second.
The noraw() function sets the input mode
    for the current terminal into Cooked mode, that is input character
    translation and signal character processing is performed. The
    raw() function puts the terminal into Raw mode, no
    input character translation is done nor is signal character processing.
The typeahead() function controls the
    detection of typeahead during a refresh based on the value of
    filedes:
The terminal tty flags can be saved by calling
    savetty() and may be restored by calling
    resetty(), the use of these functions is discouraged
    as they may cause the terminal to be put into a state that is incompatible
    with curses operation.
NULL if an
  error is detected. The functions that return an int will return one of the
  following values:
idcok() and idlok()
  currently have no effect on the curses code at all, currently curses will
  always use the terminal insert character and insert line capabilities if
  available.
| February 17, 2017 | NetBSD 9.3 |