Milky2018/chicle/tree does not have a README file

    AlignContent

    AlignItems

    AlignSelf

    using @Milky2018/chicle/style { type AlignItems as AlignSelf }

    AvailableSpace

    BoxSizing

    Dimension

    Display

    FlexDirection

    FlexWrap

    GridAutoFlow

    GridPlacement

    GridTrackRepetition

    JustifyContent

    using @Milky2018/chicle/style { type AlignContent as JustifyContent }

    JustifyItems

    using @Milky2018/chicle/style { type AlignItems as JustifyItems }

    JustifySelf

    using @Milky2018/chicle/style { type AlignItems as JustifySelf }

    LengthPercentage

    LengthPercentageAuto

    MaxTrackSizingFunction

    MinTrackSizingFunction

    NodeId

    type NodeId = Int

    NonRepeatedTrackSizingFunction

    Overflow

    Position

    TrackSizingFunction

    ChicleError

    type ChicleError

    ChicleTree

    pub struct ChicleTree[C] {
    // private fields
    }

    ChicleTree::ChicleTree

    fn[C] ChicleTree::ChicleTree() -> ChicleTree[C]

    ChicleTree::add_child

    fn[C] ChicleTree::add_child(tree : ChicleTree[C], parent : Int, child : Int) -> Unit raise ChicleError

    ChicleTree::clear_node_context

    fn[C] ChicleTree::clear_node_context(tree : ChicleTree[C], node : Int) -> Unit raise ChicleError

    ChicleTree::compute_layout

    fn[C] ChicleTree::compute_layout(self : ChicleTree[C], root : Int, available_space :
    Size
    [
    AvailableSpace
    ]) -> Unit raise ChicleError

    ChicleTree::dirty

    fn[C] ChicleTree::dirty(tree : ChicleTree[C], node : Int) -> Bool raise ChicleError

    ChicleTree::disable_rounding

    fn[C] ChicleTree::disable_rounding(self : ChicleTree[C]) -> Unit

    ChicleTree::enable_rounding

    fn[C] ChicleTree::enable_rounding(self : ChicleTree[C]) -> Unit

    ChicleTree::layout

    fn[C] ChicleTree::layout(self : ChicleTree[C], node : Int) -> Layout raise ChicleError

    ChicleTree::mark_dirty

    fn[C] ChicleTree::mark_dirty(tree : ChicleTree[C], node : Int) -> Unit raise ChicleError

    ChicleTree::new_leaf

    fn[C] ChicleTree::new_leaf(self : ChicleTree[C], style :
    Style
    ) -> Int

    ChicleTree::new_leaf_with_context

    fn[C] ChicleTree::new_leaf_with_context(self : ChicleTree[C], style :
    Style
    , context : C) -> Int

    ChicleTree::new_with_children

    fn[C] ChicleTree::new_with_children(self : ChicleTree[C], style :
    Style
    , children : Array[Int]) -> Int

    ChicleTree::node_context

    fn[C] ChicleTree::node_context(self : ChicleTree[C], node : Int) -> C? raise ChicleError

    ChicleTree::remove

    fn[C] ChicleTree::remove(tree : ChicleTree[C], node : Int) -> Unit raise ChicleError

    ChicleTree::remove_child

    fn[C] ChicleTree::remove_child(tree : ChicleTree[C], parent : Int, child : Int) -> Int raise ChicleError

    ChicleTree::remove_subtree

    fn[C] ChicleTree::remove_subtree(tree : ChicleTree[C], node : Int) -> Unit raise ChicleError

    ChicleTree::set_children

    fn[C] ChicleTree::set_children(tree : ChicleTree[C], parent : Int, children : Array[Int]) -> Unit raise ChicleError

    ChicleTree::set_node_context

    fn[C] ChicleTree::set_node_context(tree : ChicleTree[C], node : Int, context : C) -> Unit raise ChicleError

    ChicleTree::set_style

    fn[C] ChicleTree::set_style(tree : ChicleTree[C], node : Int, style :
    Style
    ) -> Unit raise ChicleError

    ChicleTree::with_capacity

    fn[C] ChicleTree::with_capacity(_capacity : Int) -> ChicleTree[C]

    Layout

    pub(all) struct Layout {
    order : Int
    location :
    Point
    [Double]
    size :
    Size
    [Double]
    content_size :
    Size
    [Double]
    scrollbar_size :
    Size
    [Double]
    border :
    Rect
    [Double]
    padding :
    Rect
    [Double]
    }

    Layout::scroll_height

    fn Layout::scroll_height(self : Layout) -> Double

    Layout::scroll_width

    fn Layout::scroll_width(self : Layout) -> Double

    Layout::zero

    fn Layout::zero() -> Layout

    LayoutInput

    pub(all) struct LayoutInput {
    run_mode : RunMode
    sizing_mode : SizingMode
    axis : RequestedAxis
    known_dimensions :
    Size
    [Double?]
    parent_size :
    Size
    [Double?]
    available_space :
    Size
    [
    AvailableSpace
    ]
    vertical_margins_are_collapsible :
    Line
    [Bool]
    }

    LayoutInput::hidden

    fn LayoutInput::hidden() -> LayoutInput

    LayoutOutput

    pub(all) struct LayoutOutput {
    size :
    Size
    [Double]
    content_size :
    Size
    [Double]
    first_baselines :
    Point
    [Double?]
    top_margin : (Double, Double)
    bottom_margin : (Double, Double)
    margins_can_collapse_through : Bool
    }

    LayoutOutput::from_layout

    fn LayoutOutput::from_layout(layout : Layout) -> LayoutOutput

    LayoutOutput::from_outer_size

    fn LayoutOutput::from_outer_size(size :
    Size
    [Double]) -> LayoutOutput

    LayoutOutput::outer_size

    NodeData

    type NodeData

    RequestedAxis

    pub(all) enum RequestedAxis {
    RequestedHorizontal
    RequestedVertical
    RequestedBoth
    }

    RunMode

    pub(all) enum RunMode {
    PerformLayout
    ComputeSize
    PerformHiddenLayout
    }

    SizingMode

    pub(all) enum SizingMode {
    ContentSize
    InherentSize
    }

    layout_input_for_compute_size

    fn layout_input_for_compute_size(known_dimensions :
    Size
    [Double?], parent_size :
    Size
    [Double?], available_space :
    Size
    [
    AvailableSpace
    ], sizing_mode : SizingMode, axis : RequestedAxis, vertical_margins_are_collapsible :
    Line
    [Bool]) -> LayoutInput

    layout_input_for_perform_layout

    requested_axis_from_absolute

    fn requested_axis_from_absolute(axis :
    AbsoluteAxis
    ) -> RequestedAxis

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io