Curses

# Module Curses

    module Curses: sig .. end

Bindings to the ncurses library.

Beware, all coordinates are passed `y` first, then `x`.

Functions whose name start with a "w" take as first argument the window the function applies to. Functions whose name start with "mv" take as first two arguments the coordinates `y` and `x` of the point to move the cursor to. For example `mvaddch y x ch` is the same as `move y x; addch ch`.

    type window

Windows.

    type screen

Screens.

    type terminal

Terminals.

    type chtype = int

Characters. Usual characters can be converted from/to `chtype` using `char_of_int` and `int_of_char`. See also `get_acs_codes` for characters useful for drawing and the `Key` module for special input characters.

    type attr_t = int

Attributes are `lor`ings of flags which are defined in the `A` module.

    type err = bool

A return value. `false` means that an error occured.

## Initialization functions

    val initscr : unit -> window

Initialize the curses library.

    val endwin : unit -> unit

Restore the terminal (should be called before exiting).

    val isendwin : unit -> bool

Has `endwin` been called without any subsequent call to `werefresh`?

    val newterm : string -> Unix.file_descr -> Unix.file_descr -> screen

Create a new terminal.

    val set_term : screen -> unit

Switch terminal.

    val delscreen : screen -> unit

Delete a screen.

    val stdscr : unit -> window

## Cursor

    val getyx : window -> int * int

Get the current cursor position.

    val getparyx : window -> int * int

    val getbegyx : window -> int * int

    val getmaxyx : window -> int * int

    val move : int -> int -> err

Move the cursor.

    val wmove : window -> int -> int -> err

## Operations on characters

    module Acs: sig .. end

Predefined characters.

    val get_acs_codes : unit -> Acs.acs

Get the predefined characters.

### Displaying characters

    val addch : chtype -> err

Add a character at the current position, then advance the cursor.

    val waddch : window -> chtype -> err

    val mvaddch : int -> int -> chtype -> err

    val mvwaddch : window -> int -> int -> chtype -> err

    val echochar : chtype -> err

`echochar ch` is equivalent to `addch ch` followed by `refresh ()`.

    val wechochar : window -> chtype -> err

    val addchstr : chtype array -> err

Add a sequence of characters at the current position. See also `addstr`.

    val waddchstr : window -> chtype array -> err

    val mvaddchstr : int -> int -> chtype array -> err

    val mvwaddchstr : window -> int -> int -> chtype array -> err

    val addchnstr : chtype array -> int -> int -> err

    val waddchnstr : window -> chtype array -> int -> int -> err

    val mvaddchnstr : int -> int -> chtype array -> int -> int -> err

    val mvwaddchnstr : window ->
           int -> int -> chtype array -> int -> int -> err

    val addstr : string -> err

Add a string at the current position.

    val waddstr : window -> string -> err

    val mvaddstr : int -> int -> string -> err

    val mvwaddstr : window -> int -> int -> string -> err

    val addnstr : string -> int -> int -> err

    val waddnstr : window -> string -> int -> int -> err

    val mvaddnstr : int -> int -> string -> int -> int -> err

    val mvwaddnstr : window -> int -> int -> string -> int -> int -> err

    val insch : chtype -> err

Insert a character before cursor.

    val winsch : window -> chtype -> err

    val mvinsch : int -> int -> chtype -> err

    val mvwinsch : window -> int -> int -> chtype -> err

    val insstr : string -> err

Insert a string before cursor.

    val winsstr : window -> string -> err

    val mvinsstr : int -> int -> string -> err

    val mvwinsstr : window -> int -> int -> string -> err

    val insnstr : string -> int -> int -> err

    val winsnstr : window -> string -> int -> int -> err

    val mvinsnstr : int -> int -> string -> int -> int -> err

    val mvwinsnstr : window -> int -> int -> string -> int -> int -> err

    val delch : unit -> err

Delete a character.

    val wdelch : window -> err

    val mvdelch : int -> int -> err

    val mvwdelch : window -> int -> int -> err

### Attributes

    module A: sig .. end

Attributes.

    module WA: sig .. end

New series of highlight attributes.

    val attroff : int -> unit

Turn off the attributes given in argument (see the `A` module).

    val wattroff : window -> int -> unit

    val attron : int -> unit

Turn on the attributes given in argument.

    val wattron : window -> int -> unit

    val attrset : int -> unit

Set the attributes.

    val wattrset : window -> int -> unit

    val standend : unit -> unit

    val wstandend : window -> unit

    val standout : unit -> unit

    val wstandout : window -> unit

    val attr_off : attr_t -> unit

Turn off the attributes given in argument (see the `WA` module).

    val wattr_off : window -> attr_t -> unit

    val attr_on : attr_t -> unit

    val wattr_on : window -> attr_t -> unit

    val attr_set : attr_t -> int -> unit

    val wattr_set : window -> attr_t -> int -> unit

    val chgat : int -> attr_t -> int -> unit

`chgat n attr color` changes the attributes of `n` characters.

    val wchgat : window -> int -> attr_t -> int -> unit

    val mvchgat : int -> int -> int -> attr_t -> int -> unit

    val mvwchgat : window -> int -> int -> int -> attr_t -> int -> unit

    val inch : unit -> chtype

Get the attributes of the caracter at current position.

    val winch : window -> chtype

    val mvinch : int -> int -> chtype

    val mvwinch : window -> int -> int -> chtype

    val inchstr : chtype array -> err

Get the attributes of a sequence of characters.

    val winchstr : window -> chtype array -> err

    val mvinchstr : int -> int -> chtype array -> err

    val mvwinchstr : window -> int -> int -> chtype array -> err

    val inchnstr : chtype array -> int -> int -> err

    val winchnstr : window -> chtype array -> int -> int -> err

    val mvinchnstr : int -> int -> chtype array -> int -> int -> err

    val mvwinchnstr : window ->
           int -> int -> chtype array -> int -> int -> err

    val instr : string -> err

Get the attributes of a string.

    val winstr : window -> string -> err

    val mvinstr : int -> int -> string -> err

    val mvwinstr : window -> int -> int -> string -> err

    val innstr : string -> int -> int -> err

    val winnstr : window -> string -> int -> int -> err

    val mvinnstr : int -> int -> string -> int -> int -> err

    val mvwinnstr : window -> int -> int -> string -> int -> int -> err

### Background

    val bkgdset : chtype -> unit

Set the background of the current character.

    val wbkgdset : window -> chtype -> unit

    val bkgd : chtype -> unit

Set the background of every character.

    val wbkgd : window -> chtype -> unit

    val getbkgd : window -> chtype

Get the current background.

### Operations on lines

    val deleteln : unit -> err

Delete a line.

    val wdeleteln : window -> err

    val insdelln : int -> err

`insdelln n` inserts `n` lines above the current line if `n` is positive or deletes `-n` lines if `n` is negative.

    val winsdelln : window -> int -> err

    val insertln : unit -> err

Insert a blank line above the current line.

    val winsertln : window -> err

### Characters input

    module Key: sig .. end

Special keys.

    val getch : unit -> int

Read a character in a window.

    val wgetch : window -> int

    val mvgetch : int -> int -> int

    val mvwgetch : window -> int -> int -> int

    val ungetch : int -> err

    val getstr : string -> err

Read a string in a window.

    val wgetstr : window -> string -> err

    val mvgetstr : int -> int -> string -> err

    val mvwgetstr : window -> int -> int -> string -> err

    val getnstr : string -> int -> int -> err

    val wgetnstr : window -> string -> int -> int -> err

    val mvgetnstr : int -> int -> string -> int -> int -> err

    val mvwgetnstr : window -> int -> int -> string -> int -> int -> err

## Windows

### Window manipulations

    val newwin : int -> int -> int -> int -> window

`newwin l c y x` create a new window with `l` lines, `c` columns. The upper left-hand corner is at (`x`,`y`).

    val delwin : window -> err

Delete a window.

    val mvwin : window -> int -> int -> err

Move a window.

    val subwin : window -> int -> int -> int -> int -> window

`subwin l c y x` create a subwindow with `l` lines and `c` columns at screen-relative position (`x`,`y`).

    val derwin : window -> int -> int -> int -> int -> window

Same as `subwin` excepting that the position (`x`,`y`) is relative to the parent window.

    val mvderwin : window -> int -> int -> err

Move a derived windw.

    val dupwin : window -> window

Duplicate a window.

    val wsyncup : window -> unit

    val syncok : window -> bool -> err

If `syncok` is called with `true` as second argument, `wsyncup` is called automatically whenever there is a change in the window.

    val wcursyncup : window -> unit

    val wsyncdown : window -> unit

    val winch_handler_on : unit -> unit

    val winch_handler_off : unit -> unit

    val get_size : unit -> int * int

    val get_size_fd : Unix.file_descr -> int * int

    val null_window : window

### Refresh control

    val refresh : unit -> err

Refresh windows.

    val wrefresh : window -> err

    val wnoutrefresh : window -> err

    val doupdate : unit -> err

    val redrawwin : window -> err

    val wredrawln : window -> int -> int -> err

    val wresize : window -> int -> int -> err

    val resizeterm : int -> int -> err

    val scroll : window -> err

    val scrl : int -> err

    val wscrl : window -> int -> err

    val touchwin : window -> err

    val touchline : window -> int -> int -> err

    val untouchwin : window -> err

    val wtouchln : window -> int -> int -> bool -> err

    val is_linetouched : window -> int -> int

    val is_wintouched : window -> bool

    val erase : unit -> unit

Clear a window.

    val werase : window -> unit

    val clear : unit -> unit

    val wclear : window -> unit

    val clrtobot : unit -> unit

    val wclrtobot : window -> unit

    val clrtoeol : unit -> unit

    val wclrtoeol : window -> unit

### Overlapped windows

    val overlay : window -> window -> err

`overlay srcwin dstwin` overlays `srcwin` on top of `dstwin`.

    val overwrite : window -> window -> err

    val copywin : window ->
           window -> int -> int -> int -> int -> int -> int -> bool -> err

### Decorations

    val border : chtype ->
           chtype ->
           chtype ->
           chtype ->
           chtype -> chtype -> chtype -> chtype -> unit

Draw a box around the edges of a window.

    val wborder : window ->
           chtype ->
           chtype ->
           chtype ->
           chtype ->
           chtype -> chtype -> chtype -> chtype -> unit

    val box : window -> chtype -> chtype -> unit

Draw a box.

    val hline : chtype -> int -> unit

Draw an horizontal line.

    val whline : window -> chtype -> int -> unit

    val mvhline : int -> int -> chtype -> int -> unit

    val mvwhline : window -> int -> int -> chtype -> int -> unit

    val vline : chtype -> int -> unit

Draw a vertical line.

    val wvline : window -> chtype -> int -> unit

    val mvvline : int -> int -> chtype -> int -> unit

    val mvwvline : window -> int -> int -> chtype -> int -> unit

### Pads

A pad is like a window except that it is not restricted by the screen size, and is not necessarily associated with a particular part of the screen.

    val newpad : int -> int -> window

Create a new pad.

    val subpad : window -> int -> int -> int -> int -> window

    val prefresh : window -> int -> int -> int -> int -> int -> int -> err

    val pnoutrefresh : window -> int -> int -> int -> int -> int -> int -> err

    val pechochar : window -> chtype -> err

## Colors

    module Color: sig .. end

Colors.

    val start_color : unit -> err

    val use_default_colors : unit -> err

    val init_pair : int -> int -> int -> err

    val init_color : int -> int -> int -> int -> err

    val has_colors : unit -> bool

    val can_change_color : unit -> bool

    val color_content : int -> int * int * int

    val pair_content : int -> int * int

    val colors : unit -> int

    val color_pairs : unit -> int

## Input/output options

### Input options

    val cbreak : unit -> err

Disable line buffering.

    val halfdelay : int -> err

Similar to `cbreak` but with delay.

    val nocbreak : unit -> err

Enable line buffering (waits for characters until newline is typed).

    val echo : unit -> err

Don't echo typed characters.

    val noecho : unit -> err

Echo typed characters.

    val intrflush : window -> bool -> err

    val keypad : window -> bool -> err

    val meta : window -> bool -> err

    val nodelay : window -> bool -> err

    val raw : unit -> err

    val noraw : unit -> err

    val noqiflush : unit -> unit

    val qiflush : unit -> unit

    val notimeout : window -> bool -> err

    val timeout : int -> unit

    val wtimeout : window -> int -> unit

    val typeahead : Unix.file_descr -> err

    val notypeahead : unit -> err

### Output options

    val clearok : window -> bool -> unit

If called with `true` as second argument, the next call to `wrefresh` with this window will clear the streen completely and redraw the entire screen from scratch.

    val idlok : window -> bool -> unit

    val idcok : window -> bool -> unit

    val immedok : window -> bool -> unit

    val leaveok : window -> bool -> unit

    val setscrreg : int -> int -> err

    val wsetscrreg : window -> int -> int -> err

    val scrollok : window -> bool -> unit

    val nl : unit -> unit

    val nonl : unit -> unit

## Soft-label keys

    val slk_init : int -> err

Initialize soft labels.

    val slk_set : int -> string -> int -> err

    val slk_refresh : unit -> err

    val slk_noutrefresh : unit -> err

    val slk_label : int -> string

    val slk_clear : unit -> err

    val slk_restore : unit -> err

    val slk_touch : unit -> err

    val slk_attron : attr_t -> err

    val slk_attroff : attr_t -> err

    val slk_attrset : attr_t -> err

## Mouse

    val mousemask : int -> int * int

Sets the mouse mask.

## Misc

    val beep : unit -> err

Ring a bell.

    val flash : unit -> err

Flash the screen.

    val unctrl : chtype -> string

    val keyname : int -> string

    val filter : unit -> unit

    val use_env : bool -> unit

    val putwin : window -> Unix.file_descr -> err

    val getwin : Unix.file_descr -> window

    val delay_output : int -> err

    val flushinp : unit -> unit

## Screen manipulation

    val scr_dump : string -> err

Dump the current screen to a file.

    val scr_restore : string -> err

    val scr_init : string -> err

    val scr_set : string -> err

## Terminal

    val baudrate : unit -> int

Get the speed of a terminal (in bits per second).

    val erasechar : unit -> char

Get user's current erase character.

    val has_ic : unit -> bool

Has the terminal insert- and delete-character capabilites?

    val has_il : unit -> bool

Has the terminal insert- and delete-line capabilites?

    val killchar : unit -> char

Get user's current line kill character.

    val longname : unit -> string

Get a description of the terminal.

    val termattrs : unit -> attr_t

    val termname : unit -> string

    val tgetent : string -> bool

    val tgetflag : string -> bool

    val tgetnum : string -> int

    val tgetstr : string -> bool

    val tgoto : string -> int -> int -> string

    val setupterm : string -> Unix.file_descr -> err

    val setterm : string -> err

    val cur_term : unit -> terminal

    val set_curterm : terminal -> terminal

    val del_curterm : terminal -> err

    val restartterm : string -> Unix.file_descr -> err

    val putp : string -> err

    val vidattr : chtype -> err

    val mvcur : int -> int -> int -> int -> err

    val tigetflag : string -> bool

    val tigetnum : string -> int

    val tigetstr : string -> string

    val tputs : string -> int -> (char -> unit) -> err

    val vidputs : chtype -> (char -> unit) -> err

    val tparm : string -> int array -> string

    val bool_terminfo_variable : int -> string * string * string

    val num_terminfo_variable : int -> string * string * string

    val str_terminfo_variable : int -> string * string * string

    val bool_terminfo_variables : (string, string * string) Hashtbl.t

    val num_terminfo_variables : (string, string * string) Hashtbl.t

    val str_terminfo_variables : (string, string * string) Hashtbl.t

## Low-level curses routines

    val def_prog_mode : unit -> unit

Save the current terminal modes as the "program" state for use by the `reser_prog_mod` and `reset_shell_mode` functions.

    val def_shell_mode : unit -> unit

    val reset_prog_mode : unit -> unit

    val reset_shell_mode : unit -> unit

    val resetty : unit -> unit

    val savetty : unit -> unit

    val getsyx : unit -> int * int

    val setsyx : int -> int -> unit

    val curs_set : int -> err

    val napms : int -> unit

    val ripoffline : bool -> unit

    val get_ripoff : unit -> window * int

## Configuration

    module Curses_config: sig .. end