package patoline

  1. Overview
  2. Docs
package patoline
Legend:
Library
Module
Module type
Parameter
Class
Class type

Patoline boxes

type box =
  1. | GlyphBox of Patoraw.RawContent.glyph
  2. | Kerning of box Patfonts.FTypes.kerningBox
  3. | Glue of drawingBox
  4. | Drawing of drawingBox
  5. | Hyphen of hyphenBox
  6. | Marker of marker
  7. | BeginFigure of int
  8. | FlushFigure of int
  9. | Parameters of parameters -> parameters
  10. | Layout of frame_zipper -> frame_zipper
  11. | Empty

Elementary box in a paragraph

and paragraph = box array

A paragraph is an array of elementary boxes. The line breaking algorithm produces lines (given by the type line) by selecting chunks in a paragraph array.

and drawingBox = {
  1. drawing_min_width : float;
  2. drawing_nominal_width : float;
  3. drawing_max_width : float;
  4. drawing_width_fixed : bool;
  5. drawing_adjust_before : bool;
  6. drawing_y0 : float;
  7. drawing_y1 : float;
  8. drawing_badness : float -> float;
  9. drawing_break_badness : float;
  10. drawing_states : int list;
  11. drawing_contents : float -> Patoraw.RawContent.raw list;
}
and hyphenBox = {
  1. hyphen_normal : box array;
  2. hyphenated : (box array * box array) array;
}
and kind =
  1. | Extern of string
  2. | Intern of string
  3. | Button of Patoraw.RawContent.button_kind * string
and marker =
  1. | Label of string
  2. | FigureRef of int
  3. | Pageref of string
  4. | Structure of int list
  5. | AlignmentMark
and line = {
  1. paragraph : int;
    (*

    Index of the paragraph containing this line in the array

    *)
  2. lastFigure : int;
    (*

    Last placed figure (initially -1)

    *)
  3. lineStart : int;
    (*

    Index of the first box of the line in the paragraph.

    *)
  4. lineEnd : int;
    (*

    Index of the box next to the last box of the line, or the box with the hyphenation if the line is hyphenated.

    *)
  5. hyphenStart : int;
  6. hyphenEnd : int;
  7. isFigure : bool;
  8. layout : frame_zipper;
  9. height : float;
  10. paragraph_height : int;
  11. page_line : int;
  12. min_width : float;
  13. nom_width : float;
  14. max_width : float;
  15. line_y0 : float;
  16. line_y1 : float;
}

Description of a line, which should be produced by the line breaking algorithm. A line is merely described as the index of its first box and the index of its last box inside the paragraph (which itself is an array of boxes).

and parameters = {
  1. measure : float;
  2. left_margin : float;
  3. local_optimization : int;
  4. min_height_before : float;
  5. min_height_after : float;
  6. min_page_before : int;
  7. min_page_after : int;
  8. not_last_line : bool;
  9. not_first_line : bool;
  10. min_lines_before : int;
  11. min_lines_after : int;
  12. absolute : bool;
}
and placed_line = {
  1. line_params : parameters;
  2. line : line;
}
and frame_content =
  1. | Placed_line of placed_line
  2. | Raw of Patoraw.RawContent.raw list
and frame = {
  1. frame_children : frame Patutil.Extra.IntMap.t;
  2. frame_tags : string list;
  3. frame_x0 : float;
  4. frame_y0 : float;
  5. frame_x1 : float;
  6. frame_y1 : float;
  7. frame_content : frame_content list;
}
and frame_zipper = frame * (int * frame) list
module MarkerMap : sig ... end
val is_glyph : box -> bool

Helpful test functions.

val is_glue : box -> bool
val is_hyphen : box -> bool

Build a box containing one glyph, with a cache.

Build a glyph id from a font and a unicode character.

val glyph_of_string : (Patfonts.FTypes.glyph_id list -> Patfonts.FTypes.glyph_id list) -> (Patfonts.FTypes.glyph_ids list -> Patfonts.FTypes.glyph_ids list) -> Patfonts.Fonts.font -> float -> Patoraw.Color.color -> string -> box list

Build a list of boxes from a string, using stuff from kerning.

val hyphenate : (string -> (string * string) array) -> (Patfonts.FTypes.glyph_id list -> Patfonts.FTypes.glyph_id list) -> (Patfonts.FTypes.glyph_ids list -> Patfonts.FTypes.glyph_ids list) -> Patfonts.Fonts.font -> float -> Patoraw.Color.color -> string -> box list

Build a list of boxes representing a word, while taking care of building an array of possible hyphenations for the word (if any).

Helper functions for layouts

val frame_up : (frame * (Patutil.Extra.IntMap.key * frame) list) -> frame * (Patutil.Extra.IntMap.key * frame) list
val frame_down_last : (frame * (Patutil.Extra.IntMap.key * frame) list) -> frame * (Patutil.Extra.IntMap.key * frame) list
val frame_top : (frame * (Patutil.Extra.IntMap.key * frame) list) -> frame * (Patutil.Extra.IntMap.key * frame) list
val empty_frame : frame
val frame : ?contents:frame_content list -> float -> float -> float -> float -> (frame * (int * frame) list) -> frame * (int * frame) list

Creates a new frame with the given top-left and bottom-right corners, appends this frame as a child of the current frame, and moves down to this new frame.

val make_page : (float * float) -> (frame * (int * frame) list) -> frame * (int * frame) list
val twocols : (frame * 'a) -> frame * 'a
val next_zipper : (frame * (Patutil.Extra.IntMap.key * frame) list) -> (frame * (Patutil.Extra.IntMap.key * frame) list) option
val doc_frame : frame
val frame_page : ('a * (Patutil.Extra.IntMap.key * frame) list) -> int
val layout_page : line -> int
val all_contents : frame -> frame_content list

Helper functions for lines

val uselessLine : line
val default_params : parameters
val lines_eq : line -> line -> bool
val empty_drawing_box : drawingBox
val drawing : ?adjust_before:bool -> ?vcenter:bool -> ?hcenter:bool -> ?offset:float -> ?width_fixed:bool -> ?states:int list -> Patoraw.RawContent.raw list -> drawingBox
val drawing_blit : drawingBox -> float -> float -> drawingBox -> drawingBox
val box_width : float -> box -> float
val box_size : box -> float
val box_interval : box -> float * float * float
val boxes_interval : box array -> float * float * float
val lower_y : box -> float
val upper_y : box -> float
val knuth_h_badness : float -> float -> float
val glue : float -> float -> float -> box
val resize_drawing : float -> drawingBox -> drawingBox
val resize : float -> box -> box
val translate : float -> float -> box -> box
val vkern_percent_under' : ('a -> 'b -> box list) -> float -> 'a -> 'b -> float * box list
val vkern_percent_under : ('a -> 'b -> box list) -> float -> 'a -> 'b -> box list
val vkern_center : ('a -> 'b -> box list) -> float -> 'a -> 'b -> box list
val vkern_translate : ('a -> 'b -> box list) -> float -> 'a -> 'b -> box list
val vkern_as : ('a -> 'b -> box list) -> ('a -> 'b -> box list) -> 'a -> 'b -> box list
val fold_left_line : box array array -> ('a -> box -> 'a) -> 'a -> line -> 'a

Calling fold_left_line paragraphs f x0 line computes f (... (f (f (f x0 box0) box1) box2) ...) boxn where box0, box1, box2, … boxn are the boxes which belong to line in its corresponding paragraph paragraphs.(line.paragraph).

val line_layout : box array array -> line -> frame_zipper -> frame_zipper
val fold_left : ('a -> box -> 'a) -> 'a -> box list -> 'a
val first_line : box array array -> line -> box
val last_line : box array array -> line -> box
val line_height : box array array -> drawingBox array -> line -> float * float
val comp : box array array -> float -> int -> int -> int -> int -> int -> float
val compression : box array array -> parameters -> line -> float
val box_to_string : box -> string
val text_line : box array array -> line -> string
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct