Struct Tree

pub struct Tree<I>
where
    I: GenerationalId,
{
    pub parent: Vec<Option<I>>,
    pub first_child: Vec<Option<I>>,
    pub next_sibling: Vec<Option<I>>,
    pub prev_sibling: Vec<Option<I>>,
    pub ignored: Vec<bool>,
    pub window: Vec<bool>,
    pub lock_focus_within: Vec<bool>,
    pub changed: bool,
}

The Tree describes the tree of entities.

Fields

parent: Vec<Option<I>>

first_child: Vec<Option<I>>

next_sibling: Vec<Option<I>>

prev_sibling: Vec<Option<I>>

ignored: Vec<bool>

window: Vec<bool>

lock_focus_within: Vec<bool>

changed: bool

Implementations

impl<I> Tree<I>

where I: GenerationalId,

pub fn new() -> Tree<I>

Creates a new tree with a root entity.

pub fn get_child_index(&self, entity: I) -> Option<usize>

pub fn get_last_child(&self, entity: I) -> Option<&I>

Returns the last child of an entity.

pub fn get_child(&self, entity: I, n: usize) -> Option<I>

Returns the nth child of an entity.

pub fn get_num_children(&self, entity: I) -> Option<u32>

Returns the number of children of an entity.

pub fn is_ignored(&self, entity: I) -> bool

Returns true if the node should be skipped by layout

pub fn is_window(&self, entity: I) -> bool

Returns true if the node should be skipped by layout

pub fn lock_focus_within(&self, entity: I) -> I

Returns the first ancestor to have the lock_focus_within flag set

pub fn get_layout_parent(&self, entity: I) -> Option<I>

Returns the first ancestor of an entity which is not ignored

pub fn get_parent(&self, entity: I) -> Option<I>

Returns the parent of an entity.

pub fn get_parent_window(&self, entity: I) -> Option<I>

pub fn get_first_child(&self, entity: I) -> Option<I>

Returns the first child of an entity or None if there isn’t one.

pub fn get_layout_first_child(&self, entity: I) -> Option<I>

pub fn get_next_sibling(&self, entity: I) -> Option<I>

Returns the next sibling of an entity or None if t here isn’t one.

pub fn get_next_layout_sibling(&self, entity: I) -> Option<I>

Returns the next layout sibling of an entity or None if t here isn’t one.

pub fn get_prev_sibling(&self, entity: I) -> Option<I>

Returns the previous sibling of an entity or None if there isn’t one.

pub fn get_prev_layout_sibling(&self, entity: I) -> Option<I>

Returns the previous layout sibling of an entity or None if there isn’t one.

pub fn is_first_child(&self, entity: I) -> bool

Returns true if the entity is the first child of its parent.

pub fn is_last_child(&self, entity: I) -> bool

Returns true if the entity is the last child of its parent.

pub fn is_sibling(&self, entity1: I, entity2: I) -> bool

pub fn has_children(&self, entity: I) -> bool

Returns true if the entity has children.

pub fn remove(&mut self, entity: I) -> Result<(), TreeError>

Removes an entity from the tree

This method assumes that a check if the entity is alive has already been done prior to calling this method.

pub fn set_first_child(&mut self, entity: I) -> Result<(), TreeError>

Makes the entity the first child of its parent.

pub fn set_next_sibling( &mut self, entity: I, sibling: I, ) -> Result<(), TreeError>

pub fn set_prev_sibling( &mut self, entity: I, sibling: I, ) -> Result<(), TreeError>

pub fn set_parent(&mut self, entity: I, parent: I)

pub fn set_ignored(&mut self, entity: I, flag: bool)

pub fn set_window(&mut self, entity: I, flag: bool)

pub fn set_lock_focus_within(&mut self, entity: I, flag: bool)

pub fn add(&mut self, entity: I, parent: I) -> Result<(), TreeError>

Adds an entity to the tree with the specified parent.

Trait Implementations

impl<I> Clone for Tree<I>

where I: Clone + GenerationalId,

fn clone(&self) -> Tree<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I> Debug for Tree<I>

where I: Debug + GenerationalId,

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

Formats the value using the given formatter.

impl<'a, I> IntoIterator for &'a Tree<I>

where I: GenerationalId,

type Item = I

The type of the elements being iterated over.

type IntoIter = TreeIterator<'a, I>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Tree<I> as IntoIterator>::IntoIter

Creates an iterator from a value.