\documentclass[11pt]{article} 
\usepackage[latin1]{inputenc} 
\usepackage[T1]{fontenc} 
\usepackage{fullpage} 
\usepackage{url} 
\usepackage{ocamldoc}
\begin{document}
\tableofcontents
\section{Module {\tt{Curses}} :  Bindings to the ncurses library.}
\label{module:Curses}\index{Curses@\verb`Curses`}



 Beware, all coordinates are passed {\tt{y}} first, then {\tt{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 {\tt{y}} and {\tt{x}} of the point to move the cursor to. For example
 {\tt{mvaddch y x ch}} is the same as {\tt{move y x; addch ch}}.



\ocamldocvspace{0.5cm}



\label{type:Curses.window}\begin{ocamldoccode}
type window 
\end{ocamldoccode}
\index{window@\verb`window`}
\begin{ocamldocdescription}
Windows.


\end{ocamldocdescription}




\label{type:Curses.screen}\begin{ocamldoccode}
type screen 
\end{ocamldoccode}
\index{screen@\verb`screen`}
\begin{ocamldocdescription}
Screens.


\end{ocamldocdescription}




\label{type:Curses.terminal}\begin{ocamldoccode}
type terminal 
\end{ocamldoccode}
\index{terminal@\verb`terminal`}
\begin{ocamldocdescription}
Terminals.


\end{ocamldocdescription}




\label{type:Curses.chtype}\begin{ocamldoccode}
type chtype = int 
\end{ocamldoccode}
\index{chtype@\verb`chtype`}
\begin{ocamldocdescription}
Characters. Usual characters can be converted from/to {\tt{chtype}} using
 {\tt{char\_of\_int}} and {\tt{int\_of\_char}}. See also {\tt{get\_acs\_codes}} for characters
 useful for drawing and the {\tt{Key}} module for special input characters.


\end{ocamldocdescription}




\label{type:Curses.attr-underscoret}\begin{ocamldoccode}
type attr_t = int 
\end{ocamldoccode}
\index{attr-underscoret@\verb`attr_t`}
\begin{ocamldocdescription}
Attributes are {\tt{lor}}ings of flags which are defined in the {\tt{A}} module.


\end{ocamldocdescription}




\label{type:Curses.err}\begin{ocamldoccode}
type err = bool 
\end{ocamldoccode}
\index{err@\verb`err`}
\begin{ocamldocdescription}
A return value. {\tt{false}} means that an error occured.


\end{ocamldocdescription}




\subsection{Initialization functions}




\label{val:Curses.initscr}\begin{ocamldoccode}
val initscr : unit -> window
\end{ocamldoccode}
\index{initscr@\verb`initscr`}
\begin{ocamldocdescription}
Initialize the curses library.


\end{ocamldocdescription}




\label{val:Curses.endwin}\begin{ocamldoccode}
val endwin : unit -> unit
\end{ocamldoccode}
\index{endwin@\verb`endwin`}
\begin{ocamldocdescription}
Restore the terminal (should be called before exiting).


\end{ocamldocdescription}




\label{val:Curses.isendwin}\begin{ocamldoccode}
val isendwin : unit -> bool
\end{ocamldoccode}
\index{isendwin@\verb`isendwin`}
\begin{ocamldocdescription}
Has {\tt{endwin}} been called without any subsequent call to {\tt{werefresh}}?


\end{ocamldocdescription}




\label{val:Curses.newterm}\begin{ocamldoccode}
val newterm : string -> Unix.file_descr -> Unix.file_descr -> screen
\end{ocamldoccode}
\index{newterm@\verb`newterm`}
\begin{ocamldocdescription}
Create a new terminal.


\end{ocamldocdescription}




\label{val:Curses.set-underscoreterm}\begin{ocamldoccode}
val set_term : screen -> unit
\end{ocamldoccode}
\index{set-underscoreterm@\verb`set_term`}
\begin{ocamldocdescription}
Switch terminal.


\end{ocamldocdescription}




\label{val:Curses.delscreen}\begin{ocamldoccode}
val delscreen : screen -> unit
\end{ocamldoccode}
\index{delscreen@\verb`delscreen`}
\begin{ocamldocdescription}
Delete a screen.


\end{ocamldocdescription}




\label{val:Curses.stdscr}\begin{ocamldoccode}
val stdscr : unit -> window
\end{ocamldoccode}
\index{stdscr@\verb`stdscr`}




\subsection{Cursor}




\label{val:Curses.getyx}\begin{ocamldoccode}
val getyx : window -> int * int
\end{ocamldoccode}
\index{getyx@\verb`getyx`}
\begin{ocamldocdescription}
Get the current cursor position.


\end{ocamldocdescription}




\label{val:Curses.getparyx}\begin{ocamldoccode}
val getparyx : window -> int * int
\end{ocamldoccode}
\index{getparyx@\verb`getparyx`}




\label{val:Curses.getbegyx}\begin{ocamldoccode}
val getbegyx : window -> int * int
\end{ocamldoccode}
\index{getbegyx@\verb`getbegyx`}




\label{val:Curses.getmaxyx}\begin{ocamldoccode}
val getmaxyx : window -> int * int
\end{ocamldoccode}
\index{getmaxyx@\verb`getmaxyx`}




\label{val:Curses.move}\begin{ocamldoccode}
val move : int -> int -> err
\end{ocamldoccode}
\index{move@\verb`move`}
\begin{ocamldocdescription}
Move the cursor.


\end{ocamldocdescription}




\label{val:Curses.wmove}\begin{ocamldoccode}
val wmove : window -> int -> int -> err
\end{ocamldoccode}
\index{wmove@\verb`wmove`}




\subsection{Operations on characters}




\begin{ocamldoccode}
{\tt{module }}{\tt{Acs}}{\tt{ : }}\end{ocamldoccode}
\label{module:Curses.Acs}\index{Acs@\verb`Acs`}

\begin{ocamldocsigend}


\label{type:Curses.Acs.acs}\begin{ocamldoccode}
type acs = \{
  ulcorner : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Upper left-hand corner (+).
\end{ocamldoccomment}
\begin{ocamldoccode}
  llcorner : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Lower left-hand corner (+).
\end{ocamldoccomment}
\begin{ocamldoccode}
  urcorner : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Upper right-hand corner (+).
\end{ocamldoccomment}
\begin{ocamldoccode}
  lrcorner : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Lower right-hand corner (+).
\end{ocamldoccomment}
\begin{ocamldoccode}
  ltee : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Left tee (+).
\end{ocamldoccomment}
\begin{ocamldoccode}
  rtee : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Tight tee (+).
\end{ocamldoccomment}
\begin{ocamldoccode}
  btee : Curses.chtype ;
  ttee : Curses.chtype ;
  hline : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Horizontal line (-).
\end{ocamldoccomment}
\begin{ocamldoccode}
  vline : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Vertical line (\textbar ).
\end{ocamldoccomment}
\begin{ocamldoccode}
  plus : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Plus (+).
\end{ocamldoccomment}
\begin{ocamldoccode}
  s1 : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Scan line 1 (-).
\end{ocamldoccomment}
\begin{ocamldoccode}
  s9 : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Scan line 9 (\_).
\end{ocamldoccomment}
\begin{ocamldoccode}
  diamond : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Diamond (+).
\end{ocamldoccomment}
\begin{ocamldoccode}
  ckboard : Curses.chtype ;
  degree : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Degree symbol (').
\end{ocamldoccomment}
\begin{ocamldoccode}
  plminus : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Plus/minus (\verb`#`).
\end{ocamldoccomment}
\begin{ocamldoccode}
  bullet : Curses.chtype ;
  larrow : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Arrow pointing left ($<$).
\end{ocamldoccomment}
\begin{ocamldoccode}
  rarrow : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Arrow pointing right ($>$).
\end{ocamldoccomment}
\begin{ocamldoccode}
  darrow : Curses.chtype ;
  uarrow : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Arrow pointing up (\textasciicircum ).
\end{ocamldoccomment}
\begin{ocamldoccode}
  board : Curses.chtype ;
  lantern : Curses.chtype ;
  block : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Solid square block (\verb`#`).
\end{ocamldoccomment}
\begin{ocamldoccode}
  s3 : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Scan line 3 (-).
\end{ocamldoccomment}
\begin{ocamldoccode}
  s7 : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Scan line 7 (-).
\end{ocamldoccomment}
\begin{ocamldoccode}
  lequal : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Less-than-or-equal-to ($<$).
\end{ocamldoccomment}
\begin{ocamldoccode}
  gequal : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Greater-or-equal-to ($>$).
\end{ocamldoccomment}
\begin{ocamldoccode}
  pi : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Greek pi ( * ).
\end{ocamldoccomment}
\begin{ocamldoccode}
  nequal : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Not-equal (!).
\end{ocamldoccomment}
\begin{ocamldoccode}
  sterling : Curses.chtype ;
\end{ocamldoccode}
\begin{ocamldoccomment}
Pound-Sterling symbol (f).
\end{ocamldoccomment}
\begin{ocamldoccode}
\}
\end{ocamldoccode}
\index{acs@\verb`acs`}


\label{val:Curses.Acs.bssb}\begin{ocamldoccode}
val bssb : acs -> Curses.chtype
\end{ocamldoccode}
\index{bssb@\verb`bssb`}


\label{val:Curses.Acs.ssbb}\begin{ocamldoccode}
val ssbb : acs -> Curses.chtype
\end{ocamldoccode}
\index{ssbb@\verb`ssbb`}


\label{val:Curses.Acs.bbss}\begin{ocamldoccode}
val bbss : acs -> Curses.chtype
\end{ocamldoccode}
\index{bbss@\verb`bbss`}


\label{val:Curses.Acs.sbbs}\begin{ocamldoccode}
val sbbs : acs -> Curses.chtype
\end{ocamldoccode}
\index{sbbs@\verb`sbbs`}


\label{val:Curses.Acs.sbss}\begin{ocamldoccode}
val sbss : acs -> Curses.chtype
\end{ocamldoccode}
\index{sbss@\verb`sbss`}


\label{val:Curses.Acs.sssb}\begin{ocamldoccode}
val sssb : acs -> Curses.chtype
\end{ocamldoccode}
\index{sssb@\verb`sssb`}


\label{val:Curses.Acs.ssbs}\begin{ocamldoccode}
val ssbs : acs -> Curses.chtype
\end{ocamldoccode}
\index{ssbs@\verb`ssbs`}


\label{val:Curses.Acs.bsss}\begin{ocamldoccode}
val bsss : acs -> Curses.chtype
\end{ocamldoccode}
\index{bsss@\verb`bsss`}


\label{val:Curses.Acs.bsbs}\begin{ocamldoccode}
val bsbs : acs -> Curses.chtype
\end{ocamldoccode}
\index{bsbs@\verb`bsbs`}


\label{val:Curses.Acs.sbsb}\begin{ocamldoccode}
val sbsb : acs -> Curses.chtype
\end{ocamldoccode}
\index{sbsb@\verb`sbsb`}


\label{val:Curses.Acs.ssss}\begin{ocamldoccode}
val ssss : acs -> Curses.chtype
\end{ocamldoccode}
\index{ssss@\verb`ssss`}
\end{ocamldocsigend}


\begin{ocamldocdescription}
Predefined characters.


\end{ocamldocdescription}




\label{val:Curses.get-underscoreacs-underscorecodes}\begin{ocamldoccode}
val get_acs_codes : unit -> Acs.acs
\end{ocamldoccode}
\index{get-underscoreacs-underscorecodes@\verb`get_acs_codes`}
\begin{ocamldocdescription}
Get the predefined characters.


\end{ocamldocdescription}




\subsubsection{Displaying characters}




\label{val:Curses.addch}\begin{ocamldoccode}
val addch : chtype -> err
\end{ocamldoccode}
\index{addch@\verb`addch`}
\begin{ocamldocdescription}
Add a character at the current position, then advance the cursor.


\end{ocamldocdescription}




\label{val:Curses.waddch}\begin{ocamldoccode}
val waddch : window -> chtype -> err
\end{ocamldoccode}
\index{waddch@\verb`waddch`}




\label{val:Curses.mvaddch}\begin{ocamldoccode}
val mvaddch : int -> int -> chtype -> err
\end{ocamldoccode}
\index{mvaddch@\verb`mvaddch`}




\label{val:Curses.mvwaddch}\begin{ocamldoccode}
val mvwaddch : window -> int -> int -> chtype -> err
\end{ocamldoccode}
\index{mvwaddch@\verb`mvwaddch`}




\label{val:Curses.echochar}\begin{ocamldoccode}
val echochar : chtype -> err
\end{ocamldoccode}
\index{echochar@\verb`echochar`}
\begin{ocamldocdescription}
{\tt{echochar ch}} is equivalent to {\tt{addch ch}} followed by {\tt{refresh ()}}.


\end{ocamldocdescription}




\label{val:Curses.wechochar}\begin{ocamldoccode}
val wechochar : window -> chtype -> err
\end{ocamldoccode}
\index{wechochar@\verb`wechochar`}




\label{val:Curses.addchstr}\begin{ocamldoccode}
val addchstr : chtype array -> err
\end{ocamldoccode}
\index{addchstr@\verb`addchstr`}
\begin{ocamldocdescription}
Add a sequence of characters at the current position. See also {\tt{addstr}}.


\end{ocamldocdescription}




\label{val:Curses.waddchstr}\begin{ocamldoccode}
val waddchstr : window -> chtype array -> err
\end{ocamldoccode}
\index{waddchstr@\verb`waddchstr`}




\label{val:Curses.mvaddchstr}\begin{ocamldoccode}
val mvaddchstr : int -> int -> chtype array -> err
\end{ocamldoccode}
\index{mvaddchstr@\verb`mvaddchstr`}




\label{val:Curses.mvwaddchstr}\begin{ocamldoccode}
val mvwaddchstr : window -> int -> int -> chtype array -> err
\end{ocamldoccode}
\index{mvwaddchstr@\verb`mvwaddchstr`}




\label{val:Curses.addchnstr}\begin{ocamldoccode}
val addchnstr : chtype array -> int -> int -> err
\end{ocamldoccode}
\index{addchnstr@\verb`addchnstr`}




\label{val:Curses.waddchnstr}\begin{ocamldoccode}
val waddchnstr : window -> chtype array -> int -> int -> err
\end{ocamldoccode}
\index{waddchnstr@\verb`waddchnstr`}




\label{val:Curses.mvaddchnstr}\begin{ocamldoccode}
val mvaddchnstr : int -> int -> chtype array -> int -> int -> err
\end{ocamldoccode}
\index{mvaddchnstr@\verb`mvaddchnstr`}




\label{val:Curses.mvwaddchnstr}\begin{ocamldoccode}
val mvwaddchnstr :
  window ->
  int -> int -> chtype array -> int -> int -> err
\end{ocamldoccode}
\index{mvwaddchnstr@\verb`mvwaddchnstr`}




\label{val:Curses.addstr}\begin{ocamldoccode}
val addstr : string -> err
\end{ocamldoccode}
\index{addstr@\verb`addstr`}
\begin{ocamldocdescription}
Add a string at the current position.


\end{ocamldocdescription}




\label{val:Curses.waddstr}\begin{ocamldoccode}
val waddstr : window -> string -> err
\end{ocamldoccode}
\index{waddstr@\verb`waddstr`}




\label{val:Curses.mvaddstr}\begin{ocamldoccode}
val mvaddstr : int -> int -> string -> err
\end{ocamldoccode}
\index{mvaddstr@\verb`mvaddstr`}




\label{val:Curses.mvwaddstr}\begin{ocamldoccode}
val mvwaddstr : window -> int -> int -> string -> err
\end{ocamldoccode}
\index{mvwaddstr@\verb`mvwaddstr`}




\label{val:Curses.addnstr}\begin{ocamldoccode}
val addnstr : string -> int -> int -> err
\end{ocamldoccode}
\index{addnstr@\verb`addnstr`}




\label{val:Curses.waddnstr}\begin{ocamldoccode}
val waddnstr : window -> string -> int -> int -> err
\end{ocamldoccode}
\index{waddnstr@\verb`waddnstr`}




\label{val:Curses.mvaddnstr}\begin{ocamldoccode}
val mvaddnstr : int -> int -> string -> int -> int -> err
\end{ocamldoccode}
\index{mvaddnstr@\verb`mvaddnstr`}




\label{val:Curses.mvwaddnstr}\begin{ocamldoccode}
val mvwaddnstr : window -> int -> int -> string -> int -> int -> err
\end{ocamldoccode}
\index{mvwaddnstr@\verb`mvwaddnstr`}




\label{val:Curses.insch}\begin{ocamldoccode}
val insch : chtype -> err
\end{ocamldoccode}
\index{insch@\verb`insch`}
\begin{ocamldocdescription}
Insert a character before cursor.


\end{ocamldocdescription}




\label{val:Curses.winsch}\begin{ocamldoccode}
val winsch : window -> chtype -> err
\end{ocamldoccode}
\index{winsch@\verb`winsch`}




\label{val:Curses.mvinsch}\begin{ocamldoccode}
val mvinsch : int -> int -> chtype -> err
\end{ocamldoccode}
\index{mvinsch@\verb`mvinsch`}




\label{val:Curses.mvwinsch}\begin{ocamldoccode}
val mvwinsch : window -> int -> int -> chtype -> err
\end{ocamldoccode}
\index{mvwinsch@\verb`mvwinsch`}




\label{val:Curses.insstr}\begin{ocamldoccode}
val insstr : string -> err
\end{ocamldoccode}
\index{insstr@\verb`insstr`}
\begin{ocamldocdescription}
Insert a string before cursor.


\end{ocamldocdescription}




\label{val:Curses.winsstr}\begin{ocamldoccode}
val winsstr : window -> string -> err
\end{ocamldoccode}
\index{winsstr@\verb`winsstr`}




\label{val:Curses.mvinsstr}\begin{ocamldoccode}
val mvinsstr : int -> int -> string -> err
\end{ocamldoccode}
\index{mvinsstr@\verb`mvinsstr`}




\label{val:Curses.mvwinsstr}\begin{ocamldoccode}
val mvwinsstr : window -> int -> int -> string -> err
\end{ocamldoccode}
\index{mvwinsstr@\verb`mvwinsstr`}




\label{val:Curses.insnstr}\begin{ocamldoccode}
val insnstr : string -> int -> int -> err
\end{ocamldoccode}
\index{insnstr@\verb`insnstr`}




\label{val:Curses.winsnstr}\begin{ocamldoccode}
val winsnstr : window -> string -> int -> int -> err
\end{ocamldoccode}
\index{winsnstr@\verb`winsnstr`}




\label{val:Curses.mvinsnstr}\begin{ocamldoccode}
val mvinsnstr : int -> int -> string -> int -> int -> err
\end{ocamldoccode}
\index{mvinsnstr@\verb`mvinsnstr`}




\label{val:Curses.mvwinsnstr}\begin{ocamldoccode}
val mvwinsnstr : window -> int -> int -> string -> int -> int -> err
\end{ocamldoccode}
\index{mvwinsnstr@\verb`mvwinsnstr`}




\label{val:Curses.delch}\begin{ocamldoccode}
val delch : unit -> err
\end{ocamldoccode}
\index{delch@\verb`delch`}
\begin{ocamldocdescription}
Delete a character.


\end{ocamldocdescription}




\label{val:Curses.wdelch}\begin{ocamldoccode}
val wdelch : window -> err
\end{ocamldoccode}
\index{wdelch@\verb`wdelch`}




\label{val:Curses.mvdelch}\begin{ocamldoccode}
val mvdelch : int -> int -> err
\end{ocamldoccode}
\index{mvdelch@\verb`mvdelch`}




\label{val:Curses.mvwdelch}\begin{ocamldoccode}
val mvwdelch : window -> int -> int -> err
\end{ocamldoccode}
\index{mvwdelch@\verb`mvwdelch`}




\subsubsection{Attributes}




\begin{ocamldoccode}
{\tt{module }}{\tt{A}}{\tt{ : }}\end{ocamldoccode}
\label{module:Curses.A}\index{A@\verb`A`}

\begin{ocamldocsigend}


\label{val:Curses.A.normal}\begin{ocamldoccode}
val normal : int
\end{ocamldoccode}
\index{normal@\verb`normal`}
\begin{ocamldocdescription}
Normal display (no highlight).


\end{ocamldocdescription}


\label{val:Curses.A.attributes}\begin{ocamldoccode}
val attributes : int
\end{ocamldoccode}
\index{attributes@\verb`attributes`}


\label{val:Curses.A.chartext}\begin{ocamldoccode}
val chartext : int
\end{ocamldoccode}
\index{chartext@\verb`chartext`}
\begin{ocamldocdescription}
Bit-mask to extract a character.


\end{ocamldocdescription}


\label{val:Curses.A.color}\begin{ocamldoccode}
val color : int
\end{ocamldoccode}
\index{color@\verb`color`}


\label{val:Curses.A.standout}\begin{ocamldoccode}
val standout : int
\end{ocamldoccode}
\index{standout@\verb`standout`}
\begin{ocamldocdescription}
Best highlighting mode of the terminal.


\end{ocamldocdescription}


\label{val:Curses.A.underline}\begin{ocamldoccode}
val underline : int
\end{ocamldoccode}
\index{underline@\verb`underline`}
\begin{ocamldocdescription}
Underlining.


\end{ocamldocdescription}


\label{val:Curses.A.reverse}\begin{ocamldoccode}
val reverse : int
\end{ocamldoccode}
\index{reverse@\verb`reverse`}
\begin{ocamldocdescription}
Reverse video.


\end{ocamldocdescription}


\label{val:Curses.A.blink}\begin{ocamldoccode}
val blink : int
\end{ocamldoccode}
\index{blink@\verb`blink`}
\begin{ocamldocdescription}
Blinking.


\end{ocamldocdescription}


\label{val:Curses.A.dim}\begin{ocamldoccode}
val dim : int
\end{ocamldoccode}
\index{dim@\verb`dim`}
\begin{ocamldocdescription}
Half bright.


\end{ocamldocdescription}


\label{val:Curses.A.bold}\begin{ocamldoccode}
val bold : int
\end{ocamldoccode}
\index{bold@\verb`bold`}
\begin{ocamldocdescription}
Extra bright or bold.


\end{ocamldocdescription}


\label{val:Curses.A.altcharset}\begin{ocamldoccode}
val altcharset : int
\end{ocamldoccode}
\index{altcharset@\verb`altcharset`}
\begin{ocamldocdescription}
Alternate character set.


\end{ocamldocdescription}


\label{val:Curses.A.invis}\begin{ocamldoccode}
val invis : int
\end{ocamldoccode}
\index{invis@\verb`invis`}
\begin{ocamldocdescription}
Invisible or blank mode.


\end{ocamldocdescription}


\label{val:Curses.A.protect}\begin{ocamldoccode}
val protect : int
\end{ocamldoccode}
\index{protect@\verb`protect`}
\begin{ocamldocdescription}
Protected mode.


\end{ocamldocdescription}


\label{val:Curses.A.horizontal}\begin{ocamldoccode}
val horizontal : int
\end{ocamldoccode}
\index{horizontal@\verb`horizontal`}


\label{val:Curses.A.left}\begin{ocamldoccode}
val left : int
\end{ocamldoccode}
\index{left@\verb`left`}


\label{val:Curses.A.low}\begin{ocamldoccode}
val low : int
\end{ocamldoccode}
\index{low@\verb`low`}


\label{val:Curses.A.right}\begin{ocamldoccode}
val right : int
\end{ocamldoccode}
\index{right@\verb`right`}


\label{val:Curses.A.top}\begin{ocamldoccode}
val top : int
\end{ocamldoccode}
\index{top@\verb`top`}


\label{val:Curses.A.vertical}\begin{ocamldoccode}
val vertical : int
\end{ocamldoccode}
\index{vertical@\verb`vertical`}


\label{val:Curses.A.combine}\begin{ocamldoccode}
val combine : int list -> int
\end{ocamldoccode}
\index{combine@\verb`combine`}


\label{val:Curses.A.color-underscorepair}\begin{ocamldoccode}
val color_pair : int -> int
\end{ocamldoccode}
\index{color-underscorepair@\verb`color_pair`}
\begin{ocamldocdescription}
Color-pair number {\tt{n}}.


\end{ocamldocdescription}


\label{val:Curses.A.pair-underscorenumber}\begin{ocamldoccode}
val pair_number : int -> int
\end{ocamldoccode}
\index{pair-underscorenumber@\verb`pair_number`}
\begin{ocamldocdescription}
Get the pair number associated with the {\tt{color\_pair n}} attribute.


\end{ocamldocdescription}
\end{ocamldocsigend}


\begin{ocamldocdescription}
Attributes.


\end{ocamldocdescription}




\begin{ocamldoccode}
{\tt{module }}{\tt{WA}}{\tt{ : }}\end{ocamldoccode}
\label{module:Curses.WA}\index{WA@\verb`WA`}

\begin{ocamldocsigend}


\label{val:Curses.WA.normal}\begin{ocamldoccode}
val normal : int
\end{ocamldoccode}
\index{normal@\verb`normal`}
\begin{ocamldocdescription}
Normal display (no highlight).


\end{ocamldocdescription}


\label{val:Curses.WA.attributes}\begin{ocamldoccode}
val attributes : int
\end{ocamldoccode}
\index{attributes@\verb`attributes`}


\label{val:Curses.WA.chartext}\begin{ocamldoccode}
val chartext : int
\end{ocamldoccode}
\index{chartext@\verb`chartext`}


\label{val:Curses.WA.color}\begin{ocamldoccode}
val color : int
\end{ocamldoccode}
\index{color@\verb`color`}


\label{val:Curses.WA.standout}\begin{ocamldoccode}
val standout : int
\end{ocamldoccode}
\index{standout@\verb`standout`}
\begin{ocamldocdescription}
Best highlighting mode of the terminal. Same as {\tt{attron A.standout}}.


\end{ocamldocdescription}


\label{val:Curses.WA.underline}\begin{ocamldoccode}
val underline : int
\end{ocamldoccode}
\index{underline@\verb`underline`}
\begin{ocamldocdescription}
Underlining.


\end{ocamldocdescription}


\label{val:Curses.WA.reverse}\begin{ocamldoccode}
val reverse : int
\end{ocamldoccode}
\index{reverse@\verb`reverse`}
\begin{ocamldocdescription}
Reverse video.


\end{ocamldocdescription}


\label{val:Curses.WA.blink}\begin{ocamldoccode}
val blink : int
\end{ocamldoccode}
\index{blink@\verb`blink`}
\begin{ocamldocdescription}
Blinking.


\end{ocamldocdescription}


\label{val:Curses.WA.dim}\begin{ocamldoccode}
val dim : int
\end{ocamldoccode}
\index{dim@\verb`dim`}
\begin{ocamldocdescription}
Half bright.


\end{ocamldocdescription}


\label{val:Curses.WA.bold}\begin{ocamldoccode}
val bold : int
\end{ocamldoccode}
\index{bold@\verb`bold`}
\begin{ocamldocdescription}
Extra bright or bold.


\end{ocamldocdescription}


\label{val:Curses.WA.altcharset}\begin{ocamldoccode}
val altcharset : int
\end{ocamldoccode}
\index{altcharset@\verb`altcharset`}
\begin{ocamldocdescription}
Alternate character set.


\end{ocamldocdescription}


\label{val:Curses.WA.invis}\begin{ocamldoccode}
val invis : int
\end{ocamldoccode}
\index{invis@\verb`invis`}


\label{val:Curses.WA.protect}\begin{ocamldoccode}
val protect : int
\end{ocamldoccode}
\index{protect@\verb`protect`}


\label{val:Curses.WA.horizontal}\begin{ocamldoccode}
val horizontal : int
\end{ocamldoccode}
\index{horizontal@\verb`horizontal`}


\label{val:Curses.WA.left}\begin{ocamldoccode}
val left : int
\end{ocamldoccode}
\index{left@\verb`left`}


\label{val:Curses.WA.low}\begin{ocamldoccode}
val low : int
\end{ocamldoccode}
\index{low@\verb`low`}


\label{val:Curses.WA.right}\begin{ocamldoccode}
val right : int
\end{ocamldoccode}
\index{right@\verb`right`}


\label{val:Curses.WA.top}\begin{ocamldoccode}
val top : int
\end{ocamldoccode}
\index{top@\verb`top`}


\label{val:Curses.WA.vertical}\begin{ocamldoccode}
val vertical : int
\end{ocamldoccode}
\index{vertical@\verb`vertical`}


\label{val:Curses.WA.combine}\begin{ocamldoccode}
val combine : int list -> int
\end{ocamldoccode}
\index{combine@\verb`combine`}


\label{val:Curses.WA.color-underscorepair}\begin{ocamldoccode}
val color_pair : int -> int
\end{ocamldoccode}
\index{color-underscorepair@\verb`color_pair`}


\label{val:Curses.WA.pair-underscorenumber}\begin{ocamldoccode}
val pair_number : int -> int
\end{ocamldoccode}
\index{pair-underscorenumber@\verb`pair_number`}
\end{ocamldocsigend}


\begin{ocamldocdescription}
New series of highlight attributes.


\end{ocamldocdescription}




\label{val:Curses.attroff}\begin{ocamldoccode}
val attroff : int -> unit
\end{ocamldoccode}
\index{attroff@\verb`attroff`}
\begin{ocamldocdescription}
Turn off the attributes given in argument (see the {\tt{A}} module).


\end{ocamldocdescription}




\label{val:Curses.wattroff}\begin{ocamldoccode}
val wattroff : window -> int -> unit
\end{ocamldoccode}
\index{wattroff@\verb`wattroff`}




\label{val:Curses.attron}\begin{ocamldoccode}
val attron : int -> unit
\end{ocamldoccode}
\index{attron@\verb`attron`}
\begin{ocamldocdescription}
Turn on the attributes given in argument.


\end{ocamldocdescription}




\label{val:Curses.wattron}\begin{ocamldoccode}
val wattron : window -> int -> unit
\end{ocamldoccode}
\index{wattron@\verb`wattron`}




\label{val:Curses.attrset}\begin{ocamldoccode}
val attrset : int -> unit
\end{ocamldoccode}
\index{attrset@\verb`attrset`}
\begin{ocamldocdescription}
Set the attributes.


\end{ocamldocdescription}




\label{val:Curses.wattrset}\begin{ocamldoccode}
val wattrset : window -> int -> unit
\end{ocamldoccode}
\index{wattrset@\verb`wattrset`}




\label{val:Curses.standend}\begin{ocamldoccode}
val standend : unit -> unit
\end{ocamldoccode}
\index{standend@\verb`standend`}




\label{val:Curses.wstandend}\begin{ocamldoccode}
val wstandend : window -> unit
\end{ocamldoccode}
\index{wstandend@\verb`wstandend`}




\label{val:Curses.standout}\begin{ocamldoccode}
val standout : unit -> unit
\end{ocamldoccode}
\index{standout@\verb`standout`}




\label{val:Curses.wstandout}\begin{ocamldoccode}
val wstandout : window -> unit
\end{ocamldoccode}
\index{wstandout@\verb`wstandout`}




\label{val:Curses.attr-underscoreoff}\begin{ocamldoccode}
val attr_off : attr_t -> unit
\end{ocamldoccode}
\index{attr-underscoreoff@\verb`attr_off`}
\begin{ocamldocdescription}
Turn off the attributes given in argument (see the {\tt{WA}} module).


\end{ocamldocdescription}




\label{val:Curses.wattr-underscoreoff}\begin{ocamldoccode}
val wattr_off : window -> attr_t -> unit
\end{ocamldoccode}
\index{wattr-underscoreoff@\verb`wattr_off`}




\label{val:Curses.attr-underscoreon}\begin{ocamldoccode}
val attr_on : attr_t -> unit
\end{ocamldoccode}
\index{attr-underscoreon@\verb`attr_on`}




\label{val:Curses.wattr-underscoreon}\begin{ocamldoccode}
val wattr_on : window -> attr_t -> unit
\end{ocamldoccode}
\index{wattr-underscoreon@\verb`wattr_on`}




\label{val:Curses.attr-underscoreset}\begin{ocamldoccode}
val attr_set : attr_t -> int -> unit
\end{ocamldoccode}
\index{attr-underscoreset@\verb`attr_set`}




\label{val:Curses.wattr-underscoreset}\begin{ocamldoccode}
val wattr_set : window -> attr_t -> int -> unit
\end{ocamldoccode}
\index{wattr-underscoreset@\verb`wattr_set`}




\label{val:Curses.chgat}\begin{ocamldoccode}
val chgat : int -> attr_t -> int -> unit
\end{ocamldoccode}
\index{chgat@\verb`chgat`}
\begin{ocamldocdescription}
{\tt{chgat n attr color}} changes the attributes of {\tt{n}} characters.


\end{ocamldocdescription}




\label{val:Curses.wchgat}\begin{ocamldoccode}
val wchgat : window -> int -> attr_t -> int -> unit
\end{ocamldoccode}
\index{wchgat@\verb`wchgat`}




\label{val:Curses.mvchgat}\begin{ocamldoccode}
val mvchgat : int -> int -> int -> attr_t -> int -> unit
\end{ocamldoccode}
\index{mvchgat@\verb`mvchgat`}




\label{val:Curses.mvwchgat}\begin{ocamldoccode}
val mvwchgat : window -> int -> int -> int -> attr_t -> int -> unit
\end{ocamldoccode}
\index{mvwchgat@\verb`mvwchgat`}




\label{val:Curses.inch}\begin{ocamldoccode}
val inch : unit -> chtype
\end{ocamldoccode}
\index{inch@\verb`inch`}
\begin{ocamldocdescription}
Get the attributes of the caracter at current position.


\end{ocamldocdescription}




\label{val:Curses.winch}\begin{ocamldoccode}
val winch : window -> chtype
\end{ocamldoccode}
\index{winch@\verb`winch`}




\label{val:Curses.mvinch}\begin{ocamldoccode}
val mvinch : int -> int -> chtype
\end{ocamldoccode}
\index{mvinch@\verb`mvinch`}




\label{val:Curses.mvwinch}\begin{ocamldoccode}
val mvwinch : window -> int -> int -> chtype
\end{ocamldoccode}
\index{mvwinch@\verb`mvwinch`}




\label{val:Curses.inchstr}\begin{ocamldoccode}
val inchstr : chtype array -> err
\end{ocamldoccode}
\index{inchstr@\verb`inchstr`}
\begin{ocamldocdescription}
Get the attributes of a sequence of characters.


\end{ocamldocdescription}




\label{val:Curses.winchstr}\begin{ocamldoccode}
val winchstr : window -> chtype array -> err
\end{ocamldoccode}
\index{winchstr@\verb`winchstr`}




\label{val:Curses.mvinchstr}\begin{ocamldoccode}
val mvinchstr : int -> int -> chtype array -> err
\end{ocamldoccode}
\index{mvinchstr@\verb`mvinchstr`}




\label{val:Curses.mvwinchstr}\begin{ocamldoccode}
val mvwinchstr : window -> int -> int -> chtype array -> err
\end{ocamldoccode}
\index{mvwinchstr@\verb`mvwinchstr`}




\label{val:Curses.inchnstr}\begin{ocamldoccode}
val inchnstr : chtype array -> int -> int -> err
\end{ocamldoccode}
\index{inchnstr@\verb`inchnstr`}




\label{val:Curses.winchnstr}\begin{ocamldoccode}
val winchnstr : window -> chtype array -> int -> int -> err
\end{ocamldoccode}
\index{winchnstr@\verb`winchnstr`}




\label{val:Curses.mvinchnstr}\begin{ocamldoccode}
val mvinchnstr : int -> int -> chtype array -> int -> int -> err
\end{ocamldoccode}
\index{mvinchnstr@\verb`mvinchnstr`}




\label{val:Curses.mvwinchnstr}\begin{ocamldoccode}
val mvwinchnstr : window ->
  int -> int -> chtype array -> int -> int -> err
\end{ocamldoccode}
\index{mvwinchnstr@\verb`mvwinchnstr`}




\label{val:Curses.instr}\begin{ocamldoccode}
val instr : string -> err
\end{ocamldoccode}
\index{instr@\verb`instr`}
\begin{ocamldocdescription}
Get the attributes of a string.


\end{ocamldocdescription}




\label{val:Curses.winstr}\begin{ocamldoccode}
val winstr : window -> string -> err
\end{ocamldoccode}
\index{winstr@\verb`winstr`}




\label{val:Curses.mvinstr}\begin{ocamldoccode}
val mvinstr : int -> int -> string -> err
\end{ocamldoccode}
\index{mvinstr@\verb`mvinstr`}




\label{val:Curses.mvwinstr}\begin{ocamldoccode}
val mvwinstr : window -> int -> int -> string -> err
\end{ocamldoccode}
\index{mvwinstr@\verb`mvwinstr`}




\label{val:Curses.innstr}\begin{ocamldoccode}
val innstr : string -> int -> int -> err
\end{ocamldoccode}
\index{innstr@\verb`innstr`}




\label{val:Curses.winnstr}\begin{ocamldoccode}
val winnstr : window -> string -> int -> int -> err
\end{ocamldoccode}
\index{winnstr@\verb`winnstr`}




\label{val:Curses.mvinnstr}\begin{ocamldoccode}
val mvinnstr : int -> int -> string -> int -> int -> err
\end{ocamldoccode}
\index{mvinnstr@\verb`mvinnstr`}




\label{val:Curses.mvwinnstr}\begin{ocamldoccode}
val mvwinnstr : window -> int -> int -> string -> int -> int -> err
\end{ocamldoccode}
\index{mvwinnstr@\verb`mvwinnstr`}




\subsubsection{Background}




\label{val:Curses.bkgdset}\begin{ocamldoccode}
val bkgdset : chtype -> unit
\end{ocamldoccode}
\index{bkgdset@\verb`bkgdset`}
\begin{ocamldocdescription}
Set the background of the current character.


\end{ocamldocdescription}




\label{val:Curses.wbkgdset}\begin{ocamldoccode}
val wbkgdset : window -> chtype -> unit
\end{ocamldoccode}
\index{wbkgdset@\verb`wbkgdset`}




\label{val:Curses.bkgd}\begin{ocamldoccode}
val bkgd : chtype -> unit
\end{ocamldoccode}
\index{bkgd@\verb`bkgd`}
\begin{ocamldocdescription}
Set the background of every character.


\end{ocamldocdescription}




\label{val:Curses.wbkgd}\begin{ocamldoccode}
val wbkgd : window -> chtype -> unit
\end{ocamldoccode}
\index{wbkgd@\verb`wbkgd`}




\label{val:Curses.getbkgd}\begin{ocamldoccode}
val getbkgd : window -> chtype
\end{ocamldoccode}
\index{getbkgd@\verb`getbkgd`}
\begin{ocamldocdescription}
Get the current background.


\end{ocamldocdescription}




\subsubsection{Operations on lines}




\label{val:Curses.deleteln}\begin{ocamldoccode}
val deleteln : unit -> err
\end{ocamldoccode}
\index{deleteln@\verb`deleteln`}
\begin{ocamldocdescription}
Delete a line.


\end{ocamldocdescription}




\label{val:Curses.wdeleteln}\begin{ocamldoccode}
val wdeleteln : window -> err
\end{ocamldoccode}
\index{wdeleteln@\verb`wdeleteln`}




\label{val:Curses.insdelln}\begin{ocamldoccode}
val insdelln : int -> err
\end{ocamldoccode}
\index{insdelln@\verb`insdelln`}
\begin{ocamldocdescription}
{\tt{insdelln n}} inserts {\tt{n}} lines above the current line if {\tt{n}} is positive or
 deletes {\tt{-n}} lines if {\tt{n}} is negative.


\end{ocamldocdescription}




\label{val:Curses.winsdelln}\begin{ocamldoccode}
val winsdelln : window -> int -> err
\end{ocamldoccode}
\index{winsdelln@\verb`winsdelln`}




\label{val:Curses.insertln}\begin{ocamldoccode}
val insertln : unit -> err
\end{ocamldoccode}
\index{insertln@\verb`insertln`}
\begin{ocamldocdescription}
Insert a blank line above the current line.


\end{ocamldocdescription}




\label{val:Curses.winsertln}\begin{ocamldoccode}
val winsertln : window -> err
\end{ocamldoccode}
\index{winsertln@\verb`winsertln`}




\subsubsection{Characters input}




\begin{ocamldoccode}
{\tt{module }}{\tt{Key}}{\tt{ : }}\end{ocamldoccode}
\label{module:Curses.Key}\index{Key@\verb`Key`}

\begin{ocamldocsigend}


\label{val:Curses.Key.code-underscoreyes}\begin{ocamldoccode}
val code_yes : int
\end{ocamldoccode}
\index{code-underscoreyes@\verb`code_yes`}


\label{val:Curses.Key.min}\begin{ocamldoccode}
val min : int
\end{ocamldoccode}
\index{min@\verb`min`}


\label{val:Curses.Key.break}\begin{ocamldoccode}
val break : int
\end{ocamldoccode}
\index{break@\verb`break`}


\label{val:Curses.Key.down}\begin{ocamldoccode}
val down : int
\end{ocamldoccode}
\index{down@\verb`down`}


\label{val:Curses.Key.up}\begin{ocamldoccode}
val up : int
\end{ocamldoccode}
\index{up@\verb`up`}


\label{val:Curses.Key.left}\begin{ocamldoccode}
val left : int
\end{ocamldoccode}
\index{left@\verb`left`}


\label{val:Curses.Key.right}\begin{ocamldoccode}
val right : int
\end{ocamldoccode}
\index{right@\verb`right`}


\label{val:Curses.Key.home}\begin{ocamldoccode}
val home : int
\end{ocamldoccode}
\index{home@\verb`home`}


\label{val:Curses.Key.backspace}\begin{ocamldoccode}
val backspace : int
\end{ocamldoccode}
\index{backspace@\verb`backspace`}


\label{val:Curses.Key.f0}\begin{ocamldoccode}
val f0 : int
\end{ocamldoccode}
\index{f0@\verb`f0`}


\label{val:Curses.Key.dl}\begin{ocamldoccode}
val dl : int
\end{ocamldoccode}
\index{dl@\verb`dl`}


\label{val:Curses.Key.il}\begin{ocamldoccode}
val il : int
\end{ocamldoccode}
\index{il@\verb`il`}


\label{val:Curses.Key.dc}\begin{ocamldoccode}
val dc : int
\end{ocamldoccode}
\index{dc@\verb`dc`}


\label{val:Curses.Key.ic}\begin{ocamldoccode}
val ic : int
\end{ocamldoccode}
\index{ic@\verb`ic`}


\label{val:Curses.Key.eic}\begin{ocamldoccode}
val eic : int
\end{ocamldoccode}
\index{eic@\verb`eic`}


\label{val:Curses.Key.clear}\begin{ocamldoccode}
val clear : int
\end{ocamldoccode}
\index{clear@\verb`clear`}


\label{val:Curses.Key.eos}\begin{ocamldoccode}
val eos : int
\end{ocamldoccode}
\index{eos@\verb`eos`}


\label{val:Curses.Key.eol}\begin{ocamldoccode}
val eol : int
\end{ocamldoccode}
\index{eol@\verb`eol`}


\label{val:Curses.Key.sf}\begin{ocamldoccode}
val sf : int
\end{ocamldoccode}
\index{sf@\verb`sf`}


\label{val:Curses.Key.sr}\begin{ocamldoccode}
val sr : int
\end{ocamldoccode}
\index{sr@\verb`sr`}


\label{val:Curses.Key.npage}\begin{ocamldoccode}
val npage : int
\end{ocamldoccode}
\index{npage@\verb`npage`}


\label{val:Curses.Key.ppage}\begin{ocamldoccode}
val ppage : int
\end{ocamldoccode}
\index{ppage@\verb`ppage`}


\label{val:Curses.Key.stab}\begin{ocamldoccode}
val stab : int
\end{ocamldoccode}
\index{stab@\verb`stab`}


\label{val:Curses.Key.ctab}\begin{ocamldoccode}
val ctab : int
\end{ocamldoccode}
\index{ctab@\verb`ctab`}


\label{val:Curses.Key.catab}\begin{ocamldoccode}
val catab : int
\end{ocamldoccode}
\index{catab@\verb`catab`}


\label{val:Curses.Key.enter}\begin{ocamldoccode}
val enter : int
\end{ocamldoccode}
\index{enter@\verb`enter`}


\label{val:Curses.Key.sreset}\begin{ocamldoccode}
val sreset : int
\end{ocamldoccode}
\index{sreset@\verb`sreset`}


\label{val:Curses.Key.reset}\begin{ocamldoccode}
val reset : int
\end{ocamldoccode}
\index{reset@\verb`reset`}


\label{val:Curses.Key.print}\begin{ocamldoccode}
val print : int
\end{ocamldoccode}
\index{print@\verb`print`}


\label{val:Curses.Key.ll}\begin{ocamldoccode}
val ll : int
\end{ocamldoccode}
\index{ll@\verb`ll`}


\label{val:Curses.Key.a1}\begin{ocamldoccode}
val a1 : int
\end{ocamldoccode}
\index{a1@\verb`a1`}


\label{val:Curses.Key.a3}\begin{ocamldoccode}
val a3 : int
\end{ocamldoccode}
\index{a3@\verb`a3`}


\label{val:Curses.Key.b2}\begin{ocamldoccode}
val b2 : int
\end{ocamldoccode}
\index{b2@\verb`b2`}


\label{val:Curses.Key.c1}\begin{ocamldoccode}
val c1 : int
\end{ocamldoccode}
\index{c1@\verb`c1`}


\label{val:Curses.Key.c3}\begin{ocamldoccode}
val c3 : int
\end{ocamldoccode}
\index{c3@\verb`c3`}


\label{val:Curses.Key.btab}\begin{ocamldoccode}
val btab : int
\end{ocamldoccode}
\index{btab@\verb`btab`}


\label{val:Curses.Key.beg}\begin{ocamldoccode}
val beg : int
\end{ocamldoccode}
\index{beg@\verb`beg`}


\label{val:Curses.Key.cancel}\begin{ocamldoccode}
val cancel : int
\end{ocamldoccode}
\index{cancel@\verb`cancel`}


\label{val:Curses.Key.close}\begin{ocamldoccode}
val close : int
\end{ocamldoccode}
\index{close@\verb`close`}


\label{val:Curses.Key.command}\begin{ocamldoccode}
val command : int
\end{ocamldoccode}
\index{command@\verb`command`}


\label{val:Curses.Key.copy}\begin{ocamldoccode}
val copy : int
\end{ocamldoccode}
\index{copy@\verb`copy`}


\label{val:Curses.Key.create}\begin{ocamldoccode}
val create : int
\end{ocamldoccode}
\index{create@\verb`create`}


\label{val:Curses.Key.end-underscore}\begin{ocamldoccode}
val end_ : int
\end{ocamldoccode}
\index{end-underscore@\verb`end_`}


\label{val:Curses.Key.exit}\begin{ocamldoccode}
val exit : int
\end{ocamldoccode}
\index{exit@\verb`exit`}


\label{val:Curses.Key.find}\begin{ocamldoccode}
val find : int
\end{ocamldoccode}
\index{find@\verb`find`}


\label{val:Curses.Key.help}\begin{ocamldoccode}
val help : int
\end{ocamldoccode}
\index{help@\verb`help`}


\label{val:Curses.Key.mark}\begin{ocamldoccode}
val mark : int
\end{ocamldoccode}
\index{mark@\verb`mark`}


\label{val:Curses.Key.message}\begin{ocamldoccode}
val message : int
\end{ocamldoccode}
\index{message@\verb`message`}


\label{val:Curses.Key.move}\begin{ocamldoccode}
val move : int
\end{ocamldoccode}
\index{move@\verb`move`}


\label{val:Curses.Key.next}\begin{ocamldoccode}
val next : int
\end{ocamldoccode}
\index{next@\verb`next`}


\label{val:Curses.Key.open-underscore}\begin{ocamldoccode}
val open_ : int
\end{ocamldoccode}
\index{open-underscore@\verb`open_`}


\label{val:Curses.Key.options}\begin{ocamldoccode}
val options : int
\end{ocamldoccode}
\index{options@\verb`options`}


\label{val:Curses.Key.previous}\begin{ocamldoccode}
val previous : int
\end{ocamldoccode}
\index{previous@\verb`previous`}


\label{val:Curses.Key.redo}\begin{ocamldoccode}
val redo : int
\end{ocamldoccode}
\index{redo@\verb`redo`}


\label{val:Curses.Key.reference}\begin{ocamldoccode}
val reference : int
\end{ocamldoccode}
\index{reference@\verb`reference`}


\label{val:Curses.Key.refresh}\begin{ocamldoccode}
val refresh : int
\end{ocamldoccode}
\index{refresh@\verb`refresh`}


\label{val:Curses.Key.replace}\begin{ocamldoccode}
val replace : int
\end{ocamldoccode}
\index{replace@\verb`replace`}


\label{val:Curses.Key.restart}\begin{ocamldoccode}
val restart : int
\end{ocamldoccode}
\index{restart@\verb`restart`}


\label{val:Curses.Key.resume}\begin{ocamldoccode}
val resume : int
\end{ocamldoccode}
\index{resume@\verb`resume`}


\label{val:Curses.Key.save}\begin{ocamldoccode}
val save : int
\end{ocamldoccode}
\index{save@\verb`save`}


\label{val:Curses.Key.sbeg}\begin{ocamldoccode}
val sbeg : int
\end{ocamldoccode}
\index{sbeg@\verb`sbeg`}


\label{val:Curses.Key.scancel}\begin{ocamldoccode}
val scancel : int
\end{ocamldoccode}
\index{scancel@\verb`scancel`}


\label{val:Curses.Key.scommand}\begin{ocamldoccode}
val scommand : int
\end{ocamldoccode}
\index{scommand@\verb`scommand`}


\label{val:Curses.Key.scopy}\begin{ocamldoccode}
val scopy : int
\end{ocamldoccode}
\index{scopy@\verb`scopy`}


\label{val:Curses.Key.screate}\begin{ocamldoccode}
val screate : int
\end{ocamldoccode}
\index{screate@\verb`screate`}


\label{val:Curses.Key.sdc}\begin{ocamldoccode}
val sdc : int
\end{ocamldoccode}
\index{sdc@\verb`sdc`}


\label{val:Curses.Key.sdl}\begin{ocamldoccode}
val sdl : int
\end{ocamldoccode}
\index{sdl@\verb`sdl`}


\label{val:Curses.Key.select}\begin{ocamldoccode}
val select : int
\end{ocamldoccode}
\index{select@\verb`select`}


\label{val:Curses.Key.send}\begin{ocamldoccode}
val send : int
\end{ocamldoccode}
\index{send@\verb`send`}


\label{val:Curses.Key.seol}\begin{ocamldoccode}
val seol : int
\end{ocamldoccode}
\index{seol@\verb`seol`}


\label{val:Curses.Key.sexit}\begin{ocamldoccode}
val sexit : int
\end{ocamldoccode}
\index{sexit@\verb`sexit`}


\label{val:Curses.Key.sfind}\begin{ocamldoccode}
val sfind : int
\end{ocamldoccode}
\index{sfind@\verb`sfind`}


\label{val:Curses.Key.shelp}\begin{ocamldoccode}
val shelp : int
\end{ocamldoccode}
\index{shelp@\verb`shelp`}


\label{val:Curses.Key.shome}\begin{ocamldoccode}
val shome : int
\end{ocamldoccode}
\index{shome@\verb`shome`}


\label{val:Curses.Key.sic}\begin{ocamldoccode}
val sic : int
\end{ocamldoccode}
\index{sic@\verb`sic`}


\label{val:Curses.Key.sleft}\begin{ocamldoccode}
val sleft : int
\end{ocamldoccode}
\index{sleft@\verb`sleft`}


\label{val:Curses.Key.smessage}\begin{ocamldoccode}
val smessage : int
\end{ocamldoccode}
\index{smessage@\verb`smessage`}


\label{val:Curses.Key.smove}\begin{ocamldoccode}
val smove : int
\end{ocamldoccode}
\index{smove@\verb`smove`}


\label{val:Curses.Key.snext}\begin{ocamldoccode}
val snext : int
\end{ocamldoccode}
\index{snext@\verb`snext`}


\label{val:Curses.Key.soptions}\begin{ocamldoccode}
val soptions : int
\end{ocamldoccode}
\index{soptions@\verb`soptions`}


\label{val:Curses.Key.sprevious}\begin{ocamldoccode}
val sprevious : int
\end{ocamldoccode}
\index{sprevious@\verb`sprevious`}


\label{val:Curses.Key.sprint}\begin{ocamldoccode}
val sprint : int
\end{ocamldoccode}
\index{sprint@\verb`sprint`}


\label{val:Curses.Key.sredo}\begin{ocamldoccode}
val sredo : int
\end{ocamldoccode}
\index{sredo@\verb`sredo`}


\label{val:Curses.Key.sreplace}\begin{ocamldoccode}
val sreplace : int
\end{ocamldoccode}
\index{sreplace@\verb`sreplace`}


\label{val:Curses.Key.sright}\begin{ocamldoccode}
val sright : int
\end{ocamldoccode}
\index{sright@\verb`sright`}


\label{val:Curses.Key.srsume}\begin{ocamldoccode}
val srsume : int
\end{ocamldoccode}
\index{srsume@\verb`srsume`}


\label{val:Curses.Key.ssave}\begin{ocamldoccode}
val ssave : int
\end{ocamldoccode}
\index{ssave@\verb`ssave`}


\label{val:Curses.Key.ssuspend}\begin{ocamldoccode}
val ssuspend : int
\end{ocamldoccode}
\index{ssuspend@\verb`ssuspend`}


\label{val:Curses.Key.sundo}\begin{ocamldoccode}
val sundo : int
\end{ocamldoccode}
\index{sundo@\verb`sundo`}


\label{val:Curses.Key.suspend}\begin{ocamldoccode}
val suspend : int
\end{ocamldoccode}
\index{suspend@\verb`suspend`}


\label{val:Curses.Key.undo}\begin{ocamldoccode}
val undo : int
\end{ocamldoccode}
\index{undo@\verb`undo`}


\label{val:Curses.Key.mouse}\begin{ocamldoccode}
val mouse : int
\end{ocamldoccode}
\index{mouse@\verb`mouse`}


\label{val:Curses.Key.resize}\begin{ocamldoccode}
val resize : int
\end{ocamldoccode}
\index{resize@\verb`resize`}


\label{val:Curses.Key.max}\begin{ocamldoccode}
val max : int
\end{ocamldoccode}
\index{max@\verb`max`}


\label{val:Curses.Key.f}\begin{ocamldoccode}
val f : int -> int
\end{ocamldoccode}
\index{f@\verb`f`}
\end{ocamldocsigend}


\begin{ocamldocdescription}
Special keys.


\end{ocamldocdescription}




\label{val:Curses.getch}\begin{ocamldoccode}
val getch : unit -> int
\end{ocamldoccode}
\index{getch@\verb`getch`}
\begin{ocamldocdescription}
Read a character in a window.


\end{ocamldocdescription}




\label{val:Curses.wgetch}\begin{ocamldoccode}
val wgetch : window -> int
\end{ocamldoccode}
\index{wgetch@\verb`wgetch`}




\label{val:Curses.mvgetch}\begin{ocamldoccode}
val mvgetch : int -> int -> int
\end{ocamldoccode}
\index{mvgetch@\verb`mvgetch`}




\label{val:Curses.mvwgetch}\begin{ocamldoccode}
val mvwgetch : window -> int -> int -> int
\end{ocamldoccode}
\index{mvwgetch@\verb`mvwgetch`}




\label{val:Curses.ungetch}\begin{ocamldoccode}
val ungetch : int -> err
\end{ocamldoccode}
\index{ungetch@\verb`ungetch`}




\label{val:Curses.getstr}\begin{ocamldoccode}
val getstr : string -> err
\end{ocamldoccode}
\index{getstr@\verb`getstr`}
\begin{ocamldocdescription}
Read a string in a window.


\end{ocamldocdescription}




\label{val:Curses.wgetstr}\begin{ocamldoccode}
val wgetstr : window -> string -> err
\end{ocamldoccode}
\index{wgetstr@\verb`wgetstr`}




\label{val:Curses.mvgetstr}\begin{ocamldoccode}
val mvgetstr : int -> int -> string -> err
\end{ocamldoccode}
\index{mvgetstr@\verb`mvgetstr`}




\label{val:Curses.mvwgetstr}\begin{ocamldoccode}
val mvwgetstr : window -> int -> int -> string -> err
\end{ocamldoccode}
\index{mvwgetstr@\verb`mvwgetstr`}




\label{val:Curses.getnstr}\begin{ocamldoccode}
val getnstr : string -> int -> int -> err
\end{ocamldoccode}
\index{getnstr@\verb`getnstr`}




\label{val:Curses.wgetnstr}\begin{ocamldoccode}
val wgetnstr : window -> string -> int -> int -> err
\end{ocamldoccode}
\index{wgetnstr@\verb`wgetnstr`}




\label{val:Curses.mvgetnstr}\begin{ocamldoccode}
val mvgetnstr : int -> int -> string -> int -> int -> err
\end{ocamldoccode}
\index{mvgetnstr@\verb`mvgetnstr`}




\label{val:Curses.mvwgetnstr}\begin{ocamldoccode}
val mvwgetnstr : window -> int -> int -> string -> int -> int -> err
\end{ocamldoccode}
\index{mvwgetnstr@\verb`mvwgetnstr`}




\subsection{Windows}




\subsubsection{Window manipulations}




\label{val:Curses.newwin}\begin{ocamldoccode}
val newwin : int -> int -> int -> int -> window
\end{ocamldoccode}
\index{newwin@\verb`newwin`}
\begin{ocamldocdescription}
{\tt{newwin l c y x}} create a new window with {\tt{l}} lines, {\tt{c}} columns. The upper
 left-hand corner is at ({\tt{x}},{\tt{y}}).


\end{ocamldocdescription}




\label{val:Curses.delwin}\begin{ocamldoccode}
val delwin : window -> err
\end{ocamldoccode}
\index{delwin@\verb`delwin`}
\begin{ocamldocdescription}
Delete a window.


\end{ocamldocdescription}




\label{val:Curses.mvwin}\begin{ocamldoccode}
val mvwin : window -> int -> int -> err
\end{ocamldoccode}
\index{mvwin@\verb`mvwin`}
\begin{ocamldocdescription}
Move a window.


\end{ocamldocdescription}




\label{val:Curses.subwin}\begin{ocamldoccode}
val subwin : window -> int -> int -> int -> int -> window
\end{ocamldoccode}
\index{subwin@\verb`subwin`}
\begin{ocamldocdescription}
{\tt{subwin l c y x}} create a subwindow with {\tt{l}} lines and {\tt{c}} columns at
 screen-relative position ({\tt{x}},{\tt{y}}).


\end{ocamldocdescription}




\label{val:Curses.derwin}\begin{ocamldoccode}
val derwin : window -> int -> int -> int -> int -> window
\end{ocamldoccode}
\index{derwin@\verb`derwin`}
\begin{ocamldocdescription}
Same as {\tt{subwin}} excepting that the position ({\tt{x}},{\tt{y}}) is relative to the
 parent window.


\end{ocamldocdescription}




\label{val:Curses.mvderwin}\begin{ocamldoccode}
val mvderwin : window -> int -> int -> err
\end{ocamldoccode}
\index{mvderwin@\verb`mvderwin`}
\begin{ocamldocdescription}
Move a derived windw.


\end{ocamldocdescription}




\label{val:Curses.dupwin}\begin{ocamldoccode}
val dupwin : window -> window
\end{ocamldoccode}
\index{dupwin@\verb`dupwin`}
\begin{ocamldocdescription}
Duplicate a window.


\end{ocamldocdescription}




\label{val:Curses.wsyncup}\begin{ocamldoccode}
val wsyncup : window -> unit
\end{ocamldoccode}
\index{wsyncup@\verb`wsyncup`}




\label{val:Curses.syncok}\begin{ocamldoccode}
val syncok : window -> bool -> err
\end{ocamldoccode}
\index{syncok@\verb`syncok`}
\begin{ocamldocdescription}
If {\tt{syncok}} is called with {\tt{true}} as second argument, {\tt{wsyncup}} is called
 automatically whenever there is a change in the window.


\end{ocamldocdescription}




\label{val:Curses.wcursyncup}\begin{ocamldoccode}
val wcursyncup : window -> unit
\end{ocamldoccode}
\index{wcursyncup@\verb`wcursyncup`}




\label{val:Curses.wsyncdown}\begin{ocamldoccode}
val wsyncdown : window -> unit
\end{ocamldoccode}
\index{wsyncdown@\verb`wsyncdown`}




\label{val:Curses.winch-underscorehandler-underscoreon}\begin{ocamldoccode}
val winch_handler_on : unit -> unit
\end{ocamldoccode}
\index{winch-underscorehandler-underscoreon@\verb`winch_handler_on`}




\label{val:Curses.winch-underscorehandler-underscoreoff}\begin{ocamldoccode}
val winch_handler_off : unit -> unit
\end{ocamldoccode}
\index{winch-underscorehandler-underscoreoff@\verb`winch_handler_off`}




\label{val:Curses.get-underscoresize}\begin{ocamldoccode}
val get_size : unit -> int * int
\end{ocamldoccode}
\index{get-underscoresize@\verb`get_size`}




\label{val:Curses.get-underscoresize-underscorefd}\begin{ocamldoccode}
val get_size_fd : Unix.file_descr -> int * int
\end{ocamldoccode}
\index{get-underscoresize-underscorefd@\verb`get_size_fd`}




\label{val:Curses.null-underscorewindow}\begin{ocamldoccode}
val null_window : window
\end{ocamldoccode}
\index{null-underscorewindow@\verb`null_window`}




\subsubsection{Refresh control}




\label{val:Curses.refresh}\begin{ocamldoccode}
val refresh : unit -> err
\end{ocamldoccode}
\index{refresh@\verb`refresh`}
\begin{ocamldocdescription}
Refresh windows.


\end{ocamldocdescription}




\label{val:Curses.wrefresh}\begin{ocamldoccode}
val wrefresh : window -> err
\end{ocamldoccode}
\index{wrefresh@\verb`wrefresh`}




\label{val:Curses.wnoutrefresh}\begin{ocamldoccode}
val wnoutrefresh : window -> err
\end{ocamldoccode}
\index{wnoutrefresh@\verb`wnoutrefresh`}




\label{val:Curses.doupdate}\begin{ocamldoccode}
val doupdate : unit -> err
\end{ocamldoccode}
\index{doupdate@\verb`doupdate`}




\label{val:Curses.redrawwin}\begin{ocamldoccode}
val redrawwin : window -> err
\end{ocamldoccode}
\index{redrawwin@\verb`redrawwin`}




\label{val:Curses.wredrawln}\begin{ocamldoccode}
val wredrawln : window -> int -> int -> err
\end{ocamldoccode}
\index{wredrawln@\verb`wredrawln`}




\label{val:Curses.wresize}\begin{ocamldoccode}
val wresize : window -> int -> int -> err
\end{ocamldoccode}
\index{wresize@\verb`wresize`}




\label{val:Curses.resizeterm}\begin{ocamldoccode}
val resizeterm : int -> int -> err
\end{ocamldoccode}
\index{resizeterm@\verb`resizeterm`}




\label{val:Curses.scroll}\begin{ocamldoccode}
val scroll : window -> err
\end{ocamldoccode}
\index{scroll@\verb`scroll`}




\label{val:Curses.scrl}\begin{ocamldoccode}
val scrl : int -> err
\end{ocamldoccode}
\index{scrl@\verb`scrl`}




\label{val:Curses.wscrl}\begin{ocamldoccode}
val wscrl : window -> int -> err
\end{ocamldoccode}
\index{wscrl@\verb`wscrl`}




\label{val:Curses.touchwin}\begin{ocamldoccode}
val touchwin : window -> err
\end{ocamldoccode}
\index{touchwin@\verb`touchwin`}




\label{val:Curses.touchline}\begin{ocamldoccode}
val touchline : window -> int -> int -> err
\end{ocamldoccode}
\index{touchline@\verb`touchline`}




\label{val:Curses.untouchwin}\begin{ocamldoccode}
val untouchwin : window -> err
\end{ocamldoccode}
\index{untouchwin@\verb`untouchwin`}




\label{val:Curses.wtouchln}\begin{ocamldoccode}
val wtouchln : window -> int -> int -> bool -> err
\end{ocamldoccode}
\index{wtouchln@\verb`wtouchln`}




\label{val:Curses.is-underscorelinetouched}\begin{ocamldoccode}
val is_linetouched : window -> int -> int
\end{ocamldoccode}
\index{is-underscorelinetouched@\verb`is_linetouched`}




\label{val:Curses.is-underscorewintouched}\begin{ocamldoccode}
val is_wintouched : window -> bool
\end{ocamldoccode}
\index{is-underscorewintouched@\verb`is_wintouched`}




\label{val:Curses.erase}\begin{ocamldoccode}
val erase : unit -> unit
\end{ocamldoccode}
\index{erase@\verb`erase`}
\begin{ocamldocdescription}
Clear a window.


\end{ocamldocdescription}




\label{val:Curses.werase}\begin{ocamldoccode}
val werase : window -> unit
\end{ocamldoccode}
\index{werase@\verb`werase`}




\label{val:Curses.clear}\begin{ocamldoccode}
val clear : unit -> unit
\end{ocamldoccode}
\index{clear@\verb`clear`}




\label{val:Curses.wclear}\begin{ocamldoccode}
val wclear : window -> unit
\end{ocamldoccode}
\index{wclear@\verb`wclear`}




\label{val:Curses.clrtobot}\begin{ocamldoccode}
val clrtobot : unit -> unit
\end{ocamldoccode}
\index{clrtobot@\verb`clrtobot`}




\label{val:Curses.wclrtobot}\begin{ocamldoccode}
val wclrtobot : window -> unit
\end{ocamldoccode}
\index{wclrtobot@\verb`wclrtobot`}




\label{val:Curses.clrtoeol}\begin{ocamldoccode}
val clrtoeol : unit -> unit
\end{ocamldoccode}
\index{clrtoeol@\verb`clrtoeol`}




\label{val:Curses.wclrtoeol}\begin{ocamldoccode}
val wclrtoeol : window -> unit
\end{ocamldoccode}
\index{wclrtoeol@\verb`wclrtoeol`}




\subsubsection{Overlapped windows}




\label{val:Curses.overlay}\begin{ocamldoccode}
val overlay : window -> window -> err
\end{ocamldoccode}
\index{overlay@\verb`overlay`}
\begin{ocamldocdescription}
{\tt{overlay srcwin dstwin}} overlays {\tt{srcwin}} on top of {\tt{dstwin}}.


\end{ocamldocdescription}




\label{val:Curses.overwrite}\begin{ocamldoccode}
val overwrite : window -> window -> err
\end{ocamldoccode}
\index{overwrite@\verb`overwrite`}




\label{val:Curses.copywin}\begin{ocamldoccode}
val copywin :
  window ->
  window -> int -> int -> int -> int -> int -> int -> bool -> err
\end{ocamldoccode}
\index{copywin@\verb`copywin`}




\subsubsection{Decorations}




\label{val:Curses.border}\begin{ocamldoccode}
val border :
  chtype ->
  chtype ->
  chtype ->
  chtype ->
  chtype -> chtype -> chtype -> chtype -> unit
\end{ocamldoccode}
\index{border@\verb`border`}
\begin{ocamldocdescription}
Draw a box around the edges of a window.


\end{ocamldocdescription}




\label{val:Curses.wborder}\begin{ocamldoccode}
val wborder :
  window ->
  chtype ->
  chtype ->
  chtype ->
  chtype ->
  chtype -> chtype -> chtype -> chtype -> unit
\end{ocamldoccode}
\index{wborder@\verb`wborder`}




\label{val:Curses.box}\begin{ocamldoccode}
val box : window -> chtype -> chtype -> unit
\end{ocamldoccode}
\index{box@\verb`box`}
\begin{ocamldocdescription}
Draw a box.


\end{ocamldocdescription}




\label{val:Curses.hline}\begin{ocamldoccode}
val hline : chtype -> int -> unit
\end{ocamldoccode}
\index{hline@\verb`hline`}
\begin{ocamldocdescription}
Draw an horizontal line.


\end{ocamldocdescription}




\label{val:Curses.whline}\begin{ocamldoccode}
val whline : window -> chtype -> int -> unit
\end{ocamldoccode}
\index{whline@\verb`whline`}




\label{val:Curses.mvhline}\begin{ocamldoccode}
val mvhline : int -> int -> chtype -> int -> unit
\end{ocamldoccode}
\index{mvhline@\verb`mvhline`}




\label{val:Curses.mvwhline}\begin{ocamldoccode}
val mvwhline : window -> int -> int -> chtype -> int -> unit
\end{ocamldoccode}
\index{mvwhline@\verb`mvwhline`}




\label{val:Curses.vline}\begin{ocamldoccode}
val vline : chtype -> int -> unit
\end{ocamldoccode}
\index{vline@\verb`vline`}
\begin{ocamldocdescription}
Draw a vertical line.


\end{ocamldocdescription}




\label{val:Curses.wvline}\begin{ocamldoccode}
val wvline : window -> chtype -> int -> unit
\end{ocamldoccode}
\index{wvline@\verb`wvline`}




\label{val:Curses.mvvline}\begin{ocamldoccode}
val mvvline : int -> int -> chtype -> int -> unit
\end{ocamldoccode}
\index{mvvline@\verb`mvvline`}




\label{val:Curses.mvwvline}\begin{ocamldoccode}
val mvwvline : window -> int -> int -> chtype -> int -> unit
\end{ocamldoccode}
\index{mvwvline@\verb`mvwvline`}




\subsubsection{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.



\label{val:Curses.newpad}\begin{ocamldoccode}
val newpad : int -> int -> window
\end{ocamldoccode}
\index{newpad@\verb`newpad`}
\begin{ocamldocdescription}
Create a new pad.


\end{ocamldocdescription}




\label{val:Curses.subpad}\begin{ocamldoccode}
val subpad : window -> int -> int -> int -> int -> window
\end{ocamldoccode}
\index{subpad@\verb`subpad`}




\label{val:Curses.prefresh}\begin{ocamldoccode}
val prefresh : window -> int -> int -> int -> int -> int -> int -> err
\end{ocamldoccode}
\index{prefresh@\verb`prefresh`}




\label{val:Curses.pnoutrefresh}\begin{ocamldoccode}
val pnoutrefresh : window -> int -> int -> int -> int -> int -> int -> err
\end{ocamldoccode}
\index{pnoutrefresh@\verb`pnoutrefresh`}




\label{val:Curses.pechochar}\begin{ocamldoccode}
val pechochar : window -> chtype -> err
\end{ocamldoccode}
\index{pechochar@\verb`pechochar`}




\subsection{Colors}




\begin{ocamldoccode}
{\tt{module }}{\tt{Color}}{\tt{ : }}\end{ocamldoccode}
\label{module:Curses.Color}\index{Color@\verb`Color`}

\begin{ocamldocsigend}


\label{val:Curses.Color.black}\begin{ocamldoccode}
val black : int
\end{ocamldoccode}
\index{black@\verb`black`}


\label{val:Curses.Color.red}\begin{ocamldoccode}
val red : int
\end{ocamldoccode}
\index{red@\verb`red`}


\label{val:Curses.Color.green}\begin{ocamldoccode}
val green : int
\end{ocamldoccode}
\index{green@\verb`green`}


\label{val:Curses.Color.yellow}\begin{ocamldoccode}
val yellow : int
\end{ocamldoccode}
\index{yellow@\verb`yellow`}


\label{val:Curses.Color.blue}\begin{ocamldoccode}
val blue : int
\end{ocamldoccode}
\index{blue@\verb`blue`}


\label{val:Curses.Color.magenta}\begin{ocamldoccode}
val magenta : int
\end{ocamldoccode}
\index{magenta@\verb`magenta`}


\label{val:Curses.Color.cyan}\begin{ocamldoccode}
val cyan : int
\end{ocamldoccode}
\index{cyan@\verb`cyan`}


\label{val:Curses.Color.white}\begin{ocamldoccode}
val white : int
\end{ocamldoccode}
\index{white@\verb`white`}
\end{ocamldocsigend}


\begin{ocamldocdescription}
Colors.


\end{ocamldocdescription}




\label{val:Curses.start-underscorecolor}\begin{ocamldoccode}
val start_color : unit -> err
\end{ocamldoccode}
\index{start-underscorecolor@\verb`start_color`}




\label{val:Curses.use-underscoredefault-underscorecolors}\begin{ocamldoccode}
val use_default_colors : unit -> err
\end{ocamldoccode}
\index{use-underscoredefault-underscorecolors@\verb`use_default_colors`}




\label{val:Curses.init-underscorepair}\begin{ocamldoccode}
val init_pair : int -> int -> int -> err
\end{ocamldoccode}
\index{init-underscorepair@\verb`init_pair`}




\label{val:Curses.init-underscorecolor}\begin{ocamldoccode}
val init_color : int -> int -> int -> int -> err
\end{ocamldoccode}
\index{init-underscorecolor@\verb`init_color`}




\label{val:Curses.has-underscorecolors}\begin{ocamldoccode}
val has_colors : unit -> bool
\end{ocamldoccode}
\index{has-underscorecolors@\verb`has_colors`}




\label{val:Curses.can-underscorechange-underscorecolor}\begin{ocamldoccode}
val can_change_color : unit -> bool
\end{ocamldoccode}
\index{can-underscorechange-underscorecolor@\verb`can_change_color`}




\label{val:Curses.color-underscorecontent}\begin{ocamldoccode}
val color_content : int -> int * int * int
\end{ocamldoccode}
\index{color-underscorecontent@\verb`color_content`}




\label{val:Curses.pair-underscorecontent}\begin{ocamldoccode}
val pair_content : int -> int * int
\end{ocamldoccode}
\index{pair-underscorecontent@\verb`pair_content`}




\label{val:Curses.colors}\begin{ocamldoccode}
val colors : unit -> int
\end{ocamldoccode}
\index{colors@\verb`colors`}




\label{val:Curses.color-underscorepairs}\begin{ocamldoccode}
val color_pairs : unit -> int
\end{ocamldoccode}
\index{color-underscorepairs@\verb`color_pairs`}




\subsection{Input/output options}




\subsubsection{Input options}




\label{val:Curses.cbreak}\begin{ocamldoccode}
val cbreak : unit -> err
\end{ocamldoccode}
\index{cbreak@\verb`cbreak`}
\begin{ocamldocdescription}
Disable line buffering.


\end{ocamldocdescription}




\label{val:Curses.halfdelay}\begin{ocamldoccode}
val halfdelay : int -> err
\end{ocamldoccode}
\index{halfdelay@\verb`halfdelay`}
\begin{ocamldocdescription}
Similar to {\tt{cbreak}} but with delay.


\end{ocamldocdescription}




\label{val:Curses.nocbreak}\begin{ocamldoccode}
val nocbreak : unit -> err
\end{ocamldoccode}
\index{nocbreak@\verb`nocbreak`}
\begin{ocamldocdescription}
Enable line buffering (waits for characters until newline is typed).


\end{ocamldocdescription}




\label{val:Curses.echo}\begin{ocamldoccode}
val echo : unit -> err
\end{ocamldoccode}
\index{echo@\verb`echo`}
\begin{ocamldocdescription}
Don't echo typed characters.


\end{ocamldocdescription}




\label{val:Curses.noecho}\begin{ocamldoccode}
val noecho : unit -> err
\end{ocamldoccode}
\index{noecho@\verb`noecho`}
\begin{ocamldocdescription}
Echo typed characters.


\end{ocamldocdescription}




\label{val:Curses.intrflush}\begin{ocamldoccode}
val intrflush : window -> bool -> err
\end{ocamldoccode}
\index{intrflush@\verb`intrflush`}




\label{val:Curses.keypad}\begin{ocamldoccode}
val keypad : window -> bool -> err
\end{ocamldoccode}
\index{keypad@\verb`keypad`}




\label{val:Curses.meta}\begin{ocamldoccode}
val meta : window -> bool -> err
\end{ocamldoccode}
\index{meta@\verb`meta`}




\label{val:Curses.nodelay}\begin{ocamldoccode}
val nodelay : window -> bool -> err
\end{ocamldoccode}
\index{nodelay@\verb`nodelay`}




\label{val:Curses.raw}\begin{ocamldoccode}
val raw : unit -> err
\end{ocamldoccode}
\index{raw@\verb`raw`}




\label{val:Curses.noraw}\begin{ocamldoccode}
val noraw : unit -> err
\end{ocamldoccode}
\index{noraw@\verb`noraw`}




\label{val:Curses.noqiflush}\begin{ocamldoccode}
val noqiflush : unit -> unit
\end{ocamldoccode}
\index{noqiflush@\verb`noqiflush`}




\label{val:Curses.qiflush}\begin{ocamldoccode}
val qiflush : unit -> unit
\end{ocamldoccode}
\index{qiflush@\verb`qiflush`}




\label{val:Curses.notimeout}\begin{ocamldoccode}
val notimeout : window -> bool -> err
\end{ocamldoccode}
\index{notimeout@\verb`notimeout`}




\label{val:Curses.timeout}\begin{ocamldoccode}
val timeout : int -> unit
\end{ocamldoccode}
\index{timeout@\verb`timeout`}




\label{val:Curses.wtimeout}\begin{ocamldoccode}
val wtimeout : window -> int -> unit
\end{ocamldoccode}
\index{wtimeout@\verb`wtimeout`}




\label{val:Curses.typeahead}\begin{ocamldoccode}
val typeahead : Unix.file_descr -> err
\end{ocamldoccode}
\index{typeahead@\verb`typeahead`}




\label{val:Curses.notypeahead}\begin{ocamldoccode}
val notypeahead : unit -> err
\end{ocamldoccode}
\index{notypeahead@\verb`notypeahead`}




\subsubsection{Output options}




\label{val:Curses.clearok}\begin{ocamldoccode}
val clearok : window -> bool -> unit
\end{ocamldoccode}
\index{clearok@\verb`clearok`}
\begin{ocamldocdescription}
If called with {\tt{true}} as second argument, the next call to {\tt{wrefresh}} with
 this window will clear the streen completely and redraw the entire screen
 from scratch.


\end{ocamldocdescription}




\label{val:Curses.idlok}\begin{ocamldoccode}
val idlok : window -> bool -> unit
\end{ocamldoccode}
\index{idlok@\verb`idlok`}




\label{val:Curses.idcok}\begin{ocamldoccode}
val idcok : window -> bool -> unit
\end{ocamldoccode}
\index{idcok@\verb`idcok`}




\label{val:Curses.immedok}\begin{ocamldoccode}
val immedok : window -> bool -> unit
\end{ocamldoccode}
\index{immedok@\verb`immedok`}




\label{val:Curses.leaveok}\begin{ocamldoccode}
val leaveok : window -> bool -> unit
\end{ocamldoccode}
\index{leaveok@\verb`leaveok`}




\label{val:Curses.setscrreg}\begin{ocamldoccode}
val setscrreg : int -> int -> err
\end{ocamldoccode}
\index{setscrreg@\verb`setscrreg`}




\label{val:Curses.wsetscrreg}\begin{ocamldoccode}
val wsetscrreg : window -> int -> int -> err
\end{ocamldoccode}
\index{wsetscrreg@\verb`wsetscrreg`}




\label{val:Curses.scrollok}\begin{ocamldoccode}
val scrollok : window -> bool -> unit
\end{ocamldoccode}
\index{scrollok@\verb`scrollok`}




\label{val:Curses.nl}\begin{ocamldoccode}
val nl : unit -> unit
\end{ocamldoccode}
\index{nl@\verb`nl`}




\label{val:Curses.nonl}\begin{ocamldoccode}
val nonl : unit -> unit
\end{ocamldoccode}
\index{nonl@\verb`nonl`}




\subsection{Soft-label keys}




\label{val:Curses.slk-underscoreinit}\begin{ocamldoccode}
val slk_init : int -> err
\end{ocamldoccode}
\index{slk-underscoreinit@\verb`slk_init`}
\begin{ocamldocdescription}
Initialize soft labels.


\end{ocamldocdescription}




\label{val:Curses.slk-underscoreset}\begin{ocamldoccode}
val slk_set : int -> string -> int -> err
\end{ocamldoccode}
\index{slk-underscoreset@\verb`slk_set`}




\label{val:Curses.slk-underscorerefresh}\begin{ocamldoccode}
val slk_refresh : unit -> err
\end{ocamldoccode}
\index{slk-underscorerefresh@\verb`slk_refresh`}




\label{val:Curses.slk-underscorenoutrefresh}\begin{ocamldoccode}
val slk_noutrefresh : unit -> err
\end{ocamldoccode}
\index{slk-underscorenoutrefresh@\verb`slk_noutrefresh`}




\label{val:Curses.slk-underscorelabel}\begin{ocamldoccode}
val slk_label : int -> string
\end{ocamldoccode}
\index{slk-underscorelabel@\verb`slk_label`}




\label{val:Curses.slk-underscoreclear}\begin{ocamldoccode}
val slk_clear : unit -> err
\end{ocamldoccode}
\index{slk-underscoreclear@\verb`slk_clear`}




\label{val:Curses.slk-underscorerestore}\begin{ocamldoccode}
val slk_restore : unit -> err
\end{ocamldoccode}
\index{slk-underscorerestore@\verb`slk_restore`}




\label{val:Curses.slk-underscoretouch}\begin{ocamldoccode}
val slk_touch : unit -> err
\end{ocamldoccode}
\index{slk-underscoretouch@\verb`slk_touch`}




\label{val:Curses.slk-underscoreattron}\begin{ocamldoccode}
val slk_attron : attr_t -> err
\end{ocamldoccode}
\index{slk-underscoreattron@\verb`slk_attron`}




\label{val:Curses.slk-underscoreattroff}\begin{ocamldoccode}
val slk_attroff : attr_t -> err
\end{ocamldoccode}
\index{slk-underscoreattroff@\verb`slk_attroff`}




\label{val:Curses.slk-underscoreattrset}\begin{ocamldoccode}
val slk_attrset : attr_t -> err
\end{ocamldoccode}
\index{slk-underscoreattrset@\verb`slk_attrset`}




\subsection{Mouse}




\label{val:Curses.mousemask}\begin{ocamldoccode}
val mousemask : int -> int * int
\end{ocamldoccode}
\index{mousemask@\verb`mousemask`}
\begin{ocamldocdescription}
Sets the mouse mask.


\end{ocamldocdescription}




\subsection{Misc}




\label{val:Curses.beep}\begin{ocamldoccode}
val beep : unit -> err
\end{ocamldoccode}
\index{beep@\verb`beep`}
\begin{ocamldocdescription}
Ring a bell.


\end{ocamldocdescription}




\label{val:Curses.flash}\begin{ocamldoccode}
val flash : unit -> err
\end{ocamldoccode}
\index{flash@\verb`flash`}
\begin{ocamldocdescription}
Flash the screen.


\end{ocamldocdescription}




\label{val:Curses.unctrl}\begin{ocamldoccode}
val unctrl : chtype -> string
\end{ocamldoccode}
\index{unctrl@\verb`unctrl`}




\label{val:Curses.keyname}\begin{ocamldoccode}
val keyname : int -> string
\end{ocamldoccode}
\index{keyname@\verb`keyname`}




\label{val:Curses.filter}\begin{ocamldoccode}
val filter : unit -> unit
\end{ocamldoccode}
\index{filter@\verb`filter`}




\label{val:Curses.use-underscoreenv}\begin{ocamldoccode}
val use_env : bool -> unit
\end{ocamldoccode}
\index{use-underscoreenv@\verb`use_env`}




\label{val:Curses.putwin}\begin{ocamldoccode}
val putwin : window -> Unix.file_descr -> err
\end{ocamldoccode}
\index{putwin@\verb`putwin`}




\label{val:Curses.getwin}\begin{ocamldoccode}
val getwin : Unix.file_descr -> window
\end{ocamldoccode}
\index{getwin@\verb`getwin`}




\label{val:Curses.delay-underscoreoutput}\begin{ocamldoccode}
val delay_output : int -> err
\end{ocamldoccode}
\index{delay-underscoreoutput@\verb`delay_output`}




\label{val:Curses.flushinp}\begin{ocamldoccode}
val flushinp : unit -> unit
\end{ocamldoccode}
\index{flushinp@\verb`flushinp`}




\subsection{Screen manipulation}




\label{val:Curses.scr-underscoredump}\begin{ocamldoccode}
val scr_dump : string -> err
\end{ocamldoccode}
\index{scr-underscoredump@\verb`scr_dump`}
\begin{ocamldocdescription}
Dump the current screen to a file.


\end{ocamldocdescription}




\label{val:Curses.scr-underscorerestore}\begin{ocamldoccode}
val scr_restore : string -> err
\end{ocamldoccode}
\index{scr-underscorerestore@\verb`scr_restore`}




\label{val:Curses.scr-underscoreinit}\begin{ocamldoccode}
val scr_init : string -> err
\end{ocamldoccode}
\index{scr-underscoreinit@\verb`scr_init`}




\label{val:Curses.scr-underscoreset}\begin{ocamldoccode}
val scr_set : string -> err
\end{ocamldoccode}
\index{scr-underscoreset@\verb`scr_set`}




\subsection{Terminal}




\label{val:Curses.baudrate}\begin{ocamldoccode}
val baudrate : unit -> int
\end{ocamldoccode}
\index{baudrate@\verb`baudrate`}
\begin{ocamldocdescription}
Get the speed of a terminal (in bits per second).


\end{ocamldocdescription}




\label{val:Curses.erasechar}\begin{ocamldoccode}
val erasechar : unit -> char
\end{ocamldoccode}
\index{erasechar@\verb`erasechar`}
\begin{ocamldocdescription}
Get user's current erase character.


\end{ocamldocdescription}




\label{val:Curses.has-underscoreic}\begin{ocamldoccode}
val has_ic : unit -> bool
\end{ocamldoccode}
\index{has-underscoreic@\verb`has_ic`}
\begin{ocamldocdescription}
Has the terminal insert- and delete-character capabilites?


\end{ocamldocdescription}




\label{val:Curses.has-underscoreil}\begin{ocamldoccode}
val has_il : unit -> bool
\end{ocamldoccode}
\index{has-underscoreil@\verb`has_il`}
\begin{ocamldocdescription}
Has the terminal insert- and delete-line capabilites?


\end{ocamldocdescription}




\label{val:Curses.killchar}\begin{ocamldoccode}
val killchar : unit -> char
\end{ocamldoccode}
\index{killchar@\verb`killchar`}
\begin{ocamldocdescription}
Get user's current line kill character.


\end{ocamldocdescription}




\label{val:Curses.longname}\begin{ocamldoccode}
val longname : unit -> string
\end{ocamldoccode}
\index{longname@\verb`longname`}
\begin{ocamldocdescription}
Get a description of the terminal.


\end{ocamldocdescription}




\label{val:Curses.termattrs}\begin{ocamldoccode}
val termattrs : unit -> attr_t
\end{ocamldoccode}
\index{termattrs@\verb`termattrs`}




\label{val:Curses.termname}\begin{ocamldoccode}
val termname : unit -> string
\end{ocamldoccode}
\index{termname@\verb`termname`}




\label{val:Curses.tgetent}\begin{ocamldoccode}
val tgetent : string -> bool
\end{ocamldoccode}
\index{tgetent@\verb`tgetent`}




\label{val:Curses.tgetflag}\begin{ocamldoccode}
val tgetflag : string -> bool
\end{ocamldoccode}
\index{tgetflag@\verb`tgetflag`}




\label{val:Curses.tgetnum}\begin{ocamldoccode}
val tgetnum : string -> int
\end{ocamldoccode}
\index{tgetnum@\verb`tgetnum`}




\label{val:Curses.tgetstr}\begin{ocamldoccode}
val tgetstr : string -> bool
\end{ocamldoccode}
\index{tgetstr@\verb`tgetstr`}




\label{val:Curses.tgoto}\begin{ocamldoccode}
val tgoto : string -> int -> int -> string
\end{ocamldoccode}
\index{tgoto@\verb`tgoto`}




\label{val:Curses.setupterm}\begin{ocamldoccode}
val setupterm : string -> Unix.file_descr -> err
\end{ocamldoccode}
\index{setupterm@\verb`setupterm`}




\label{val:Curses.setterm}\begin{ocamldoccode}
val setterm : string -> err
\end{ocamldoccode}
\index{setterm@\verb`setterm`}




\label{val:Curses.cur-underscoreterm}\begin{ocamldoccode}
val cur_term : unit -> terminal
\end{ocamldoccode}
\index{cur-underscoreterm@\verb`cur_term`}




\label{val:Curses.set-underscorecurterm}\begin{ocamldoccode}
val set_curterm : terminal -> terminal
\end{ocamldoccode}
\index{set-underscorecurterm@\verb`set_curterm`}




\label{val:Curses.del-underscorecurterm}\begin{ocamldoccode}
val del_curterm : terminal -> err
\end{ocamldoccode}
\index{del-underscorecurterm@\verb`del_curterm`}




\label{val:Curses.restartterm}\begin{ocamldoccode}
val restartterm : string -> Unix.file_descr -> err
\end{ocamldoccode}
\index{restartterm@\verb`restartterm`}




\label{val:Curses.putp}\begin{ocamldoccode}
val putp : string -> err
\end{ocamldoccode}
\index{putp@\verb`putp`}




\label{val:Curses.vidattr}\begin{ocamldoccode}
val vidattr : chtype -> err
\end{ocamldoccode}
\index{vidattr@\verb`vidattr`}




\label{val:Curses.mvcur}\begin{ocamldoccode}
val mvcur : int -> int -> int -> int -> err
\end{ocamldoccode}
\index{mvcur@\verb`mvcur`}




\label{val:Curses.tigetflag}\begin{ocamldoccode}
val tigetflag : string -> bool
\end{ocamldoccode}
\index{tigetflag@\verb`tigetflag`}




\label{val:Curses.tigetnum}\begin{ocamldoccode}
val tigetnum : string -> int
\end{ocamldoccode}
\index{tigetnum@\verb`tigetnum`}




\label{val:Curses.tigetstr}\begin{ocamldoccode}
val tigetstr : string -> string
\end{ocamldoccode}
\index{tigetstr@\verb`tigetstr`}




\label{val:Curses.tputs}\begin{ocamldoccode}
val tputs : string -> int -> (char -> unit) -> err
\end{ocamldoccode}
\index{tputs@\verb`tputs`}




\label{val:Curses.vidputs}\begin{ocamldoccode}
val vidputs : chtype -> (char -> unit) -> err
\end{ocamldoccode}
\index{vidputs@\verb`vidputs`}




\label{val:Curses.tparm}\begin{ocamldoccode}
val tparm : string -> int array -> string
\end{ocamldoccode}
\index{tparm@\verb`tparm`}




\label{val:Curses.bool-underscoreterminfo-underscorevariable}\begin{ocamldoccode}
val bool_terminfo_variable : int -> string * string * string
\end{ocamldoccode}
\index{bool-underscoreterminfo-underscorevariable@\verb`bool_terminfo_variable`}




\label{val:Curses.num-underscoreterminfo-underscorevariable}\begin{ocamldoccode}
val num_terminfo_variable : int -> string * string * string
\end{ocamldoccode}
\index{num-underscoreterminfo-underscorevariable@\verb`num_terminfo_variable`}




\label{val:Curses.str-underscoreterminfo-underscorevariable}\begin{ocamldoccode}
val str_terminfo_variable : int -> string * string * string
\end{ocamldoccode}
\index{str-underscoreterminfo-underscorevariable@\verb`str_terminfo_variable`}




\label{val:Curses.bool-underscoreterminfo-underscorevariables}\begin{ocamldoccode}
val bool_terminfo_variables : (string, string * string) Hashtbl.t
\end{ocamldoccode}
\index{bool-underscoreterminfo-underscorevariables@\verb`bool_terminfo_variables`}




\label{val:Curses.num-underscoreterminfo-underscorevariables}\begin{ocamldoccode}
val num_terminfo_variables : (string, string * string) Hashtbl.t
\end{ocamldoccode}
\index{num-underscoreterminfo-underscorevariables@\verb`num_terminfo_variables`}




\label{val:Curses.str-underscoreterminfo-underscorevariables}\begin{ocamldoccode}
val str_terminfo_variables : (string, string * string) Hashtbl.t
\end{ocamldoccode}
\index{str-underscoreterminfo-underscorevariables@\verb`str_terminfo_variables`}




\subsection{Low-level curses routines}




\label{val:Curses.def-underscoreprog-underscoremode}\begin{ocamldoccode}
val def_prog_mode : unit -> unit
\end{ocamldoccode}
\index{def-underscoreprog-underscoremode@\verb`def_prog_mode`}
\begin{ocamldocdescription}
Save the current terminal modes as the "program" state for use by the
 {\tt{reser\_prog\_mod}} and {\tt{reset\_shell\_mode}} functions.


\end{ocamldocdescription}




\label{val:Curses.def-underscoreshell-underscoremode}\begin{ocamldoccode}
val def_shell_mode : unit -> unit
\end{ocamldoccode}
\index{def-underscoreshell-underscoremode@\verb`def_shell_mode`}




\label{val:Curses.reset-underscoreprog-underscoremode}\begin{ocamldoccode}
val reset_prog_mode : unit -> unit
\end{ocamldoccode}
\index{reset-underscoreprog-underscoremode@\verb`reset_prog_mode`}




\label{val:Curses.reset-underscoreshell-underscoremode}\begin{ocamldoccode}
val reset_shell_mode : unit -> unit
\end{ocamldoccode}
\index{reset-underscoreshell-underscoremode@\verb`reset_shell_mode`}




\label{val:Curses.resetty}\begin{ocamldoccode}
val resetty : unit -> unit
\end{ocamldoccode}
\index{resetty@\verb`resetty`}




\label{val:Curses.savetty}\begin{ocamldoccode}
val savetty : unit -> unit
\end{ocamldoccode}
\index{savetty@\verb`savetty`}




\label{val:Curses.getsyx}\begin{ocamldoccode}
val getsyx : unit -> int * int
\end{ocamldoccode}
\index{getsyx@\verb`getsyx`}




\label{val:Curses.setsyx}\begin{ocamldoccode}
val setsyx : int -> int -> unit
\end{ocamldoccode}
\index{setsyx@\verb`setsyx`}




\label{val:Curses.curs-underscoreset}\begin{ocamldoccode}
val curs_set : int -> err
\end{ocamldoccode}
\index{curs-underscoreset@\verb`curs_set`}




\label{val:Curses.napms}\begin{ocamldoccode}
val napms : int -> unit
\end{ocamldoccode}
\index{napms@\verb`napms`}




\label{val:Curses.ripoffline}\begin{ocamldoccode}
val ripoffline : bool -> unit
\end{ocamldoccode}
\index{ripoffline@\verb`ripoffline`}




\label{val:Curses.get-underscoreripoff}\begin{ocamldoccode}
val get_ripoff : unit -> window * int
\end{ocamldoccode}
\index{get-underscoreripoff@\verb`get_ripoff`}




\subsection{Configuration}




\begin{ocamldoccode}
{\tt{module }}{\tt{Curses\_config}}{\tt{ : }}\end{ocamldoccode}
\label{module:Curses.Curses-underscoreconfig}\index{Curses-underscoreconfig@\verb`Curses_config`}

\begin{ocamldocsigend}


\label{val:Curses.Curses-underscoreconfig.wide-underscorencurses}\begin{ocamldoccode}
val wide_ncurses : bool
\end{ocamldoccode}
\index{wide-underscorencurses@\verb`wide_ncurses`}
\begin{ocamldocdescription}
If {\tt{Curses}} has been linked against a curses library with wide
 character support, then {\tt{wide\_ncurses}} is {\tt{true}}.


\end{ocamldocdescription}
\end{ocamldocsigend}




\end{document}