Module LTerm_draw

module LTerm_draw: sig .. end

Drawing

type point = {

`mutable char : CamomileLibrary.UChar.t;`	`(*`	The unicode character.	`*)`
`mutable bold : bool;`	`(*`	Whether the character is in bold or not.	`*)`
`mutable underline : bool;`	`(*`	Whether the character is underlined or not.	`*)`
`mutable blink : bool;`	`(*`	Whether the character is blinking or not.	`*)`
`mutable reverse : bool;`	`(*`	Whether the character is in reverse video mode or not.	`*)`
`mutable foreground : LTerm_style.color;`	`(*`	The foreground color.	`*)`
`mutable background : LTerm_style.color;`	`(*`	The background color.	`*)`

}

Type of a point in a matrix of styled characters.

type matrix = point array array

Type of a matrix of points. The matrix is indexed by lines then columns, i.e. to access the point at line l and column c in matrix m you should use m.(l).(c).

val make_matrix : LTerm_geom.size -> matrix

matrix size creates a matrix of the given size containing only blank characters.

val set_style : point -> LTerm_style.t -> unit

set_style point style sets fields of point according to fields of style. For example:

        set_style point { LTerm_style.none with LTerm_style.bold = Some true }

will have the following effect:

        point.bold <- true

type context

Type of contexts. A context is used for drawing.

val context : matrix -> LTerm_geom.size -> context

context m s creates a context from a matrix m of size s. It raises Invalid_argument if s is not the size of m.

exception Out_of_bounds

Exception raised when trying to access a point that is outside the bounds of a context.

val size : context -> LTerm_geom.size

size ctx returns the size of the given context.

val sub : context -> LTerm_geom.rect -> context

sub ctx rect creates a sub-context from the given context. It raises LTerm_draw.Out_of_bounds if the rectangle is not contained in the given context.

val clear : context -> unit

clear ctx clears the given context. It resets all styles to their default and sets characters to spaces.

val fill : context -> ?style:LTerm_style.t -> CamomileLibrary.UChar.t -> unit

fill ctx ch fills the given context with ch.

val fill_style : context -> LTerm_style.t -> unit

fill_style style fills the given context with style.

val point : context -> int -> int -> point

point ctx row column returns the point at given position in ctx. It raises LTerm_draw.Out_of_bounds if the coordinates are outside the given context.

val draw_char : context ->
       int -> int -> ?style:LTerm_style.t -> CamomileLibrary.UChar.t -> unit

draw_char ctx row column ?style ch sets the character at given coordinates to ch. It does nothing if the given coordinates are outside the bounds of the context.

val draw_string : context -> int -> int -> ?style:LTerm_style.t -> string -> unit

draw_string ctx row column ?style str draws the given string at given coordinates. This does not affect styles. str may contains newlines.

val draw_styled : context ->
       int -> int -> ?style:LTerm_style.t -> LTerm_text.t -> unit

draw_styled ctx row column ?style text draws the given styled text at given coordinates.

val draw_string_aligned : context ->
       int -> LTerm_geom.horz_alignment -> ?style:LTerm_style.t -> string -> unit

Draws a string with the given alignment.

val draw_styled_aligned : context ->
       int ->
       LTerm_geom.horz_alignment -> ?style:LTerm_style.t -> LTerm_text.t -> unit

Draws a styled string with the given aglienment.

type connection =

`\|`	`Blank`	`(*`	No connection.	`*)`
`\|`	`Light`	`(*`	Connection with a light line.	`*)`
`\|`	`Heavy`	`(*`	Connection with a heavy line.	`*)`

Type of an connection in a piece that can be connected to other pieces.

type piece = {

	`top : connection;`
	`bottom : connection;`
	`left : connection;`
	`right : connection;`

}

Type of a piece, given by its four connection.

val draw_piece : context ->
       int -> int -> ?style:LTerm_style.t -> piece -> unit

Draws a piece. It may modify pieces around it.

val draw_hline : context ->
       int -> int -> int -> ?style:LTerm_style.t -> connection -> unit

draw_hline ctx row column length connection draws an horizontal line.

val draw_vline : context ->
       int -> int -> int -> ?style:LTerm_style.t -> connection -> unit

draw_hline ctx row column length connection draws a vertical line.

val draw_frame : context ->
       LTerm_geom.rect -> ?style:LTerm_style.t -> connection -> unit

Draws a rectangle.