Up  

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 lorings 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) Stdlib.Hashtbl.t
val num_terminfo_variables : (string, string * string) Stdlib.Hashtbl.t
val str_terminfo_variables : (string, string * string) Stdlib.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