Module `Brr_canvas.C2d`

The 2D canvas context.

Enumerations

module Fill_rule : sig ... end: Fill rule enum.

module Image_smoothing_quality : sig ... end: Image smoothing quality enum.

module Line_cap : sig ... end: Line cap.

module Line_join : sig ... end: Line join.

module Text_align : sig ... end: Text alignement.

module Text_baseline : sig ... end: Text baseline.

module Text_direction : sig ... end: Text direction.

module Composite_op : sig ... end: Compositing operators.

module Repeat : sig ... end: Pattern repetition.

Paths

module Path : sig ... end: Path2D objects.

Image sources

type image_src: The type for canvas image sources. This can be many things.

val image_src_of_el : Brr.El.t -> image_src: image_src_of_el e use this with an El.img, El.video, El.canvas element. No checks are performed.

val image_src_of_jv : Jv.t -> image_src: image_src_of_jv jv is an image source from the given JavaScript value. jv must be one of these things, no checks are performed.

Context attributes

type attrs: The type for CanvasRenderingContext2DSettings.

val attrs : ?⁠alpha:bool -> ?⁠desynchronized:bool -> unit -> attrs: attrs () are attrs with the given attributes.

val attrs_alpha : attrs -> bool: attrs_alpha a is the alpha attribute of a.

val attrs_desynchronized : attrs -> bool: attrs_desynchronized a is the desynchronized attribute of a.

Context

type t: The type for CanvasRenderingContext2D objects.

val create : ?⁠attrs:attrs -> Canvas.t -> t: create ~attrs cnv creates 2D context for canvas cnv with attributes attrs.

val canvas : t -> Canvas.t option: canvas c is the canvas element associated to the context c (if any).

val attrs : t -> attrs: attrs c are the context's attributes.

val save : t -> unit: save c saves the state of c.

val restore : t -> unit: restore c restores last save of c.

Antialiasing

val image_smoothing_enabled : t -> bool: image_smoothing_enabled c determines the image smoothing (antialiasing) performed on c.

val set_image_smoothing_enabled : t -> bool -> unit: image_smoothing_enabled c b sets the image smoothing (antialiasing) performed on c.

val image_smoothing_quality : t -> Image_smoothing_quality.t: image_smoothing_enabled c determines image smoothing quality (antialiasing) performed on c.

val set_image_smoothing_quality : t -> Image_smoothing_quality.t -> unit: image_smoothing_enabled c sets the image smoothing quality (antialiasing) performed on c.

Compositing

val global_alpha : t -> float: global_alpha c is the global alpha of c.

val set_global_alpha : t -> float -> unit: set_global_alpha c a setes the global alpha of c to a.

val global_composite_op : t -> Composite_op.t: global_composite_op c is the global composite operator of c.

val set_global_composite_op : t -> Composite_op.t -> unit: set_global_composite_op c op sets the global composite operator of c to op.

val filter : t -> Jstr.t: filter c is the filter of c.

val set_filter : t -> Jstr.t -> unit: set_filter c f sets the filter of c to f.

Transformations

val get_transform : t -> Matrix4.t: get_transform c gets the current transformation matrix.

val set_transform : t -> Matrix4.t -> unit: set_transform c m sets the current transformation matrix.

val reset_transform : t -> unit: reset_transform c resets the current transformation matrix to the identity.

val transform : t -> Matrix4.t -> unit: transform c m transforms space by matrix m.

val translate : t -> x:float -> y:float -> unit: translate c x y translates space by (x,y).

val rotate : t -> float -> unit: rotate c r rotates space by r radians.

val scale : t -> sx:float -> sy:float -> unit: scale c sx sy scales space by (sx, sy).

Style fills and strokes

type style: The type for stroke and fill styles.

val set_stroke_style : t -> style -> unit: set_stroke_style c s sets the stroke style of c to s.

val set_fill_style : t -> style -> unit: set_fill_style c s sets the fill style of c to s.

val color : Jstr.t -> style: color s is the color s parsed as a CSS color value as a style.

type gradient: The type for gradients.

val gradient_style : gradient -> style: gradient_style g is a style from the given gradient.

val linear_gradient : t -> x0:float -> y0:float -> x1:float -> y1:float -> stops:(float * Jstr.t) list -> gradient: linear_gradient c ~x0 ~y0 ~x1 ~y1 ~stops create a linear gradient from (x0,y0) to (x1,y1) with color stops stops.

val radial_gradient : t -> x0:float -> y0:float -> r0:float -> x1:float -> y1:float -> r1:float -> stops:(float * Jstr.t) list -> gradient: radial_gradient c ~x0 ~y0 ~r0 ~x1 ~y1 ~r1 ~stops create a radial gradient from circle centered at (x0,y0) with radius r0 to circle centered at (x1,y1) with radius r1 and color stops stops.

type pattern: The type for patterns.

val pattern_style : pattern -> style: pattern_style p is a style from the given pattern.

val pattern : t -> image_src -> Repeat.t -> tr:Matrix4.t option -> pattern: pattern c img repeat ~tr creates a pattern from img repeatint it according to repeat and transform tr.

Style lines

val line_width : t -> float: line_width c is the line width in c.

val set_line_width : t -> float -> unit: set_line_width c w set the line width to w in c.

val line_cap : t -> Line_cap.t: line_cap c is the line cap in c.

val set_line_cap : t -> Line_cap.t -> unit: set_line_cap c cap set the line cap to cap in c.

val line_join : t -> Line_join.t: line_join c is the line join in c.

val set_line_join : t -> Line_join.t -> unit: set_line_join c join set the line join to join in c.

val miter_limit : t -> float: miter_limit c is the miter limit in c.

val set_miter_limit : t -> float -> unit: set_miter_limit c l set the miter limit to l in c.

val line_dash : t -> float list: line_dash c are the line dashes in c.

val set_line_dash : t -> float list -> unit: set_line_dash c ds sets the line dashes to ds in c.

val line_dash_offset : t -> float: line_dash_offset c is the line dash offset in c.

val set_line_dash_offset : t -> float -> unit: set_line_dash_offset c o set the line dash offset to o in c.

Style shadows

val shadow_blur : t -> float: shadow_blur c is the shadow blur of c.

val set_shadow_blur : t -> float -> unit: set_shadow_blur c b sets the shadow blur of c to b.

val shadow_offset_x : t -> float: shadow_offset_x c is the x shadow offset of c.

val set_shadow_offset_x : t -> float -> unit: set_shadow_offset_x c o sets the x shadow offset of c to o

val shadow_offset_y : t -> float: shadow_offset_y c is the y shadow offset of c.

val set_shadow_offset_y : t -> float -> unit: set_shadow_offset_x c o sets the y shadow offset of c to o.

val shadow_color : t -> Jstr.t: shadow_color c is the shadow color of c.

val set_shadow_color : t -> Jstr.t -> unit: set_shadow_color c col sets the shadow color of c to col.

Style text

val font : t -> Jstr.t: font c is the font in c.

val set_font : t -> Jstr.t -> unit: set_font c fnt set the font to fnt in c.

val text_align : t -> Text_align.t: text_align c is the text align in c.

val set_text_align : t -> Text_align.t -> unit: set_text_align c a set the text align to a in c.

val text_baseline : t -> Text_baseline.t: text_baseline c is the text baseline in c.

val set_text_baseline : t -> Text_baseline.t -> unit: set_text_baseline c b set the text baseline to b in c.

val text_direction : t -> Text_direction.t: text_direction c is the text direction in c.

val set_text_direction : t -> Text_direction.t -> unit: set_direction c d set the text direction to d in c.

Draw rectangles

val clear_rect : t -> x:float -> y:float -> w:float -> h:float -> unit: clear_rect c x y ~w ~h clears the given rectangular area by setting it to transparent black.

val fill_rect : t -> x:float -> y:float -> w:float -> h:float -> unit: fill_rect c x y ~w ~h fill the given rectangular area with current fill style.

val stroke_rect : t -> x:float -> y:float -> w:float -> h:float -> unit: stroke_rect c x y ~w ~h strokes the given rectangular area with current stroke style.

Draw paths

Note. fill_rule always defaults to Fill_rule.nonzero.

val fill : ?⁠fill_rule:Fill_rule.t -> t -> Path.t -> unit: fill ~fill_rule c p fills p in c according to fill_rule.

val stroke : t -> Path.t -> unit: stroke c p strokes path p in c.

val clip : ?⁠fill_rule:Fill_rule.t -> t -> Path.t -> unit: clip ~fill_rule c p clip drawing to the region of p in c according to fill_rule.

val draw_focus_if_needed : t -> Path.t -> Brr.El.t -> unit: draw_focus_if_needed c p e draws a focus ring around p in c if e has focus.

val scroll_path_into_view : t -> Path.t -> unit: scroll_path_into_view c p scrolls path p into view in c.

val is_point_in_fill : ?⁠fill_rule:Fill_rule.t -> t -> Path.t -> x:float -> y:float -> bool: is_point_in_fill ~fill_rule c p x y determines whether (x,y) is in the fill determiend by path p in c according to fill_rule.

val is_point_in_stroke : t -> Path.t -> x:float -> y:float -> bool: point_in_path c p x y determines whether (x,y) is in the stroke determiend by path p.

Draw text

val fill_text : ?⁠max_width:float -> t -> Jstr.t -> x:float -> y:float -> unit: fill_text c txt x y fills text txt at position (x,y).

val stroke_text : ?⁠max_width:float -> t -> Jstr.t -> x:float -> y:float -> unit: fill_text c txt x y fills text txt at position (x,y).

module Text_metrics : sig ... end: Text metrics.

val measure_text : t -> Jstr.t -> Text_metrics.t: measure_text txt measures text txt.

Draw images

val draw_image : t -> image_src -> x:float -> y:float -> unit: draw_image c i x y draws image i in the rectangle of c with top-left corner (x,y) and bottom-right corner (x+iw, y+ih), with iw and ih the width and height of i (unclear which unit that is though).

val draw_image_in_rect : t -> image_src -> x:float -> y:float -> w:float -> h:float -> unit: draw_image_in_rect c i x y ~w ~h draws image i in the rectangle of c with top-left corner (x,y) and bottom-right corner (x+w, y+h).

val draw_sub_image_in_rect : t -> image_src -> sx:float -> sy:float -> sw:float -> sh:float -> x:float -> y:float -> w:float -> h:float -> unit: draw_sub_image_in_rect c i ~sx ~sy ~xw ~sh x y ~w ~h draws the pixels of i in the image space rectangle with top-left corner (sx,sy) and bottom-right corner (sx+sw,sy+sh) in the rectangle of c with top-left corner (x,y) and bottom-right corner (x+w, y+h).

Pixel manipulation

module Image_data : sig ... end: Image data objects

val create_image_data : t -> w:int -> h:int -> Image_data.t: create_image_data c ~w ~h is a new image data of wxh transparent black pixels.

val get_image_data : t -> x:int -> y:int -> w:int -> h:int -> Image_data.t: get_image_data c x y ~w ~h are the pixels of canvas c in the image space rectangle with top-left corner (x,y) and bottom-right corner (x+w, y+h).

val put_image_data : t -> Image_data.t -> x:int -> y:int -> unit: put_image_data c d x y writes the pixels of d in the image space rectangle of c with top-left corner (x,y) and bottom-right corner (x+iw, y+ih), with iw and ih the width and height of i.

val put_sub_image_data : t -> Image_data.t -> sx:int -> sy:int -> sw:int -> sh:int -> x:int -> y:int -> unit: put_sub_image_data c d ~sx ~sy ~xw ~sh x y writes the pixels of d in the image space rectangle with top-left corner (sx,sy) and bottom-right corner (sx+sw,sy+sh) to the image space rectangle of c with top-left corner (x,y) and bottom-right corner (x+sx, y+sy).