Struct Overlap 

pub struct Overlap { /* private fields */ }

A node that contains many children which are stacked on top of each other and do not interact.

Implementations

impl Overlap

pub fn new() -> Self

Create an empty Overlap with no child and alignment (Begin, Begin).

pub fn with_child(self, index: NodeIndex) -> Self

Add a new child to the list.

pub fn with_align(self, align: (Alignment, Alignment)) -> Self

Set the horizontal and vertical alignment of the container, not the children.

pub fn add_child(&mut self, index: NodeIndex)

Add a child to the list. The child will appear on top (last-visited).

pub fn len(&self) -> usize

Returns the number of children in the list.

pub fn is_empty(&self) -> bool

Returns true if the list is empty.

Equivalent to len() == 0.

pub fn remove_child(&mut self, index: usize, tree: &mut UiTree) -> bool

Remove a child from the list.

Returns true if the child was removed.

pub fn set_child_position(&mut self, index: usize, position: usize) -> bool

Move a child to a new index. Lower indices are visited first.

Returns true if the child was moved.

pub fn get_child_index(&self, index: usize) -> Option<NodeIndex>

Returns the tree index associated with a child at a given list index.

Trait Implementations

impl Default for Overlap

fn default() -> Self

Returns the “default value” for a type.

impl UiNode for Overlap

fn get_align(&self) -> (Alignment, Alignment)

Get the alignment of the node.

fn get_align_mut(&mut self) -> (&mut Alignment, &mut Alignment)

Get a mutable reference to the alignment of the node.

fn calculate_min_size(&self, tree: &UiTree) -> (f32, f32)

Calculate the minimum size of the node.

fn calculate_rects(&self, cache: &NodeCache, tree: &UiTree) -> Vec<Rect>

Recalculate the position and size of child nodes, in the same order and count as get_visible_children.

fn get_children(&self) -> Vec<NodeIndex>

Get all children of the node, if applicable.

fn get_visible_children(&self) -> Vec<NodeIndex>

Get all visible children of the node, if applicable.