Trait LayoutPartialTree 

pub trait LayoutPartialTree: TraversePartialTree {
    type CoreContainerStyle<'a>: CoreStyle<CustomIdent = Self::CustomIdent>
       where Self: 'a;
    type CustomIdent: CheapCloneStr;

    // Required methods
    fn get_core_container_style(
        &self,
        node_id: NodeId,
    ) -> Self::CoreContainerStyle<'_>;
    fn set_unrounded_layout(&mut self, node_id: NodeId, layout: &Layout);
    fn compute_child_layout(
        &mut self,
        node_id: NodeId,
        inputs: LayoutInput,
    ) -> LayoutOutput;

    // Provided method
    fn resolve_calc_value(&self, val: *const (), basis: f32) -> f32 { ... }
}

Any type that implements LayoutPartialTree can be laid out using Takia’s algorithms

Note that this trait extends TraversePartialTree (not TraverseTree). Takia’s algorithm implementations have been designed such that they can be used for a laying out a single node that only has access to it’s immediate children.

Required Associated Types

type CoreContainerStyle<'a>: CoreStyle<CustomIdent = Self::CustomIdent> where Self: 'a

The style type representing the core container styles that all containers should have Used when laying out the root node of a tree

type CustomIdent: CheapCloneStr

String type for representing “custom identifiers” (for example, named grid lines or areas) If you are unsure what to use here then consider Arc<str>.

Required Methods

fn get_core_container_style( &self, node_id: NodeId, ) -> Self::CoreContainerStyle<'_>

Get core style

Only called for the node being laid out, never for its children (those go through the get_*_child_style methods), so it may be expressed in the node’s own axes while child styles are expressed in the axes of the node laying them out.

fn set_unrounded_layout(&mut self, node_id: NodeId, layout: &Layout)

Set the node’s unrounded layout

fn compute_child_layout( &mut self, node_id: NodeId, inputs: LayoutInput, ) -> LayoutOutput

Compute the specified node’s size or full layout given the specified constraints

Provided Methods

fn resolve_calc_value(&self, val: *const (), basis: f32) -> f32

Resolve calc value

Examples found in repository

examples/custom_tree_owned_unsafe.rs (line 166)

    fn compute_child_layout(&mut self, node_id: NodeId, inputs: takia::tree::LayoutInput) -> takia::tree::LayoutOutput {
        compute_cached_layout(self, node_id, inputs, |tree, node_id, inputs| {
            let node = unsafe { node_from_id_mut(node_id) };
            let font_metrics = FontMetrics { char_width: 10.0, char_height: 10.0 };

            let mut output = match node.kind {
                NodeKind::Flexbox => compute_flexbox_layout(tree, node_id, inputs),
                NodeKind::Grid => compute_grid_layout(tree, node_id, inputs),
                NodeKind::Text => compute_leaf_layout(
                    inputs,
                    &node.style,
                    |val, basis| tree.resolve_calc_value(val, basis),
                    |known_dimensions, available_space| {
                        text_measure_function(
                            known_dimensions,
                            available_space,
                            node.text_data.as_ref().unwrap(),
                            &font_metrics,
                        )
                    },
                ),
                NodeKind::Image => compute_leaf_layout(
                    inputs,
                    &node.style,
                    |val, basis| tree.resolve_calc_value(val, basis),
                    |known_dimensions, _available_space| {
                        image_measure_function(known_dimensions, node.image_data.as_ref().unwrap())
                    },
                ),
            };

            // Lay out any out-of-flow (absolute/fixed) boxes for which this node is the containing block
            if inputs.run_mode == takia::RunMode::PerformLayout {
                compute_oof_layout(tree, node_id, &mut output);
            }

            output
        })
    }

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors