🥮 mooncakes.io

    moon_cosmic

    MoonBit port of cosmic-text (text shaping, layout, and editor primitives) built on moon_swash.

    text
    layout
    bidi
    shaping
    swash
    cosmic-text
    Download zip
    Author
    Version
    0.3.6
    License
    Apache-2.0
    Repository
    Last updated
    52 minutes ago
    Downloads
    40K

    Dependencies

    #Milky2018/moon_cosmic

    MoonBit port of Rust cosmic-text (text shaping, layout, and editor primitives), built on top of Milky2018/moon_swash.

    The project keeps behavior aligned with upstream cosmic-text through automated tests where feasible.

    #Features

    • Font system (in-memory): load TTF/OTF/TTC bytes; resolve fonts by family + weight; per-codepoint fallback.
    • Shaping: Shaping::Advanced uses moon_swash/shape to produce clustered glyphs and advances; tabs snap to stops.
    • Wrapping & layout: Wrap::{None,Glyph,Word,WordOrGlyph}, Align::{Left,Right,Center,Justified,Start,End}, hinting.
    • BiDi: paragraph iteration + embedding levels and visual reordering of glyph runs.
    • Raster cache: CacheKey + SwashCache backed by moon_swash/scale (variable wght axis support; fake-italic transform).
    • Editor primitives: Buffer, Editor, cursor/selection, hit-testing, and motion actions.

    #Install

    Add dependency:

    moon add Milky2018/moon_cosmic

    #Quick Start (Layout)

    import Milky2018/moon_cosmic

    fn main {
      // Provide font bytes from your host app (file I/O is app-specific).
      let font_bytes : Bytes = /* ... */

      let font_system = FontSystem::new().load_font_data(font_bytes)
      let metrics = Metrics::new(14.0F, 20.0F)

      let attrs = Attrs::new().family(Family::Name("Inter"))
      let attrs_list = AttrsList::new(attrs)

      let buffer = Buffer::new(metrics)
        .set_wrap(Wrap::WordOrGlyph)
        .set_text("Hello world", attrs_list, Shaping::Advanced)
        .set_size(Some(200.0F), None)
        .layout_all_with_font_system(font_system)

      for run in buffer.layout_runs() {
        // `run.glyphs`: Array[LayoutGlyph]
        // `run.line_w`: line width in pixels
        ignore(run)
      }
    }

    #Quick Start (Draw)

    Buffer::draw renders via a callback (pixel-oriented for compatibility with the legacy renderer pattern).

    import Milky2018/moon_cosmic

    fn draw_demo(font_bytes : Bytes) -> Unit {
      let font_system = FontSystem::new().load_font_data(font_bytes)
      let cache = SwashCache::new()

      let buffer = Buffer::new(Metrics::new(14.0F, 20.0F))
        .set_text("Hi!", AttrsList::new(Attrs::new()), Shaping::Advanced)
        .set_size(Some(200.0F), None)

      let (_buffer, _cache) = buffer.draw(
        font_system,
        cache,
        Color::rgb(0, 0, 0),
        fn(_x, _y, _w, _h, _color) { () },
      )
    }

    #Integration Notes

    #Subpixel Cache Keys (Atlas Caching)

    Downstream atlas caches should key by PhysicalGlyph.cache_key (includes x_bin/y_bin), not only (glyph_id, x, y).

    #Font Collections (TTC / Multi-face)

    FontSystem::load_font_data may load multiple faces from one file/collection. Each face gets its own font_id. Use FontSystem::get_font(font_id) / FontSystem::get_font_entry(font_id) to rasterize the correct face for a given LayoutGlyph.

    #Dev Workflow

    Common commands:

    moon check        # Lint/type-check
moon test         # Run tests
moon fmt          # Format
moon info         # Update .mbti
moon info && moon fmt

    #Test Font Blob

    Some tests require real font metrics. This repo embeds Inter-Regular.ttf into src/test_fonts_test.mbt (base64).

    To regenerate it (if test font data changes):

    python3 scripts/gen_test_font_mbt.py
moon fmt
moon test

    #License

    Apache-2.0. Upstream cosmic-text is dual-licensed MIT OR Apache-2.0.

    CacheKeyFlags

    source
    type CacheKeyFlags = UInt

    Flags that change rendering.

    Edit

    source
    pub(open) trait Edit {
      fn editor(Self) -> Editor
      fn set_editor(Self, Editor) -> Self
      fn cursor(Self) -> Cursor
      fn set_cursor(Self, Cursor) -> Self
      fn selection(Self) -> Selection
      fn set_selection(Self, Selection) -> Self
      fn auto_indent(Self) -> Bool
      fn set_auto_indent(Self, Bool) -> Self
      fn tab_width(Self) -> Int
      fn set_tab_width(Self, Int) -> Self
      fn start_change(Self) -> Self
      fn finish_change(Self) -> (Self, Change?)
      fn copy_selection(Self) -> String?
      fn delete_selection(Self) -> (Self, Bool)
      fn delete_range(Self, Cursor, Cursor) -> Self
      fn insert_string(Self, String, AttrsList?) -> Self
      fn apply_change(Self, Change) -> (Self, Bool)
      fn cursor_position(Self) -> (Int, Int)?
      fn action(Self, Action) -> Self
    }

    Shared editable surface for Editor/SyntaxEditor/ViEditor.

    Renderer

    source
    pub(open) trait Renderer {
      fn rectangle(Self, x : Int, y : Int, w : UInt, h : UInt, color : Color) -> Unit
      fn glyph(Self, physical_glyph : PhysicalGlyph, color : Color) -> Unit
    }

    Custom renderer for buffers and editors.

    Action

    source
    pub(all) enum Action {
      Motion(Motion)
      Escape
      Insert(Char)
      Enter
      Backspace
      Delete
      Indent
      Unindent
      Click(Int, Int)
      DoubleClick(Int, Int)
      TripleClick(Int, Int)
      Drag(Int, Int)
      Scroll(Float)
    }

    An action to perform on an editor.

    Affinity

    source
    pub(all) enum Affinity {
      Before
      After
    }

    Whether to associate cursors placed at a boundary between runs with the run before or after it.
    impl Eq for Affinity

    Affinity::after

    source
    fn Affinity::after(self : Affinity) -> Bool

    Affinity::before

    source
    fn Affinity::before(self : Affinity) -> Bool

    Affinity::equal

    source
    fn Affinity::equal(self : Affinity, other : Affinity) -> Bool

    Affinity::from_after

    source
    fn Affinity::from_after(after : Bool) -> Affinity

    Affinity::from_before

    source
    fn Affinity::from_before(before : Bool) -> Affinity

    Affinity::not_equal

    source
    fn Affinity::not_equal(x : Affinity, y : Affinity) -> Bool

    Align

    source
    pub(all) enum Align {
      Left
      Right
      Center
      Justified
      Start
      End
    }

    Align or justify

    Attrs

    source
    pub struct Attrs {
      color_opt : Color?
      metadata : Int
      family : Family
      weight : Weight
      stretch : 
    Stretch
      style : 
    Style
      cache_key_flags : UInt
      metrics_opt : CacheMetrics?
      letter_spacing_opt : LetterSpacing?
      font_features : FontFeatures
      text_decoration : TextDecoration
    }

    impl Eq for Attrs
    impl Hash for Attrs

    Attrs::cache_key_flags

    source
    fn Attrs::cache_key_flags(self : Attrs, cache_key_flags : UInt) -> Attrs

    Attrs::cache_key_flags_value

    source
    fn Attrs::cache_key_flags_value(self : Attrs) -> UInt

    Attrs::color

    source
    fn Attrs::color(self : Attrs, color : Color) -> Attrs

    Attrs::color_opt_value

    source
    fn Attrs::color_opt_value(self : Attrs) -> Color?

    Attrs::compatible

    source
    fn Attrs::compatible(self : Attrs, other : Attrs) -> Bool

    Attrs::equal

    source
    fn Attrs::equal(self : Attrs, other : Attrs) -> Bool

    Attrs::family

    source
    fn Attrs::family(self : Attrs, family : Family) -> Attrs

    Attrs::family_value

    source
    fn Attrs::family_value(self : Attrs) -> Family

    Attrs::font_features

    source
    fn Attrs::font_features(self : Attrs, font_features : FontFeatures) -> Attrs

    Attrs::font_features_value

    source
    fn Attrs::font_features_value(self : Attrs) -> FontFeatures

    Attrs::hash

    source
    fn Attrs::hash(self : Attrs) -> Int

    Attrs::hash_combine

    source
    fn Attrs::hash_combine(self : Attrs, hasher : Hasher) -> Unit

    Attrs::letter_spacing

    source
    fn Attrs::letter_spacing(self : Attrs, letter_spacing : Float) -> Attrs

    Attrs::letter_spacing_opt

    source
    fn Attrs::letter_spacing_opt(self : Attrs) -> Float?

    Attrs::metadata

    source
    fn Attrs::metadata(self : Attrs) -> Int

    Attrs::metrics

    source
    fn Attrs::metrics(self : Attrs, metrics : Metrics) -> Attrs

    Set Metrics, overriding values in Buffer for this span.

    Attrs::metrics_opt

    source
    fn Attrs::metrics_opt(self : Attrs) -> Metrics?

    Return optional Metrics override.

    Attrs::new

    source
    fn Attrs::new() -> Attrs

    Attrs::not_equal

    source
    fn Attrs::not_equal(x : Attrs, y : Attrs) -> Bool

    Attrs::overline

    source
    fn Attrs::overline(self : Attrs) -> Attrs

    Attrs::overline_color

    source
    fn Attrs::overline_color(self : Attrs, color : Color) -> Attrs

    Attrs::stretch

    source
    fn Attrs::stretch(self : Attrs, stretch : 
    Stretch    ) -> Attrs

    Attrs::stretch_value

    source
    fn Attrs::stretch_value(self : Attrs) -> 
    Stretch

    Attrs::strikethrough

    source
    fn Attrs::strikethrough(self : Attrs) -> Attrs

    Attrs::strikethrough_color

    source
    fn Attrs::strikethrough_color(self : Attrs, color : Color) -> Attrs

    Attrs::style

    source
    fn Attrs::style(self : Attrs, style : 
    Style    ) -> Attrs

    Attrs::style_value

    source
    fn Attrs::style_value(self : Attrs) -> 
    Style

    Attrs::text_decoration

    source
    fn Attrs::text_decoration(self : Attrs, text_decoration : TextDecoration) -> Attrs

    Attrs::text_decoration_value

    source
    fn Attrs::text_decoration_value(self : Attrs) -> TextDecoration

    Attrs::underline

    source
    fn Attrs::underline(self : Attrs, style : UnderlineStyle) -> Attrs

    Attrs::underline_color

    source
    fn Attrs::underline_color(self : Attrs, color : Color) -> Attrs

    Attrs::weight

    source
    fn Attrs::weight(self : Attrs, weight : Weight) -> Attrs

    Attrs::weight_value

    source
    fn Attrs::weight_value(self : Attrs) -> Weight

    Attrs::with_metadata

    source
    fn Attrs::with_metadata(metadata : Int) -> Attrs

    AttrsList

    source
    pub struct AttrsList {
      defaults : Attrs
      spans : Array[AttrsSpan]
    }

    impl Eq for AttrsList
    impl Hash for AttrsList

    AttrsList::add_span

    source
    fn AttrsList::add_span(self : AttrsList, start : Int, end : Int, attrs : Attrs) -> AttrsList

    AttrsList::defaults

    source
    fn AttrsList::defaults(self : AttrsList) -> Attrs

    AttrsList::eq

    source
    fn AttrsList::eq(self : AttrsList, other : AttrsList) -> Bool

    AttrsList::equal

    source
    fn AttrsList::equal(self : AttrsList, other : AttrsList) -> Bool

    AttrsList::get_span

    source
    fn AttrsList::get_span(self : AttrsList, pos : Int) -> Attrs

    AttrsList::hash

    source
    fn AttrsList::hash(self : AttrsList) -> Int

    AttrsList::hash_combine

    source
    fn AttrsList::hash_combine(self : AttrsList, hasher : Hasher) -> Unit

    AttrsList::new

    source
    fn AttrsList::new(defaults : Attrs) -> AttrsList

    AttrsList::not_equal

    source
    fn AttrsList::not_equal(x : AttrsList, y : AttrsList) -> Bool

    AttrsList::spans_iter

    source
    fn AttrsList::spans_iter(self : AttrsList) -> Array[AttrsSpan]

    AttrsList::split_off

    source
    fn AttrsList::split_off(self : AttrsList, index : Int) -> (AttrsList, AttrsList)

    Splits spans at index and returns (left, right).

    AttrsSpan

    source
    pub struct AttrsSpan {
      start : Int
      end : Int
      attrs : Attrs
    }

    impl Eq for AttrsSpan
    impl Hash for AttrsSpan

    AttrsSpan::equal

    source
    fn AttrsSpan::equal(self : AttrsSpan, other : AttrsSpan) -> Bool

    AttrsSpan::hash

    source
    fn AttrsSpan::hash(self : AttrsSpan) -> Int

    AttrsSpan::hash_combine

    source
    fn AttrsSpan::hash_combine(self : AttrsSpan, hasher : Hasher) -> Unit

    AttrsSpan::not_equal

    source
    fn AttrsSpan::not_equal(x : AttrsSpan, y : AttrsSpan) -> Bool

    BidiInfo

    source
    pub struct BidiInfo {
      text : String
      original_classes : Array[
    BidiClass    ]
      levels : Array[Int]
      paragraphs : Array[ParagraphInfo]
    }

    BiDi analysis result aligned with unicode-bidi / cosmic-text flow.

    original_classes and levels are indexed by UTF-16 code-unit offset.

    BidiInfo::adjusted_levels

    source
    fn BidiInfo::adjusted_levels(self : BidiInfo) -> Array[Int]

    BidiInfo::levels

    source
    fn BidiInfo::levels(self : BidiInfo) -> Array[Int]

    BidiInfo::new

    source
    fn BidiInfo::new(text : String) -> BidiInfo

    BidiInfo::new_with_para_level

    source
    fn BidiInfo::new_with_para_level(text : String, default_para_level : Int?) -> BidiInfo

    BidiInfo::paragraphs

    source
    fn BidiInfo::paragraphs(self : BidiInfo) -> Array[ParagraphInfo]

    BidiInfo::rtl

    source
    fn BidiInfo::rtl(self : BidiInfo) -> Bool

    BidiInfo::text

    source
    fn BidiInfo::text(self : BidiInfo) -> String

    BidiParagraphs

    source
    pub struct BidiParagraphs {
      text : String
      ranges : Array[(Int, Int)]
      cursor : Int
      pos : Int
    }

    An iterator over paragraphs in input text.

    Behavior follows unicode-bidi paragraph ranges: paragraph separator characters (BidiClass::B) remain in the paragraph range but are trimmed from the returned paragraph text.

    BidiParagraphs::iter

    source
    fn BidiParagraphs::iter(self : BidiParagraphs) -> Iter[String]

    BidiParagraphs::new

    source
    fn BidiParagraphs::new(text : String) -> BidiParagraphs

    BidiParagraphs::next

    source
    fn BidiParagraphs::next(self : BidiParagraphs) -> (BidiParagraphs, String)?

    Returns (next, paragraph_text) if any.

    Buffer

    source
    pub struct Buffer {
      lines : Array[BufferLine]
      metrics : Metrics
      width_opt : Float?
      height_opt : Float?
      scroll : Scroll
      redraw : Bool
      wrap : Wrap
      ellipsize : Ellipsize
      monospace_width : Float?
      tab_width : Int
      hinting : Hinting
      dirty_relayout : Bool
      dirty_tab_shape : Bool
      dirty_text_set : Bool
      dirty_scroll : Bool
    }

    Minimal Buffer port scaffold from cosmic-text/src/buffer.rs.

    Buffer::cursor_motion

    source
    fn Buffer::cursor_motion(self : Buffer, cursor : Cursor, cursor_x_opt : Int?, motion : Motion) -> (Cursor, Int?)?

    Cursor motion based on current layout runs.

    This uses visual lines from layout_runs() for vertical movement.

    Buffer::draw

    source
    fn Buffer::draw(self : Buffer, font_system : FontSystem, swash_cache : SwashCache, text_color : Color, f : (Int, Int, UInt, UInt, Color) -> Unit) -> (Buffer, SwashCache)

    Draw the buffer with a font system and swash cache.

    This is a naming-aligned convenience wrapper (matches upstream's Buffer::draw intent).

    Buffer::draw_with_font_system

    source
    fn Buffer::draw_with_font_system(self : Buffer, font_system : FontSystem, swash_cache : SwashCache, text_color : Color, f : (Int, Int, UInt, UInt, Color) -> Unit) -> (Buffer, SwashCache)

    Draw the buffer using a SwashCache.

    For compatibility with upstream's legacy renderer helper, the callback is called per pixel (w = 1, h = 1).

    Buffer::ellipsize

    source
    fn Buffer::ellipsize(self : Buffer) -> Ellipsize

    Buffer::hinting

    source
    fn Buffer::hinting(self : Buffer) -> Hinting

    Buffer::hit

    source
    fn Buffer::hit(self : Buffer, x : Float, y : Float) -> Cursor?

    Hit-testing: map a physical x/y position to a cursor.

    Buffer::layout_all

    source
    fn Buffer::layout_all(self : Buffer) -> Buffer

    Layout all lines using the built-in shaping (no font system).

    Buffer::layout_all_with_font_system

    source
    fn Buffer::layout_all_with_font_system(self : Buffer, font_system : FontSystem) -> Buffer

    Layout all lines using a provided FontSystem (best-effort).

    Buffer::layout_cursor

    source
    fn Buffer::layout_cursor(self : Buffer, font_system : FontSystem, cursor : Cursor) -> LayoutCursor?

    Buffer::layout_runs

    source
    fn Buffer::layout_runs(self : Buffer) -> Iter[LayoutRun]

    Buffer::line_layout

    source
    fn Buffer::line_layout(self : Buffer, font_system : FontSystem, line_i : Int) -> Array[LayoutLine]?

    Buffer::line_shape

    source
    fn Buffer::line_shape(self : Buffer, font_system : FontSystem, line_i : Int) -> ShapeLine?

    Buffer::lines

    source
    fn Buffer::lines(self : Buffer) -> Array[BufferLine]

    Buffer::metrics

    source
    fn Buffer::metrics(self : Buffer) -> Metrics

    Buffer::new

    source
    fn Buffer::new(metrics : Metrics) -> Buffer

    Buffer::new_empty

    source
    fn Buffer::new_empty(metrics : Metrics) -> Buffer

    Create an empty Buffer with the provided Metrics.

    Panics (fails) if metrics.line_height is zero (aligned with upstream).

    Buffer::redraw

    source
    fn Buffer::redraw(self : Buffer) -> Bool

    Buffer::scroll

    source
    fn Buffer::scroll(self : Buffer) -> Scroll

    Buffer::set_ellipsize

    source
    fn Buffer::set_ellipsize(self : Buffer, ellipsize : Ellipsize) -> Buffer

    Buffer::set_hinting

    source
    fn Buffer::set_hinting(self : Buffer, hinting : Hinting) -> Buffer

    Buffer::set_metrics

    source
    fn Buffer::set_metrics(self : Buffer, metrics : Metrics) -> Buffer

    Buffer::set_metrics_and_size

    source
    fn Buffer::set_metrics_and_size(self : Buffer, metrics : Metrics, width_opt : Float?, height_opt : Float?) -> Buffer

    Buffer::set_monospace_width

    source
    fn Buffer::set_monospace_width(self : Buffer, monospace_width : Float?) -> Buffer

    Buffer::set_redraw

    source
    fn Buffer::set_redraw(self : Buffer, redraw : Bool) -> Buffer

    Buffer::set_rich_text

    source
    fn Buffer::set_rich_text(self : Buffer, spans : Array[(String, Attrs)], default_attrs : Attrs, shaping : Shaping, alignment : Align?) -> Buffer

    Set rich text of buffer using styled spans (pairs of text and attrs).

    This mirrors cosmic-text's Buffer::set_rich_text behavior:
    • Concatenates spans into one string.
    • Splits into paragraphs using BidiParagraphs.
    • Builds per-line AttrsList spans relative to each line.
    • Uses LineEnding::default() for all lines.

    Buffer::set_scroll

    source
    fn Buffer::set_scroll(self : Buffer, scroll : Scroll) -> Buffer

    Buffer::set_size

    source
    fn Buffer::set_size(self : Buffer, width_opt : Float?, height_opt : Float?) -> Buffer

    Buffer::set_tab_width

    source
    fn Buffer::set_tab_width(self : Buffer, tab_width : Int) -> Buffer

    Buffer::set_text

    source
    fn Buffer::set_text(self : Buffer, text : String, attrs_list : AttrsList, shaping : Shaping) -> Buffer

    Set full text of buffer.

    NOTE: attrs_list is copied per line (upstream spans are per line).

    Buffer::set_wrap

    source
    fn Buffer::set_wrap(self : Buffer, wrap : Wrap) -> Buffer

    Buffer::shape_all_with_font_system

    source
    fn Buffer::shape_all_with_font_system(self : Buffer, font_system : FontSystem) -> Buffer

    Shape all lines using a provided FontSystem (best-effort).

    This is a coarse-grained helper for clients that do not want to manage per-line shaping manually yet.

    Buffer::shape_until_cursor

    source
    fn Buffer::shape_until_cursor(self : Buffer, font_system : FontSystem, cursor : Cursor, prune : Bool) -> Buffer

    Buffer::shape_until_scroll

    source
    fn Buffer::shape_until_scroll(self : Buffer, font_system : FontSystem, prune : Bool) -> Buffer

    Buffer::size

    source
    fn Buffer::size(self : Buffer) -> (Float?, Float?)

    Buffer::wrap

    source
    fn Buffer::wrap(self : Buffer) -> Wrap

    BufferLine

    source
    pub struct BufferLine {
      text : String
      ending : LineEnding
      attrs_list : AttrsList
      align : Align?
      shape_opt : Cached[ShapeLine]
      layout_opt : Cached[Array[LayoutLine]]
      shaping : Shaping
      metadata : Int?
    }

    BufferLine::align

    source
    fn BufferLine::align(self : BufferLine) -> Align?

    BufferLine::append

    source
    fn BufferLine::append(self : BufferLine, other : BufferLine) -> BufferLine

    Append other to self (consumes both, returns updated line).

    BufferLine::attrs_list

    source
    fn BufferLine::attrs_list(self : BufferLine) -> AttrsList

    BufferLine::ending

    source
    fn BufferLine::ending(self : BufferLine) -> LineEnding

    BufferLine::into_text

    source
    fn BufferLine::into_text(self : BufferLine) -> String

    BufferLine::layout

    source
    fn BufferLine::layout(self : BufferLine, font_size : Float, width_opt : Float?, wrap : Wrap, ellipsize : Ellipsize, match_mono_width : Float?, tab_width : Int, hinting : Hinting) -> BufferLine

    BufferLine::layout_opt

    source
    fn BufferLine::layout_opt(self : BufferLine) -> Array[LayoutLine]?

    BufferLine::layout_runs

    source
    fn BufferLine::layout_runs(self : BufferLine, height_opt : Float?, line_height : Float) -> Iter[LayoutRun]

    BufferLine::layout_with_font_system

    source
    fn BufferLine::layout_with_font_system(self : BufferLine, font_system : FontSystem, font_size : Float, width_opt : Float?, wrap : Wrap, ellipsize : Ellipsize, match_mono_width : Float?, tab_width : Int, hinting : Hinting) -> BufferLine

    Layout using a provided FontSystem (best-effort).

    BufferLine::metadata

    source
    fn BufferLine::metadata(self : BufferLine) -> Int?

    BufferLine::new

    source
    fn BufferLine::new(text : String, ending : LineEnding, attrs_list : AttrsList, shaping : Shaping) -> BufferLine

    BufferLine::reset

    source
    fn BufferLine::reset(self : BufferLine) -> BufferLine

    BufferLine::reset_layout

    source
    fn BufferLine::reset_layout(self : BufferLine) -> BufferLine

    BufferLine::reset_shaping

    source
    fn BufferLine::reset_shaping(self : BufferLine) -> BufferLine

    BufferLine::set_align

    source
    fn BufferLine::set_align(self : BufferLine, align : Align?) -> (BufferLine, Bool)

    BufferLine::set_attrs_list

    source
    fn BufferLine::set_attrs_list(self : BufferLine, attrs_list : AttrsList) -> (BufferLine, Bool)

    BufferLine::set_ending

    source
    fn BufferLine::set_ending(self : BufferLine, ending : LineEnding) -> BufferLine

    BufferLine::set_metadata

    source
    fn BufferLine::set_metadata(self : BufferLine, metadata : Int) -> BufferLine

    BufferLine::set_text

    source
    fn BufferLine::set_text(self : BufferLine, text : String, ending : LineEnding, attrs_list : AttrsList) -> (BufferLine, Bool)

    BufferLine::shape

    source
    fn BufferLine::shape(self : BufferLine, tab_width : Int) -> BufferLine

    BufferLine::shape_opt

    source
    fn BufferLine::shape_opt(self : BufferLine) -> ShapeLine?

    BufferLine::shape_with_font_system

    source
    fn BufferLine::shape_with_font_system(self : BufferLine, font_system : FontSystem, tab_width : Int) -> BufferLine

    Shape using a provided FontSystem (best-effort).

    This is an incremental step towards upstream cosmic-text: we keep the same cache behavior, but build glyph advances from the font.

    BufferLine::split_off

    source
    fn BufferLine::split_off(self : BufferLine, index : Int) -> (BufferLine, BufferLine)

    Split off new line at index. Returns (left, right).

    BufferLine::text

    source
    fn BufferLine::text(self : BufferLine) -> String

    CacheKey

    source
    pub struct CacheKey {
      font_id : Int
      glyph_id : Int
      font_size_bits : UInt
      x_bin : SubpixelBin
      y_bin : SubpixelBin
      font_weight : Int
      flags : UInt
    }

    Key for building a glyph cache.

    NOTE: we keep this as a plain struct (instead of bitfields) to match the conceptual model of cosmic-text.
    impl Eq for CacheKey
    impl Hash for CacheKey
    impl Show for CacheKey

    CacheKey::equal

    source
    fn CacheKey::equal(self : CacheKey, other : CacheKey) -> Bool

    CacheKey::has_disable_hinting

    source
    fn CacheKey::has_disable_hinting(self : CacheKey) -> Bool

    CacheKey::has_fake_italic

    source
    fn CacheKey::has_fake_italic(self : CacheKey) -> Bool

    CacheKey::has_pixel_font

    source
    fn CacheKey::has_pixel_font(self : CacheKey) -> Bool

    CacheKey::hash

    source
    fn CacheKey::hash(self : CacheKey) -> Int

    CacheKey::hash_combine

    source
    fn CacheKey::hash_combine(self : CacheKey, hasher : Hasher) -> Unit

    CacheKey::new

    source
    fn CacheKey::new(font_id : Int, glyph_id : Int, font_size : Float, pos : (Float, Float), font_weight : Int, flags : UInt) -> (CacheKey, Int, Int)

    CacheKey::not_equal

    source
    fn CacheKey::not_equal(x : CacheKey, y : CacheKey) -> Bool

    CacheKey::output

    source
    fn CacheKey::output(self : CacheKey, logger : &Logger) -> Unit

    CacheKey::to_string

    source
    fn CacheKey::to_string(self : CacheKey) -> String

    CacheKey::x_bin

    source
    fn CacheKey::x_bin(self : CacheKey) -> SubpixelBin

    CacheKey::y_bin

    source
    fn CacheKey::y_bin(self : CacheKey) -> SubpixelBin

    CacheMetrics

    source
    pub struct CacheMetrics {
      font_size_bits : UInt
      line_height_bits : UInt
    }

    Metrics, but implementing Eq and Hash using u32 representation of f32.

    This mirrors upstream cosmic-text CacheMetrics, enabling per-span metrics overrides (font size / line height) while keeping Attrs hashable.
    impl Eq for CacheMetrics

    CacheMetrics::equal

    source
    fn CacheMetrics::equal(self : CacheMetrics, other : CacheMetrics) -> Bool

    CacheMetrics::font_size

    source
    fn CacheMetrics::font_size(self : CacheMetrics) -> Float

    CacheMetrics::from_metrics

    source
    fn CacheMetrics::from_metrics(metrics : Metrics) -> CacheMetrics

    CacheMetrics::hash

    source
    fn CacheMetrics::hash(self : CacheMetrics) -> Int

    CacheMetrics::hash_combine

    source
    fn CacheMetrics::hash_combine(self : CacheMetrics, hasher : Hasher) -> Unit

    CacheMetrics::line_height

    source
    fn CacheMetrics::line_height(self : CacheMetrics) -> Float

    CacheMetrics::not_equal

    source
    fn CacheMetrics::not_equal(x : CacheMetrics, y : CacheMetrics) -> Bool

    CacheMetrics::output

    source
    fn CacheMetrics::output(self : CacheMetrics, logger : &Logger) -> Unit

    CacheMetrics::to_metrics

    source
    fn CacheMetrics::to_metrics(self : CacheMetrics) -> Metrics

    CacheMetrics::to_string

    source
    fn CacheMetrics::to_string(self : CacheMetrics) -> String

    Cached

    source
    pub(all) enum Cached[T] {
      Empty
      Unused(T)
      Used(T)
    }

    Ported from cosmic-text/src/cached.rs (cosmic-text is dual-licensed MIT OR Apache-2.0).

    MoonBit version is implemented in a functional style (returns updated Cached), but keeps the same state machine semantics as the upstream &mut self API.

    Cached::get

    source
    fn[T] Cached::get(self : Cached[T]) -> T?

    Cached::is_unused

    source
    fn[T] Cached::is_unused(self : Cached[T]) -> Bool

    Cached::is_used

    source
    fn[T] Cached::is_used(self : Cached[T]) -> Bool

    Cached::set_unused

    source
    fn[T] Cached::set_unused(self : Cached[T]) -> Cached[T]

    Cached::set_used

    source
    fn[T] Cached::set_used(_self : Cached[T], val : T) -> Cached[T]

    Cached::take_unused

    source
    fn[T] Cached::take_unused(self : Cached[T]) -> (Cached[T], T?)

    Cached::take_used

    source
    fn[T] Cached::take_used(self : Cached[T]) -> (Cached[T], T?)

    CachedLine

    source
    pub struct CachedLine {
      text : String
      state_in : LineState
      state_out : LineState
      spans : Array[TokenSpan]
    }

    Change

    source
    pub(all) struct Change {
      items : Array[ChangeItem]
    }

    A set of change items grouped into one logical change.

    Change::default

    source
    fn Change::default() -> Change

    Change::reverse

    source
    fn Change::reverse(self : Change) -> Change

    ChangeItem

    source
    pub(all) struct ChangeItem {
      start : Cursor
      end : Cursor
      text : String
      insert : Bool
    }

    A unique change to an editor.

    ChangeItem::reverse

    source
    fn ChangeItem::reverse(self : ChangeItem) -> ChangeItem

    Color

    source
    pub struct Color {
      value : UInt
    }

    Text color (ARGB packed, aligned with upstream).
    impl Eq for Color
    impl Hash for Color

    Color::a

    source
    fn Color::a(self : Color) -> Byte

    Color::as_rgba

    source
    fn Color::as_rgba(self : Color) -> (Byte, Byte, Byte, Byte)

    Color::b

    source
    fn Color::b(self : Color) -> Byte

    Color::equal

    source
    fn Color::equal(self : Color, other : Color) -> Bool

    Color::g

    source
    fn Color::g(self : Color) -> Byte

    Color::hash

    source
    fn Color::hash(self : Color) -> Int

    Color::hash_combine

    source
    fn Color::hash_combine(self : Color, hasher : Hasher) -> Unit

    Color::not_equal

    source
    fn Color::not_equal(x : Color, y : Color) -> Bool

    Color::r

    source
    fn Color::r(self : Color) -> Byte

    Color::rgb

    source
    fn Color::rgb(r : Byte, g : Byte, b : Byte) -> Color

    Color::rgba

    source
    fn Color::rgba(r : Byte, g : Byte, b : Byte, a : Byte) -> Color

    Cursor

    source
    pub struct Cursor {
      line : Int
      index : Int
      affinity : Affinity
    }

    Current cursor location
    impl Eq for Cursor

    Cursor::equal

    source
    fn Cursor::equal(self : Cursor, other : Cursor) -> Bool

    Cursor::new

    source
    fn Cursor::new(line : Int, index : Int) -> Cursor

    Cursor::new_with_affinity

    source
    fn Cursor::new_with_affinity(line : Int, index : Int, affinity : Affinity) -> Cursor

    Cursor::not_equal

    source
    fn Cursor::not_equal(x : Cursor, y : Cursor) -> Bool

    DecorationMetrics

    source
    pub struct DecorationMetrics {
      offset : Float
      thickness : Float
    }

    DecorationMetrics::equal

    source
    fn DecorationMetrics::equal(self : DecorationMetrics, other : DecorationMetrics) -> Bool

    DecorationMetrics::hash

    source
    fn DecorationMetrics::hash(self : DecorationMetrics) -> Int

    DecorationMetrics::hash_combine

    source
    fn DecorationMetrics::hash_combine(self : DecorationMetrics, hasher : Hasher) -> Unit

    DecorationMetrics::new

    source
    fn DecorationMetrics::new(offset : Float, thickness : Float) -> DecorationMetrics

    DecorationMetrics::not_equal

    source
    fn DecorationMetrics::not_equal(x : DecorationMetrics, y : DecorationMetrics) -> Bool

    DecorationSpan

    source
    pub struct DecorationSpan {
      glyph_start : Int
      glyph_end : Int
      data : GlyphDecorationData
      color_opt : Color?
      font_size : Float
    }

    A span of consecutive glyphs sharing the same text decoration.

    Editor

    source
    pub struct Editor {
      buffer : Buffer
      cursor : Cursor
      cursor_x_opt : Int?
      selection : Selection
      cursor_moved : Bool
      auto_indent : Bool
      change_opt : Change?
    }

    impl Edit for Editor

    Editor::action

    source
    fn Editor::action(self : Editor, action : Action) -> Editor

    Perform an action on the editor.

    Editor::apply_change

    source
    fn Editor::apply_change(self : Editor, change : Change) -> (Editor, Bool)

    Editor::auto_indent

    source
    fn Editor::auto_indent(self : Editor) -> Bool

    Editor::buffer

    source
    fn Editor::buffer(self : Editor) -> Buffer

    Editor::copy_selection

    source
    fn Editor::copy_selection(self : Editor) -> String?

    Editor::cursor

    source
    fn Editor::cursor(self : Editor) -> Cursor

    Editor::cursor_position

    source
    fn Editor::cursor_position(self : Editor) -> (Int, Int)?

    Get X and Y position of the top-left corner of the cursor.

    Editor::delete_range

    source
    fn Editor::delete_range(self : Editor, start : Cursor, end : Cursor) -> Editor

    Delete text starting at start cursor and ending at end cursor.

    Editor::delete_selection

    source
    fn Editor::delete_selection(self : Editor) -> (Editor, Bool)

    Editor::editor

    source
    fn Editor::editor(self : Editor) -> Editor

    Editor::finish_change

    source
    fn Editor::finish_change(self : Editor) -> (Editor, Change?)

    Editor::insert_at

    source
    fn Editor::insert_at(self : Editor, cursor : Cursor, data : String, attrs_list_opt : AttrsList?) -> (Editor, Cursor)

    Insert data at the specified cursor, returning the updated editor and the new cursor.

    NOTE: attrs_list_opt is applied to inserted text; when None, we use the previous character's attrs as defaults.

    Editor::insert_string

    source
    fn Editor::insert_string(self : Editor, data : String, attrs_list_opt : AttrsList?) -> Editor

    Insert string at current cursor, replacing selection if present.

    Editor::new

    source
    fn Editor::new(buffer : Buffer) -> Editor

    Editor::render

    source
    fn[R : Renderer] Editor::render(self : Editor, renderer : R, text_color : Color, cursor_color : Color, selection_color : Color, selected_text_color : Color) -> Unit

    Render editor contents with selection and cursor highlights.

    Editor::selection

    source
    fn Editor::selection(self : Editor) -> Selection

    Editor::selection_bounds

    source
    fn Editor::selection_bounds(self : Editor) -> (Cursor, Cursor)?

    Get the bounds of the current selection (line/word selection is expanded).

    Editor::set_auto_indent

    source
    fn Editor::set_auto_indent(self : Editor, auto_indent : Bool) -> Editor

    Editor::set_cursor

    source
    fn Editor::set_cursor(self : Editor, cursor : Cursor) -> Editor

    Editor::set_editor

    source
    fn Editor::set_editor(_self : Editor, editor : Editor) -> Editor

    Editor::set_selection

    source
    fn Editor::set_selection(self : Editor, selection : Selection) -> Editor

    Editor::set_tab_width

    source
    fn Editor::set_tab_width(self : Editor, tab_width : Int) -> Editor

    Set tab width in spaces. A value of 0 is ignored (matches upstream).

    Editor::start_change

    source
    fn Editor::start_change(self : Editor) -> Editor

    Editor::tab_width

    source
    fn Editor::tab_width(self : Editor) -> Int

    Ellipsize

    source
    pub(all) enum Ellipsize {
      None
      Start(EllipsizeHeightLimit)
      Middle(EllipsizeHeightLimit)
      End(EllipsizeHeightLimit)
    }

    EllipsizeHeightLimit

    source
    pub(all) enum EllipsizeHeightLimit {
      Lines(Int)
      Height(Float)
    }

    FallbackMissingKind

    source
    pub(all) enum FallbackMissingKind {
      Exhausted
      PresetFallback
      ScriptFallback
    }

    FallbackProfile

    source
    pub(all) enum FallbackProfile {
      Unix
      MacOS
      Windows
      Other
    }

    FallbackProfile::equal

    source
    fn FallbackProfile::equal(self : FallbackProfile, other : FallbackProfile) -> Bool

    FallbackProfile::not_equal

    source
    fn FallbackProfile::not_equal(x : FallbackProfile, y : FallbackProfile) -> Bool

    Family

    source
    pub(all) enum Family {
      Name(String)
      Serif
      SansSerif
      Cursive
      Fantasy
      Monospace
      SystemUi
      UiSerif
      UiSansSerif
      UiMonospace
      UiRounded
      Emoji
      Math
      FangSong
    }

    Font family selector.

    This mirrors the generic families exposed by cosmic-text and extends them with the CSS/Bevy generic families required by modern text stacks.
    impl Eq for Family
    impl Hash for Family
    impl Show for Family

    Family::equal

    source
    fn Family::equal(self : Family, other : Family) -> Bool

    Family::hash

    source
    fn Family::hash(self : Family) -> Int

    Family::hash_combine

    source
    fn Family::hash_combine(self : Family, hasher : Hasher) -> Unit

    Family::not_equal

    source
    fn Family::not_equal(x : Family, y : Family) -> Bool

    Family::output

    source
    fn Family::output(self : Family, logger : &Logger) -> Unit

    Family::to_string

    source
    fn Family::to_string(self : Family) -> String

    Feature

    source
    pub struct Feature {
      tag : FeatureTag
      value : UInt
    }

    impl Eq for Feature
    impl Hash for Feature

    Feature::equal

    source
    fn Feature::equal(self : Feature, other : Feature) -> Bool

    Feature::hash

    source
    fn Feature::hash(self : Feature) -> Int

    Feature::hash_combine

    source
    fn Feature::hash_combine(self : Feature, hasher : Hasher) -> Unit

    Feature::new

    source
    fn Feature::new(tag : FeatureTag, value : UInt) -> Feature

    Feature::not_equal

    source
    fn Feature::not_equal(x : Feature, y : Feature) -> Bool

    Feature::tag

    source
    fn Feature::tag(self : Feature) -> FeatureTag

    Feature::value

    source
    fn Feature::value(self : Feature) -> UInt

    FeatureTag

    source
    pub struct FeatureTag {
      value : UInt
    }

    impl Eq for FeatureTag
    impl Hash for FeatureTag

    FeatureTag::as_tag

    source
    fn FeatureTag::as_tag(self : FeatureTag) -> UInt

    FeatureTag::equal

    source
    fn FeatureTag::equal(self : FeatureTag, other : FeatureTag) -> Bool

    FeatureTag::from_tag

    source
    fn FeatureTag::from_tag(tag : UInt) -> FeatureTag

    FeatureTag::hash

    source
    fn FeatureTag::hash(self : FeatureTag) -> Int

    FeatureTag::hash_combine

    source
    fn FeatureTag::hash_combine(self : FeatureTag, hasher : Hasher) -> Unit

    FeatureTag::new

    source
    fn FeatureTag::new(tag : String) -> FeatureTag

    FeatureTag::not_equal

    source
    fn FeatureTag::not_equal(x : FeatureTag, y : FeatureTag) -> Bool

    FontCachedCodepointSupportInfo

    source
    type FontCachedCodepointSupportInfo

    FontEntry

    source
    pub struct FontEntry {
      id : Int
      family_name : String
      postscript_name : String
      source_data : Bytes
      source_index : Int
      font : 
    FontRef
      charmap_proxy : 
    CharmapProxy
      attributes : 
    Attributes
      is_monospace : Bool
      not_emoji : Bool
    }

    Minimal font system wrapper for the MoonBit cosmic-text port.

    Upstream cosmic-text uses fontdb for font discovery. In this MoonBit port we start with an in-memory font list backed by moon_swash.

    FontEntry::attributes

    source

    FontEntry::charmap_proxy

    source

    FontEntry::family_name

    source
    fn FontEntry::family_name(self : FontEntry) -> String

    FontEntry::font

    source

    FontEntry::id

    source
    fn FontEntry::id(self : FontEntry) -> Int

    FontEntry::is_monospace

    source
    fn FontEntry::is_monospace(self : FontEntry) -> Bool

    FontEntry::not_emoji

    source
    fn FontEntry::not_emoji(self : FontEntry) -> Bool

    FontEntry::postscript_name

    source
    fn FontEntry::postscript_name(self : FontEntry) -> String

    FontEntry::source_data

    source
    fn FontEntry::source_data(self : FontEntry) -> Bytes

    FontEntry::source_index

    source
    fn FontEntry::source_index(self : FontEntry) -> Int

    FontFeatures

    source
    pub struct FontFeatures {
      features : Array[Feature]
    }

    impl Eq for FontFeatures

    FontFeatures::disable

    source
    fn FontFeatures::disable(self : FontFeatures, tag : FeatureTag) -> FontFeatures

    FontFeatures::enable

    source
    fn FontFeatures::enable(self : FontFeatures, tag : FeatureTag) -> FontFeatures

    FontFeatures::equal

    source
    fn FontFeatures::equal(self : FontFeatures, other : FontFeatures) -> Bool

    FontFeatures::features

    source
    fn FontFeatures::features(self : FontFeatures) -> Array[Feature]

    FontFeatures::hash

    source
    fn FontFeatures::hash(self : FontFeatures) -> Int

    FontFeatures::hash_combine

    source
    fn FontFeatures::hash_combine(self : FontFeatures, hasher : Hasher) -> Unit

    FontFeatures::new

    source

    FontFeatures::not_equal

    source
    fn FontFeatures::not_equal(x : FontFeatures, y : FontFeatures) -> Bool

    FontFeatures::set

    source
    fn FontFeatures::set(self : FontFeatures, tag : FeatureTag, value : UInt) -> FontFeatures

    FontMatchAttrs

    source
    pub struct FontMatchAttrs {
      family : Family
      weight : Weight
      stretch : 
    Stretch
      style : 
    Style
    }

    FontMatchAttrs::equal

    source
    fn FontMatchAttrs::equal(self : FontMatchAttrs, other : FontMatchAttrs) -> Bool

    FontMatchAttrs::hash

    source
    fn FontMatchAttrs::hash(self : FontMatchAttrs) -> Int

    FontMatchAttrs::hash_combine

    source
    fn FontMatchAttrs::hash_combine(self : FontMatchAttrs, hasher : Hasher) -> Unit

    FontMatchAttrs::not_equal

    source
    fn FontMatchAttrs::not_equal(x : FontMatchAttrs, y : FontMatchAttrs) -> Bool

    FontSystem

    source
    pub struct FontSystem {
      locale : String
      fonts : Array[FontEntry]
      font_matches_cache : 
    HashMap    [FontMatchAttrs, Array[Int]]
      codepoint_support_cache : 
    HashMap    [Int, FontCachedCodepointSupportInfo]
      hb_font_cache : 
    HashMap    [Int, 
    Font    ]
      hb_shape_buffer : 
    Buffer
      shape_run_cache : ShapeRunCache
      // private fields
    }

    FontSystem::clear_fallback_profile

    source
    fn FontSystem::clear_fallback_profile(self : FontSystem) -> FontSystem

    FontSystem::clear_fallback_warning_handler

    source
    fn FontSystem::clear_fallback_warning_handler(self : FontSystem) -> FontSystem

    FontSystem::count_supported_codepoints

    source
    fn FontSystem::count_supported_codepoints(self : FontSystem, font_id : Int, codepoints : Array[UInt]) -> Int

    FontSystem::font_matches

    source
    fn FontSystem::font_matches(self : FontSystem, attrs : Attrs) -> Array[Int]

    Get ordered font match candidates for attrs (cached).

    FontSystem::font_matches_for_script

    source
    fn FontSystem::font_matches_for_script(self : FontSystem, attrs : Attrs, script : 
    Script    ) -> Array[Int]

    FontSystem::font_matches_for_scripts

    source
    fn FontSystem::font_matches_for_scripts(self : FontSystem, attrs : Attrs, scripts : Array[
    Script    ]) -> Array[Int]

    FontSystem::font_matches_for_scripts_with_codepoints

    source
    fn FontSystem::font_matches_for_scripts_with_codepoints(self : FontSystem, attrs : Attrs, scripts : Array[
    Script    ], codepoints : Array[UInt]) -> Array[Int]

    FontSystem::fonts

    source
    fn FontSystem::fonts(self : FontSystem) -> Array[FontEntry]

    FontSystem::get_font

    source
    fn FontSystem::get_font(self : FontSystem, font_id : Int) -> 
    FontRef    ?

    FontSystem::get_font_entry

    source
    fn FontSystem::get_font_entry(self : FontSystem, font_id : Int) -> FontEntry?

    Get the full FontEntry for a font_id (useful for downstream rasterization with TTC collections).

    FontSystem::load_font_data

    source
    fn FontSystem::load_font_data(self : FontSystem, data : Bytes) -> FontSystem

    Load font data (TTF/OTF/TTC bytes) into the system.

    If the bytes do not parse as a font/collection, this is a no-op.

    FontSystem::locale

    source
    fn FontSystem::locale(self : FontSystem) -> String

    FontSystem::new

    source
    fn FontSystem::new() -> FontSystem

    FontSystem::new_with_locale

    source
    fn FontSystem::new_with_locale(locale : String) -> FontSystem

    FontSystem::resolve

    source
    fn FontSystem::resolve(self : FontSystem, attrs : Attrs) -> Int?

    Resolve a font ID for the given attrs (best-effort).

    FontSystem::resolve_for_codepoint

    source
    fn FontSystem::resolve_for_codepoint(self : FontSystem, attrs : Attrs, codepoint : UInt) -> Int?

    Resolve a font ID for a specific codepoint (best-effort).

    This prefers the requested family (when present) and then minimizes weight difference, falling back to any loaded font that supports the codepoint.

    FontSystem::select_family

    source
    fn FontSystem::select_family(self : FontSystem, family : Family) -> Int?

    Find a font ID that matches the family selector (best-effort).

    FontSystem::set_fallback_profile

    source
    fn FontSystem::set_fallback_profile(self : FontSystem, profile : FallbackProfile) -> FontSystem

    FontSystem::set_fallback_warning_handler

    source
    fn FontSystem::set_fallback_warning_handler(self : FontSystem, handler : (String) -> Unit) -> FontSystem

    GlyphDecorationData

    source
    pub struct GlyphDecorationData {
      text_decoration : TextDecoration
      underline_metrics : DecorationMetrics
      strikethrough_metrics : DecorationMetrics
      ascent : Float
    }

    GlyphDecorationData::equal

    source

    GlyphDecorationData::hash

    source

    GlyphDecorationData::hash_combine

    source
    fn GlyphDecorationData::hash_combine(self : GlyphDecorationData, hasher : Hasher) -> Unit

    GlyphDecorationData::not_equal

    source

    Hinting

    source
    pub(all) enum Hinting {
      Disabled
      Enabled
    }

    Metrics hinting strategy

    Justify

    source
    pub(all) enum Justify {
      Left
      Right
      Center
      Justified
      Start
      End
    }

    LayoutCursor

    source
    pub struct LayoutCursor {
      line : Int
      layout : Int
      glyph : Int
    }

    The position of a cursor within a Buffer.
    impl Eq for LayoutCursor

    LayoutCursor::equal

    source
    fn LayoutCursor::equal(self : LayoutCursor, other : LayoutCursor) -> Bool

    LayoutCursor::new

    source
    fn LayoutCursor::new(line : Int, layout : Int, glyph : Int) -> LayoutCursor

    LayoutCursor::not_equal

    source
    fn LayoutCursor::not_equal(x : LayoutCursor, y : LayoutCursor) -> Bool

    LayoutGlyph

    source
    pub struct LayoutGlyph {
      start : Int
      end : Int
      font_size : Float
      font_id : Int
      font_weight : Int
      glyph_id : Int
      x : Float
      y : Float
      w : Float
      level : Int
      line_height_opt : Float?
      x_offset : Float
      y_offset : Float
      color_opt : Color?
      metadata : Int
      cache_key_flags : UInt
    }

    A laid out glyph.

    LayoutGlyph::new

    source
    fn LayoutGlyph::new(start : Int, end : Int, font_size : Float, font_id : Int, font_weight : Int, glyph_id : Int, x : Float, y : Float, w : Float, metadata : Int) -> LayoutGlyph

    Convenience constructor (fills optional fields with defaults).

    LayoutGlyph::physical

    source
    fn LayoutGlyph::physical(self : LayoutGlyph, offset : (Float, Float), scale : Float) -> PhysicalGlyph

    LayoutLine

    source
    pub struct LayoutLine {
      start : Int
      end : Int
      w : Float
      max_ascent : Float
      max_descent : Float
      line_height_opt : Float?
      glyphs : Array[LayoutGlyph]
      decorations : Array[DecorationSpan]
    }

    A line of laid out glyphs.

    LayoutRun

    source
    pub struct LayoutRun {
      line_i : Int
      line_y : Float
      line_top : Float
      line_height : Float
      text : String
      rtl : Bool
      glyphs : Array[LayoutGlyph]
      decorations : Array[DecorationSpan]
      line_w : Float
    }

    A line of visible text for rendering.

    LayoutRun::highlight

    source
    fn LayoutRun::highlight(self : LayoutRun, cursor_start : Cursor, cursor_end : Cursor) -> (Float, Float)?

    Return highlighted x-span (x_left, width) intersecting this run.

    LegacyRenderer

    source
    pub struct LegacyRenderer {
      font_system : FontSystem
      cache : SwashCache
      callback : (Int, Int, UInt, UInt, Color) -> Unit
    }

    Helper to migrate from the legacy callback-based renderer.

    This matches upstream LegacyRenderer: rectangles are forwarded to the callback, and glyphs are rasterized through SwashCache::with_pixels.

    LegacyRenderer::glyph

    source
    fn LegacyRenderer::glyph(self : LegacyRenderer, physical_glyph : PhysicalGlyph, color : Color) -> Unit

    LegacyRenderer::new

    source
    fn LegacyRenderer::new(font_system : FontSystem, cache : SwashCache, callback : (Int, Int, UInt, UInt, Color) -> Unit) -> LegacyRenderer

    LegacyRenderer::rectangle

    source
    fn LegacyRenderer::rectangle(self : LegacyRenderer, x : Int, y : Int, w : UInt, h : UInt, color : Color) -> Unit

    LetterSpacing

    source
    pub struct LetterSpacing {
      bits : UInt
    }

    impl Eq for LetterSpacing

    LetterSpacing::equal

    source
    fn LetterSpacing::equal(self : LetterSpacing, other : LetterSpacing) -> Bool

    LetterSpacing::hash

    source
    fn LetterSpacing::hash(self : LetterSpacing) -> Int

    LetterSpacing::hash_combine

    source
    fn LetterSpacing::hash_combine(self : LetterSpacing, hasher : Hasher) -> Unit

    LetterSpacing::new

    source
    fn LetterSpacing::new(value : Float) -> LetterSpacing

    LetterSpacing::not_equal

    source
    fn LetterSpacing::not_equal(x : LetterSpacing, y : LetterSpacing) -> Bool

    LetterSpacing::value

    source
    fn LetterSpacing::value(self : LetterSpacing) -> Float

    LineBreak

    source
    pub(all) enum LineBreak {
      NoWrap
      AnyCharacter
      WordBoundary
    }

    Compatibility layer for Bevy-style Text2d concepts.

    Upstream cosmic-text uses Wrap + Align. Bevy exposes similar concepts as line-break and justification; we provide a small mapping layer here.

    LineEnding

    source
    pub(all) enum LineEnding {
      Lf
      CrLf
      Cr
      LfCr
      None
    }

    Ported from cosmic-text/src/line_ending.rs (cosmic-text is dual-licensed MIT OR Apache-2.0).

    LineEnding::as_str

    source
    fn LineEnding::as_str(self : LineEnding) -> String

    LineEnding::default

    source
    fn LineEnding::default() -> LineEnding

    Default line ending (matches upstream: LF).

    LineIter

    source
    pub struct LineIter {
      string : String
      start : Int
      end : Int
    }

    LineIter::new

    source
    fn LineIter::new(string : String) -> LineIter

    LineIter::next

    source
    fn LineIter::next(self : LineIter) -> (LineIter, (Int, Int, LineEnding)?)

    Returns (start, end, ending) where [start,end) is the line content range.

    LineState

    source
    pub struct LineState {
      block_comment_depth : Int
      markup_comment_open : Bool
      markup_tag_open : Bool
      ruby_block_comment_open : Bool
      shell_heredoc_delim_opt : String?
      shell_heredoc_strip_tabs : Bool
      lua_long_eq_count_opt : Int?
      lua_long_is_comment : Bool
      string_delim_opt : Char?
      string_is_triple : Bool
      raw_hash_count_opt : Int?
      markdown_fence_char_opt : Char?
      clike_preproc_continuation : Bool
    }

    impl Eq for LineState

    LineState::equal

    source
    fn LineState::equal(self : LineState, other : LineState) -> Bool

    LineState::new

    source
    fn LineState::new() -> LineState

    LineState::not_equal

    source
    fn LineState::not_equal(x : LineState, y : LineState) -> Bool

    Metrics

    source
    pub struct Metrics {
      font_size : Float
      line_height : Float
    }

    Ported from cosmic-text/src/buffer.rs (cosmic-text is dual-licensed MIT OR Apache-2.0).

    Metrics::new

    source
    fn Metrics::new(font_size : Float, line_height : Float) -> Metrics

    Metrics::relative

    source
    fn Metrics::relative(font_size : Float, line_height_scale : Float) -> Metrics

    Create metrics with given font size and calculate line height using relative scale.

    Metrics::scale

    source
    fn Metrics::scale(self : Metrics, scale : Float) -> Metrics

    Scale font size and line height.

    Motion

    source
    pub(all) enum Motion {
      LayoutCursor(LayoutCursor)
      Previous
      Next
      Left
      Right
      Up
      Down
      Home
      SoftHome
      End
      ParagraphStart
      ParagraphEnd
      PageUp
      PageDown
      Vertical(Int)
      PreviousWord
      NextWord
      LeftWord
      RightWord
      BufferStart
      BufferEnd
      GotoLine(Int)
    }

    A motion to perform on a Cursor
    impl Eq for Motion

    Motion::equal

    source
    fn Motion::equal(self : Motion, other : Motion) -> Bool

    Motion::not_equal

    source
    fn Motion::not_equal(x : Motion, y : Motion) -> Bool

    ParagraphInfo

    source
    pub struct ParagraphInfo {
      range_start : Int
      range_end : Int
      level : Int
    }

    Paragraph metadata for BiDi processing.

    Indices are UTF-16 code-unit offsets in the source text.

    ParagraphInfo::is_rtl

    source
    fn ParagraphInfo::is_rtl(self : ParagraphInfo) -> Bool

    ParagraphInfo::level

    source
    fn ParagraphInfo::level(self : ParagraphInfo) -> Int

    ParagraphInfo::range_end

    source
    fn ParagraphInfo::range_end(self : ParagraphInfo) -> Int

    ParagraphInfo::range_start

    source
    fn ParagraphInfo::range_start(self : ParagraphInfo) -> Int

    PhysicalGlyph

    source
    pub struct PhysicalGlyph {
      cache_key : CacheKey
      x : Int
      y : Int
    }

    A laid out glyph in physical/pixel coordinates, ready for rasterization.

    Scroll

    source
    pub struct Scroll {
      line : Int
      vertical : Float
      horizontal : Float
    }

    Scroll position in Buffer

    Scroll::default

    source
    fn Scroll::default() -> Scroll

    Scroll::new

    source
    fn Scroll::new(line : Int, vertical : Float, horizontal : Float) -> Scroll

    Selection

    source
    pub(all) enum Selection {
      None
      Normal(Cursor)
      Line(Cursor)
      Word(Cursor)
    }

    Selection mode.
    impl Eq for Selection

    Selection::equal

    source
    fn Selection::equal(self : Selection, other : Selection) -> Bool

    Selection::not_equal

    source
    fn Selection::not_equal(x : Selection, y : Selection) -> Bool

    ShapeGlyph

    source
    pub struct ShapeGlyph {
      start : Int
      end : Int
      x_advance : Float
      y_advance : Float
      x_offset : Float
      y_offset : Float
      ascent : Float
      descent : Float
      font_id : Int
      font_weight : Int
      glyph_id : Int
      color_opt : Color?
      metadata : Int
      cache_key_flags : UInt
      text_decoration : TextDecoration
      underline_metrics : DecorationMetrics
      strikethrough_metrics : DecorationMetrics
      level : Int
      metrics_opt : Metrics?
    }

    ShapeGlyph::new

    source
    fn ShapeGlyph::new(start : Int, end : Int, x_advance : Float, y_advance : Float, x_offset : Float, y_offset : Float, font_id : Int, glyph_id : Int, metadata : Int) -> ShapeGlyph

    ShapeGlyph::width

    source
    fn ShapeGlyph::width(self : ShapeGlyph, font_size : Float) -> Float

    ShapeGlyph::with_ascent_descent

    source
    fn ShapeGlyph::with_ascent_descent(self : ShapeGlyph, ascent : Float, descent : Float) -> ShapeGlyph

    ShapeLine

    source
    pub struct ShapeLine {
      text : String
      rtl : Bool
      glyphs : Array[ShapeGlyph]
    }

    ShapeLine::build

    source
    fn ShapeLine::build(_self : ShapeLine, text : String, attrs_list : AttrsList, shaping : Shaping, tab_width : Int) -> ShapeLine

    Build a shaped line from text and attributes list.

    ShapeLine::build_with_font_system

    source
    fn ShapeLine::build_with_font_system(_self : ShapeLine, font_system : FontSystem, text : String, attrs_list : AttrsList, shaping : Shaping, tab_width : Int) -> ShapeLine

    Build a shaped line using a FontSystem (best-effort).

    Advanced mode follows upstream shape_run/shape_fallback flow on top of moon_swash: BiDi runs, per-run script/fallback selection, cluster-aware glyph ranges, and run-cache reuse.

    ShapeLine::empty

    source
    fn ShapeLine::empty() -> ShapeLine

    ShapeLine::layout

    source
    fn ShapeLine::layout(self : ShapeLine, font_size : Float, width_opt : Float?, wrap : Wrap, ellipsize : Ellipsize, align : Align?, match_mono_width : Float?, hinting : Hinting) -> Array[LayoutLine]

    ShapeLine::layout_to_buffer

    source
    fn ShapeLine::layout_to_buffer(self : ShapeLine, font_size : Float, width_opt : Float?, wrap : Wrap, ellipsize : Ellipsize, align : Align?, layout_lines : Array[LayoutLine], match_mono_width : Float?, hinting : Hinting) -> Unit

    ShapeLine::new

    source
    fn ShapeLine::new(rtl : Bool, glyphs : Array[ShapeGlyph]) -> ShapeLine

    ShapeLine::width

    source
    fn ShapeLine::width(self : ShapeLine, font_size : Float) -> Float

    ShapeRunCache

    source
    pub struct ShapeRunCache {
      age : UInt64
      cache : 
    HashMap    [ShapeRunKey, (UInt64, Array[ShapeGlyph])]
    }

    A helper structure for caching shape runs.

    ShapeRunCache::clear

    source
    fn ShapeRunCache::clear(self : ShapeRunCache) -> Unit

    Clear all cached runs.

    ShapeRunCache::get

    source

    Get a cache item, updating age if found.

    ShapeRunCache::insert

    source
    fn ShapeRunCache::insert(self : ShapeRunCache, key : ShapeRunKey, glyphs : Array[ShapeGlyph]) -> Unit

    Insert a cache item with current age.

    ShapeRunCache::new

    source

    ShapeRunCache::output

    source
    fn ShapeRunCache::output(_self : ShapeRunCache, logger : &Logger) -> Unit

    ShapeRunCache::peek

    source

    Peek a cache item without updating its age.

    ShapeRunCache::to_string

    source
    fn ShapeRunCache::to_string(self : ShapeRunCache) -> String

    ShapeRunCache::trim

    source
    fn ShapeRunCache::trim(self : ShapeRunCache, keep_ages : UInt64) -> Unit

    Remove anything in the cache with an age older than keep_ages.

    ShapeRunKey

    source
    pub struct ShapeRunKey {
      text : String
      default_attrs : Attrs
      attrs_spans : Array[(Int, Int, Attrs)]
    }

    Key for caching shape runs.
    impl Eq for ShapeRunKey
    impl Hash for ShapeRunKey

    ShapeRunKey::equal

    source
    fn ShapeRunKey::equal(self : ShapeRunKey, other : ShapeRunKey) -> Bool

    ShapeRunKey::hash

    source
    fn ShapeRunKey::hash(self : ShapeRunKey) -> Int

    ShapeRunKey::hash_combine

    source
    fn ShapeRunKey::hash_combine(self : ShapeRunKey, hasher : Hasher) -> Unit

    ShapeRunKey::new

    source
    fn ShapeRunKey::new(text : String, attrs_list : AttrsList) -> ShapeRunKey

    ShapeRunKey::not_equal

    source
    fn ShapeRunKey::not_equal(x : ShapeRunKey, y : ShapeRunKey) -> Bool

    Shaping

    source
    pub(all) enum Shaping {
      Basic
      Advanced
    }

    Shaping primitives ported from cosmic-text/src/shape.rs.

    SubpixelBin

    source
    pub enum SubpixelBin {
      Zero
      One
      Two
      Three
    }

    Binning of subpixel position for cache optimization.
    impl Eq for SubpixelBin
    impl Hash for SubpixelBin
    impl Show for SubpixelBin

    SubpixelBin::as_float

    source
    fn SubpixelBin::as_float(self : SubpixelBin) -> Float

    SubpixelBin::equal

    source
    fn SubpixelBin::equal(self : SubpixelBin, other : SubpixelBin) -> Bool

    SubpixelBin::hash

    source
    fn SubpixelBin::hash(self : SubpixelBin) -> Int

    SubpixelBin::hash_combine

    source
    fn SubpixelBin::hash_combine(self : SubpixelBin, hasher : Hasher) -> Unit

    SubpixelBin::new

    source
    fn SubpixelBin::new(pos : Float) -> (Int, SubpixelBin)

    Returns (integral pixel position, bin for fractional part).

    Matches upstream cosmic-text binning behavior, including negative positions.

    SubpixelBin::not_equal

    source
    fn SubpixelBin::not_equal(x : SubpixelBin, y : SubpixelBin) -> Bool

    SubpixelBin::output

    source
    fn SubpixelBin::output(self : SubpixelBin, logger : &Logger) -> Unit

    SubpixelBin::to_repr

    source

    SubpixelBin::to_string

    source
    fn SubpixelBin::to_string(self : SubpixelBin) -> String

    SwashCache

    source

    SwashCache::get_image

    source
    fn SwashCache::get_image(self : SwashCache, font_system : FontSystem, cache_key : CacheKey) -> 
    Image    ?

    SwashCache::get_image_uncached

    source
    fn SwashCache::get_image_uncached(self : SwashCache, font_system : FontSystem, cache_key : CacheKey) -> 
    Image    ?

    SwashCache::get_outline_commands

    source
    fn SwashCache::get_outline_commands(self : SwashCache, font_system : FontSystem, cache_key : CacheKey) -> (Array[
    Vector    ], Array[
    Verb    ])?

    Create outline commands (path data) from a cache key, caching results.

    This matches upstream SwashCache::get_outline_commands.

    SwashCache::get_outline_commands_uncached

    source
    fn SwashCache::get_outline_commands_uncached(self : SwashCache, font_system : FontSystem, cache_key : CacheKey) -> (Array[
    Vector    ], Array[
    Verb    ])?

    Create outline commands (path data) from a cache key, without caching results.

    This matches upstream SwashCache::get_outline_commands_uncached.

    SwashCache::new

    source
    fn SwashCache::new() -> SwashCache

    SwashCache::with_pixels

    source
    fn SwashCache::with_pixels(self : SwashCache, font_system : FontSystem, cache_key : CacheKey, base : Color, f : (Int, Int, Color) -> Unit) -> Unit

    Enumerate pixels in a cached glyph image.

    SyntaxEditor

    source
    pub struct SyntaxEditor {
      editor : Editor
      syntax_system : SyntaxSystem
      syntax_name : String
      theme : SyntaxTheme
      cache : Array[CachedLine]
    }

    SyntaxEditor::action

    source
    fn SyntaxEditor::action(self : SyntaxEditor, action : Action) -> SyntaxEditor

    SyntaxEditor::apply_change

    source
    fn SyntaxEditor::apply_change(self : SyntaxEditor, change : Change) -> (SyntaxEditor, Bool)

    SyntaxEditor::auto_indent

    source
    fn SyntaxEditor::auto_indent(self : SyntaxEditor) -> Bool

    SyntaxEditor::background_color

    source
    fn SyntaxEditor::background_color(self : SyntaxEditor) -> Color

    SyntaxEditor::copy_selection

    source
    fn SyntaxEditor::copy_selection(self : SyntaxEditor) -> String?

    SyntaxEditor::cursor

    source
    fn SyntaxEditor::cursor(self : SyntaxEditor) -> Cursor

    SyntaxEditor::cursor_color

    source
    fn SyntaxEditor::cursor_color(self : SyntaxEditor) -> Color

    SyntaxEditor::cursor_position

    source
    fn SyntaxEditor::cursor_position(self : SyntaxEditor) -> (Int, Int)?

    SyntaxEditor::delete_range

    source
    fn SyntaxEditor::delete_range(self : SyntaxEditor, start : Cursor, end : Cursor) -> SyntaxEditor

    SyntaxEditor::delete_selection

    source
    fn SyntaxEditor::delete_selection(self : SyntaxEditor) -> (SyntaxEditor, Bool)

    SyntaxEditor::editor

    source
    fn SyntaxEditor::editor(self : SyntaxEditor) -> Editor

    SyntaxEditor::finish_change

    source
    fn SyntaxEditor::finish_change(self : SyntaxEditor) -> (SyntaxEditor, Change?)

    SyntaxEditor::foreground_color

    source
    fn SyntaxEditor::foreground_color(self : SyntaxEditor) -> Color

    SyntaxEditor::insert_string

    source
    fn SyntaxEditor::insert_string(self : SyntaxEditor, data : String, attrs_list_opt : AttrsList?) -> SyntaxEditor

    SyntaxEditor::new

    source
    fn SyntaxEditor::new(editor : Editor, syntax_system : SyntaxSystem, theme_name : String) -> SyntaxEditor?

    SyntaxEditor::rehighlight

    source
    fn SyntaxEditor::rehighlight(self : SyntaxEditor) -> SyntaxEditor

    SyntaxEditor::render

    source
    fn[R : Renderer] SyntaxEditor::render(self : SyntaxEditor, renderer : R) -> Unit

    SyntaxEditor::selection

    source
    fn SyntaxEditor::selection(self : SyntaxEditor) -> Selection

    SyntaxEditor::selection_color

    source
    fn SyntaxEditor::selection_color(self : SyntaxEditor) -> Color

    SyntaxEditor::set_auto_indent

    source
    fn SyntaxEditor::set_auto_indent(self : SyntaxEditor, auto_indent : Bool) -> SyntaxEditor

    SyntaxEditor::set_cursor

    source
    fn SyntaxEditor::set_cursor(self : SyntaxEditor, cursor : Cursor) -> SyntaxEditor

    SyntaxEditor::set_editor

    source
    fn SyntaxEditor::set_editor(self : SyntaxEditor, editor : Editor) -> SyntaxEditor

    SyntaxEditor::set_selection

    source
    fn SyntaxEditor::set_selection(self : SyntaxEditor, selection : Selection) -> SyntaxEditor

    SyntaxEditor::set_tab_width

    source
    fn SyntaxEditor::set_tab_width(self : SyntaxEditor, tab_width : Int) -> SyntaxEditor

    SyntaxEditor::start_change

    source
    fn SyntaxEditor::start_change(self : SyntaxEditor) -> SyntaxEditor

    SyntaxEditor::syntax_by_extension

    source
    fn SyntaxEditor::syntax_by_extension(self : SyntaxEditor, extension : String) -> SyntaxEditor

    SyntaxEditor::syntax_name

    source
    fn SyntaxEditor::syntax_name(self : SyntaxEditor) -> String

    SyntaxEditor::tab_width

    source
    fn SyntaxEditor::tab_width(self : SyntaxEditor) -> Int

    SyntaxEditor::theme

    source

    SyntaxEditor::update_theme

    source
    fn SyntaxEditor::update_theme(self : SyntaxEditor, theme_name : String) -> (SyntaxEditor, Bool)

    SyntaxSystem

    source
    pub struct SyntaxSystem {
    }

    SyntaxSystem::new

    source

    SyntaxSystem::plain_text_syntax

    source
    fn SyntaxSystem::plain_text_syntax(_self : SyntaxSystem) -> String

    SyntaxSystem::syntax_for_extension

    source
    fn SyntaxSystem::syntax_for_extension(_self : SyntaxSystem, extension : String) -> String?

    SyntaxSystem::theme

    source
    fn SyntaxSystem::theme(_self : SyntaxSystem, theme_name : String) -> SyntaxTheme?

    SyntaxTheme

    source
    pub struct SyntaxTheme {
      name : String
      background : Color
      foreground : Color
      cursor_opt : Color?
      selection_opt : Color?
      keyword : Color
      type_name : Color
      string_lit : Color
      comment : Color
      number : Color
    }

    Internal syntax-highlighting editor layer inspired by cosmic-text/src/edit/syntect.rs.

    SyntaxTheme::background

    source
    fn SyntaxTheme::background(self : SyntaxTheme) -> Color

    SyntaxTheme::cursor

    source
    fn SyntaxTheme::cursor(self : SyntaxTheme) -> Color

    SyntaxTheme::foreground

    source
    fn SyntaxTheme::foreground(self : SyntaxTheme) -> Color

    SyntaxTheme::name

    source
    fn SyntaxTheme::name(self : SyntaxTheme) -> String

    SyntaxTheme::selection

    source
    fn SyntaxTheme::selection(self : SyntaxTheme) -> Color

    TextDecoration

    source
    pub struct TextDecoration {
      underline : UnderlineStyle
      underline_color_opt : Color?
      strikethrough : Bool
      strikethrough_color_opt : Color?
      overline : Bool
      overline_color_opt : Color?
    }

    TextDecoration::equal

    source
    fn TextDecoration::equal(self : TextDecoration, other : TextDecoration) -> Bool

    TextDecoration::has_decoration

    source
    fn TextDecoration::has_decoration(self : TextDecoration) -> Bool

    TextDecoration::hash

    source
    fn TextDecoration::hash(self : TextDecoration) -> Int

    TextDecoration::hash_combine

    source
    fn TextDecoration::hash_combine(self : TextDecoration, hasher : Hasher) -> Unit

    TextDecoration::new

    source

    TextDecoration::not_equal

    source
    fn TextDecoration::not_equal(x : TextDecoration, y : TextDecoration) -> Bool

    TokenClass

    source
    pub(all) enum TokenClass {
      Keyword
      TypeName
      StringLit
      Comment
      Number
    }

    TokenSpan

    source
    pub struct TokenSpan {
      start : Int
      end : Int
      class : TokenClass
    }

    UnderlineStyle

    source
    pub(all) enum UnderlineStyle {
      None
      Single
      Double
    }

    UnderlineStyle::equal

    source
    fn UnderlineStyle::equal(self : UnderlineStyle, other : UnderlineStyle) -> Bool

    UnderlineStyle::hash

    source
    fn UnderlineStyle::hash(self : UnderlineStyle) -> Int

    UnderlineStyle::hash_combine

    source
    fn UnderlineStyle::hash_combine(self : UnderlineStyle, hasher : Hasher) -> Unit

    UnderlineStyle::not_equal

    source
    fn UnderlineStyle::not_equal(x : UnderlineStyle, y : UnderlineStyle) -> Bool

    ViEditor

    source
    pub struct ViEditor {
      editor : Editor
      mode : ViMode
      pending_operator : ViOperator?
      passthrough : Bool
      history : Array[Change]
      history_index : Int
      save_pivot_opt : Int?
      changed : Bool
      search_opt : (String, Bool)?
      search_input_opt : String?
      search_input_forwards : Bool
      pending_find_opt : (Bool, Bool, Int)?
      last_find_opt : (Bool, Bool, Char)?
      pending_replace_char : Bool
      pending_text_object_opt : (ViOperator, Bool)?
      pending_g : Bool
      pending_count_opt : Int?
      pending_register_prefix : Bool
      active_register_opt : Char?
      registers : Array[(Char, Selection, String)]
      register_opt : String?
    }

    impl Edit for ViEditor

    ViEditor::action

    source
    fn ViEditor::action(self : ViEditor, action : Action) -> ViEditor

    ViEditor::apply_change

    source
    fn ViEditor::apply_change(self : ViEditor, change : Change) -> (ViEditor, Bool)

    ViEditor::auto_indent

    source
    fn ViEditor::auto_indent(self : ViEditor) -> Bool

    ViEditor::changed

    source
    fn ViEditor::changed(self : ViEditor) -> Bool

    ViEditor::copy_selection

    source
    fn ViEditor::copy_selection(self : ViEditor) -> String?

    ViEditor::cursor

    source
    fn ViEditor::cursor(self : ViEditor) -> Cursor

    ViEditor::cursor_position

    source
    fn ViEditor::cursor_position(self : ViEditor) -> (Int, Int)?

    ViEditor::delete_range

    source
    fn ViEditor::delete_range(self : ViEditor, start : Cursor, end : Cursor) -> ViEditor

    ViEditor::delete_selection

    source
    fn ViEditor::delete_selection(self : ViEditor) -> (ViEditor, Bool)

    ViEditor::editor

    source
    fn ViEditor::editor(self : ViEditor) -> Editor

    ViEditor::escape

    source
    fn ViEditor::escape(self : ViEditor) -> ViEditor

    ViEditor::feed_char

    source
    fn ViEditor::feed_char(self : ViEditor, key : Char) -> ViEditor

    ViEditor::feed_string

    source
    fn ViEditor::feed_string(self : ViEditor, keys : String) -> ViEditor

    ViEditor::finish_change

    source
    fn ViEditor::finish_change(self : ViEditor) -> (ViEditor, Change?)

    ViEditor::insert_string

    source
    fn ViEditor::insert_string(self : ViEditor, data : String, attrs_list_opt : AttrsList?) -> ViEditor

    ViEditor::mode

    source
    fn ViEditor::mode(self : ViEditor) -> ViMode

    ViEditor::new

    source
    fn ViEditor::new(editor : Editor) -> ViEditor

    ViEditor::redo

    source
    fn ViEditor::redo(self : ViEditor) -> ViEditor

    ViEditor::save_point

    source
    fn ViEditor::save_point(self : ViEditor) -> ViEditor

    ViEditor::selection

    source
    fn ViEditor::selection(self : ViEditor) -> Selection

    ViEditor::set_auto_indent

    source
    fn ViEditor::set_auto_indent(self : ViEditor, auto_indent : Bool) -> ViEditor

    ViEditor::set_changed

    source
    fn ViEditor::set_changed(self : ViEditor, changed : Bool) -> ViEditor

    ViEditor::set_cursor

    source
    fn ViEditor::set_cursor(self : ViEditor, cursor : Cursor) -> ViEditor

    ViEditor::set_editor

    source
    fn ViEditor::set_editor(self : ViEditor, editor : Editor) -> ViEditor

    ViEditor::set_passthrough

    source
    fn ViEditor::set_passthrough(self : ViEditor, passthrough : Bool) -> ViEditor

    ViEditor::set_selection

    source
    fn ViEditor::set_selection(self : ViEditor, selection : Selection) -> ViEditor

    ViEditor::set_tab_width

    source
    fn ViEditor::set_tab_width(self : ViEditor, tab_width : Int) -> ViEditor

    ViEditor::start_change

    source
    fn ViEditor::start_change(self : ViEditor) -> ViEditor

    ViEditor::tab_width

    source
    fn ViEditor::tab_width(self : ViEditor) -> Int

    ViEditor::undo

    source
    fn ViEditor::undo(self : ViEditor) -> ViEditor

    ViMode

    source
    pub(all) enum ViMode {
      Normal
      Insert
      Replace
      Visual
      VisualLine
      Search
    }

    Internal Vi-style editor layer on top of moon_cosmic.Editor.

    ViOperator

    source
    pub(all) enum ViOperator {
      Delete
      Change
      Yank
      ShiftLeft
      ShiftRight
    }

    Weight

    source
    pub struct Weight {
      value : Int
    }

    Font weight (1..=1000). This is a simplified stand-in for fontdb::Weight.
    impl Eq for Weight
    impl Hash for Weight
    impl Show for Weight

    Weight::bold

    source
    fn Weight::bold() -> Weight

    Weight::equal

    source
    fn Weight::equal(self : Weight, other : Weight) -> Bool

    Weight::hash

    source
    fn Weight::hash(self : Weight) -> Int

    Weight::hash_combine

    source
    fn Weight::hash_combine(self : Weight, hasher : Hasher) -> Unit

    Weight::new

    source
    fn Weight::new(value : Int) -> Weight

    Weight::normal

    source
    fn Weight::normal() -> Weight

    Weight::not_equal

    source
    fn Weight::not_equal(x : Weight, y : Weight) -> Bool

    Weight::output

    source
    fn Weight::output(self : Weight, logger : &Logger) -> Unit

    Weight::to_string

    source
    fn Weight::to_string(self : Weight) -> String

    Weight::value

    source
    fn Weight::value(self : Weight) -> Int

    Wrap

    source
    pub(all) enum Wrap {
      None
      Glyph
      Word
      WordOrGlyph
    }

    Wrapping mode

    CACHE_KEY_FLAG_DISABLE_HINTING

    source
    let CACHE_KEY_FLAG_DISABLE_HINTING : UInt

    CACHE_KEY_FLAG_FAKE_ITALIC

    source
    let CACHE_KEY_FLAG_FAKE_ITALIC : UInt

    CACHE_KEY_FLAG_PIXEL_FONT

    source
    let CACHE_KEY_FLAG_PIXEL_FONT : UInt

    apply_align

    source
    fn apply_align(text : String, lines : Array[LayoutLine], width : Float, align : Align) -> Array[LayoutLine]

    Apply Align to precomputed layout lines assuming LTR paragraph direction.

    apply_align_with_rtl

    source
    fn apply_align_with_rtl(text : String, lines : Array[LayoutLine], width : Float, align : Align, rtl : Bool) -> Array[LayoutLine]

    Apply Align to precomputed layout lines (requires a finite width).

    cosmic_text_version

    source
    fn cosmic_text_version() -> String

    Port scaffold for cosmic-text (MIT OR Apache-2.0).

    The port is implemented incrementally while keeping data-flow behavior aligned.

    floorf

    source
    fn floorf(x : Float) -> Float

    grapheme_indices_uax29

    source
    fn grapheme_indices_uax29(s : String) -> Array[(Int, Int)]

    justify_to_align

    source
    fn justify_to_align(j : Justify) -> Align

    layout_ascii

    source
    fn layout_ascii(text : String, glyph_w : Float, width_opt : Float?, wrap : Wrap) -> Array[LayoutLine]

    ASCII-only layout for wrap tests.

    Semantics:
    • Treat each code unit as one glyph.
    • glyph_w is a monospace advance in pixels.

    layout_from_shape

    source
    fn layout_from_shape(text : String, shape : ShapeLine, font_size : Float, cell_w : Float, width_opt : Float?, wrap : Wrap) -> Array[LayoutLine]

    Layout from ShapeLine.

    cell_w is the pixel width per "advance cell" (ShapeGlyph.x_advance is in cells).

    line_break_to_wrap

    source
    fn line_break_to_wrap(lb : LineBreak) -> Wrap

    render_decoration

    source
    fn[R : Renderer] render_decoration(renderer : R, run : LayoutRun, default_color : Color) -> Unit

    Draw text decoration lines (underline, strikethrough, overline) for a layout run.

    roundf

    source
    fn roundf(x : Float) -> Float

    truncf

    source
    fn truncf(x : Float) -> Float

    word_indices_uax29

    source
    fn word_indices_uax29(s : String) -> Array[(Int, Int)]

    word_indices_whitespace

    source
    fn word_indices_whitespace(s : String) -> Array[(Int, Int)]

    Compatibility wrappers for segmentation APIs.

    Implementations are hosted in the linebreak internal subpackage.

    wrap_word_segments

    source
    fn wrap_word_segments(s : String) -> Array[(Int, Int, Bool)]

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io