README

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