Module Mlpost.Box


module Box: sig .. end


Boxes
type t 
The abstract type of boxes

Creating boxes



type style =
| Rect
| Circle
| RoundRect
| Patatoid
| Patatoid2
| Ellipse
| RoundBox
| Custom of (Num.t -> Num.t -> Num.t * Num.t * Path.t)
type 'a box_creator = ?dx:Num.t ->
?dy:Num.t ->
?name:string ->
?stroke:Color.t option ->
?pen:Pen.t -> ?fill:Color.t -> 'a -> t
All functions used to create boxes take the following optional parameters : dx (resp. dy) is the horizontal (resp. vertical) padding between the box border and its contents ; name, if present, is associated with the box and can be used to retrieve it using get ; stroke is the color used to draw the outline of the box ; when equal to None, the outline will not be drawn ; pen is the pen used to draw the box's outline, if absent Pen.default is used ; fill, if present, is the color used to fill the box.
val empty : ?width:Num.t ->
?height:Num.t ->
?style:style ->
?name:string ->
?stroke:Color.t option ->
?pen:Pen.t -> ?fill:Color.t -> unit -> t
the empty box
val empty_from_box : ?style:style ->
?name:string ->
?stroke:Color.t option ->
?pen:Pen.t -> ?fill:Color.t -> t -> t
the empty box with the same position and dimension as the box
val pic : ?style:style -> Picture.t box_creator
pic p creates a new box containing the picture p
val path : ?style:style -> Path.t box_creator
path p creates a new box containing the path p
val tex : ?style:style -> string box_creator
tex s creates a new box containing the LaTeX string s
tex.png
val box : ?style:style -> t box_creator
box b creates a new box containing the box b
val circle : t box_creator
circle pic creates a circle box containing the picture pic. Optional padding is given by arguments dx and dy; default is 2bp.
circle.png
val ellipse : t box_creator
ellipse pic creates a elliptic box containing the picture pic. Optional padding is given by arguments dx and dy; default is 2bp
ellipse.png
val rect : t box_creator
rect pic creates a rectangular box containing the picture pic. Optional padding is given by arguments dx and dy; default is 2bp.
rect.png
val round_rect : t box_creator
round_rect pic creates a rectangular box containing the picture pic, with rounded corners. Optional padding is given by dx and dy; default is 2bp
round_rect.png
val patatoid : t box_creator
patatoid pic creates an undefined, vaguely rectangular box containing the picture pic. It may happen that the content overlaps with the box.
patatoid.png
val patatoid2 : t box_creator
patatoid2 pic creates an undefined, vaguely rectangular box containing the picture pic, which is guaranteed to be fully contained in the patatoid.
val round_box : t box_creator
val bpath : t -> Path.t
Get the bounding path of a box

Special points on a box


val ctr : t -> Point.t
ctr.png
val north : t -> Point.t
north.png
val south : t -> Point.t
south.png
val west : t -> Point.t
west.png
val east : t -> Point.t
east.png
val north_west : t -> Point.t
north_west.png
val south_west : t -> Point.t
south_west.png
val north_east : t -> Point.t
north_east.png
val south_east : t -> Point.t
south_east.png
type vposition = [ `Bot
| `Bottom
| `Center
| `Custom of t -> Num.t
| `North
| `South
| `Top ]
type hposition = [ `Center
| `Custom of t -> Num.t
| `East
| `Left
| `Right
| `West ]
type position = [ `Bot
| `Bottom
| `Bottomleft
| `Bottomright
| `Center
| `Custom of t -> Point.t
| `East
| `Left
| `Lowerleft
| `Lowerright
| `Lowleft
| `Lowright
| `North
| `Northeast
| `Northwest
| `Right
| `South
| `Southeast
| `Southwest
| `Top
| `Topleft
| `Topright
| `Upleft
| `Upperleft
| `Upperright
| `Upright
| `West ]
val corner : position -> t -> Point.t

Operators


val height : t -> Num.t
return the height of the box
height.png
val width : t -> Num.t
return the width of the box
width.png
val shift : Point.t -> t -> t
shift pt x shifts the box x about the point pt
shift.png
val center : Point.t -> t -> t
center pt x centers the box x at the point pt
center.png
val draw : ?debug:bool -> t -> Command.t
Draws a box
debug : if set to to true, the bounding path and the center of the box are drawn as well, default is false
val group : ?style:style -> t list box_creator
group bl groups a list of boxes bl into a single box

Boxes alignment


val halign : ?pos:vposition ->
Num.t -> t list -> t list
val valign : ?pos:hposition ->
Num.t -> t list -> t list
val hbox : ?padding:Num.t ->
?pos:position ->
?style:style ->
?min_width:Num.t ->
?same_width:bool -> t list box_creator
aligns the given boxes horizontally and returns a box containing these boxes as sub-components. Leave the first box at its place.
padding : horizontal padding used to separate the boxes; defaults to 0
pos : used to determine the way boxes are aligned; defaults to `Center
val hbox_list : ?padding:Num.t ->
?pos:position ->
?min_width:Num.t ->
?same_width:bool -> t list -> t list
val vbox : ?padding:Num.t ->
?pos:position ->
?style:style ->
?min_height:Num.t ->
?same_height:bool -> t list box_creator
aligns the given boxes vertically and returns a box containing these boxes as sub-components. Leave the first box at its place.
padding : vertical padding used to separate the boxes
pos : used to determine the way boxes are aligned
val vbox_list : ?padding:Num.t ->
?pos:position ->
?min_height:Num.t ->
?same_height:bool -> t list -> t list
val tabular : ?hpadding:Num.t ->
?vpadding:Num.t ->
?pos:Command.position ->
?style:style ->
?name:string ->
?stroke:Color.t option ->
?pen:Pen.t ->
?fill:Color.t -> t array array -> t
aligns the given boxes both vertically and horizontally and returns a box containing all these boxes (with rows as first sub-components, and then individual boxes as sub-components of each row). Columns (resp. rows) are separated by hpadding (resp. vpadding); both default to 0. Alignment within columns and rows is controlled using pos. The arrays for rows must have the same lengths; otherwise Invalid_argument is raised.
val tabularl : ?hpadding:Num.t ->
?vpadding:Num.t ->
?pos:Command.position ->
?style:style ->
?name:string ->
?stroke:Color.t option ->
?pen:Pen.t ->
?fill:Color.t -> t list list -> t
similar to tabular, but using lists instead of arrays
val tabulari : ?hpadding:Num.t ->
?vpadding:Num.t ->
?pos:Command.position ->
?style:style ->
?name:string ->
?stroke:Color.t option ->
?pen:Pen.t ->
?fill:Color.t ->
int -> int -> (int -> int -> t) -> t
similar to tabular, but using a matrix defined with a function
val hplace : ?padding:Num.t ->
?pos:position ->
?min_width:Num.t ->
?same_width:bool -> t list -> t list
val vplace : ?padding:Num.t ->
?pos:position ->
?min_height:Num.t ->
?same_height:bool -> t list -> t list
val hblock : ?padding:Num.t ->
?pos:Command.position ->
?name:string ->
?stroke:Color.t option ->
?pen:Pen.t ->
?min_width:Num.t ->
?same_width:bool -> t list -> t
hblock bl aligns the boxes of bl horizontally and surround them with new rectangular boxes of the same height; all these new boxes are packed together into the returned box.
min_width : minimum width of all boxes; default is zero
same_width : if true, all boxes are of same width, and at least of min_width; default is false
val vblock : ?padding:Num.t ->
?pos:Command.position ->
?name:string ->
?stroke:Color.t option ->
?pen:Pen.t ->
?min_height:Num.t ->
?same_height:bool -> t list -> t
similar to hblock, with vertical alignment.
min_height : minimum height of all boxes; default is zero
same_height : if true, all boxes are of same height, and at least of min_height; default is false
val grid : ?hpadding:Num.t ->
?vpadding:Num.t ->
?pos:Command.position ->
?stroke:Color.t option ->
?pen:Pen.t -> t array array -> t
Aligns the given boxes in a way that is similar to hblock and vblock: boxes are aligned in a grid where all cells have the same size. Each one of these cells is a box containing the original corresponding box.
val gridl : ?hpadding:Num.t ->
?vpadding:Num.t ->
?pos:Command.position ->
?stroke:Color.t option ->
?pen:Pen.t -> t list list -> t
similar to grid, but using lists instead of arrays
val gridi : ?hpadding:Num.t ->
?vpadding:Num.t ->
?pos:Command.position ->
?stroke:Color.t option ->
?pen:Pen.t ->
int -> int -> (int -> int -> t) -> t
similar to gridi, but using a matrix defined with a function

Sub-boxes accessors


val nth : int -> t -> t
nth i b returns the i-th sub-box of b. The first sub-box has index 0. Raises Invalid_argument if there is no such sub-box.
val get : string -> t -> t
get n b returns the sub-box of b of name n, if any, and raises Invalid_argument otherwise. The behavior is not specified if b contains several sub-boxes with name n.
val sub : t -> t -> t
sub b1 b2 returns the sub-box of b which has the same name as b1, if any, and raises Invalid_argument otherwise. The behavior is not specified if b contains several sub-boxes with the name of b1.
val elts : t -> t array
elts b returns the sub-boxes of b; returns the empty array for the empty box or a box containing a picture.

Specials Points


val setp : string -> Point.t -> t -> t
val getp : string -> t -> Point.t
val getpx : string -> t -> Num.t
val getpy : string -> t -> Num.t

Box properties


val get_fill : t -> Color.t option
val set_fill : Color.t -> t -> t
val get_stroke : t -> Color.t option
val set_stroke : Color.t -> t -> t
val clear_stroke : t -> t
val get_name : t -> string
val set_name : string -> t -> t
val get_pen : t -> Pen.t option
val set_pen : Pen.t -> t -> t
val set_height : Command.vposition -> Num.t -> t -> t
val set_width : Command.hposition -> Num.t -> t -> t
val set_height2 : vposition ->
Num.t ->
vposition -> Num.t -> t -> t
set_height2 `North y1 `South y2 b return the box b with its height and center chosen such as the ordinate of the top (because of `North) of the box is at y1 and the ordinate of its south is at y2
val set_width2 : hposition ->
Num.t ->
hposition -> Num.t -> t -> t
val set_size : Command.position ->
width:Num.t -> height:Num.t -> t -> t
val same_height : ?pos:vposition -> t list -> t list
val same_width : ?pos:hposition -> t list -> t list
val same_size : ?pos:position -> t list -> t list

Misc.


val shadow : t -> t
val cpath : ?style:Path.joint ->
?outd:Path.direction ->
?ind:Path.direction ->
?sep:Num.t -> t -> t -> Path.t
the path that connects 2 boxes and stops at the box boundaries
val cpath_left : ?style:Path.joint ->
?outd:Path.direction ->
?ind:Path.direction -> t -> Point.t -> Path.t
the path that connects a box and a point and stops at the box boundaries
val cpath_right : ?style:Path.joint ->
?outd:Path.direction ->
?ind:Path.direction -> Point.t -> t -> Path.t
the path that connects a box and a point and stops at the box boundaries
val transform : Transform.t -> t -> t
val scale : Num.t -> t -> t
val rotate : float -> t -> t
val shift : Point.t -> t -> t
val yscale : Num.t -> t -> t
val xscale : Num.t -> t -> t