Struct LayoutNode

pub struct LayoutNode<T>
where
    T: 'static,
{
    pub style: Style,
    pub unrounded_layout: Layout,
    pub final_layout: Layout,
    pub cache: Cache,
    pub context: Option<T>,
}

Fields

style: Style

unrounded_layout: Layout

final_layout: Layout

cache: Cache

context: Option<T>

Implementations

impl<T> LayoutNode<T>

where T: 'static,

pub fn new(style: Style) -> Self

Examples found in repository

examples/basic.rs (line 20)

fn container<P, C>(s: Scope<P>, style: Style, content: C)
where
    P: 'static,
    C: Fn(Scope<Container>) + Clone + 'static,
{
    let scope = s.child::<Container>();
    s.create_node(
        scope,
        content,
        move |_| style.clone(),
        |style, _| LayoutNode::new(style),
        |n, style, _| {
            if n.style != style {
                n.style = style;
            }
        },
    );
}

struct Leaf;
#[track_caller]
fn leaf<P>(s: Scope<P>, style: Style)
where
    P: 'static,
{
    let scope = s.child::<Leaf>();
    s.create_node(
        scope,
        |_| {},
        move |_| style.clone(),
        |style, _| LayoutNode::new(style),
        |n, style, _| {
            if n.style != style {
                n.style = style;
                n.mark_dirty();
            }
        },
    );
}

pub fn with_context(style: Style, context: T) -> Self

pub fn mark_dirty(&mut self)

Examples found in repository

examples/basic.rs (line 44)

fn leaf<P>(s: Scope<P>, style: Style)
where
    P: 'static,
{
    let scope = s.child::<Leaf>();
    s.create_node(
        scope,
        |_| {},
        move |_| style.clone(),
        |style, _| LayoutNode::new(style),
        |n, style, _| {
            if n.style != style {
                n.style = style;
                n.mark_dirty();
            }
        },
    );
}

Trait Implementations

impl<T> Clone for LayoutNode<T>

where T: 'static + Clone,

fn clone(&self) -> LayoutNode<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> ComposeNode for LayoutNode<T>

where T: 'static,

type Context = TaffyConfig

impl<T> Debug for LayoutNode<T>

where T: 'static + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.