Enum egui_dock::dock_state::tree::node::Node

pub enum Node<Tab> {
    Empty,
    Leaf {
        rect: Rect,
        viewport: Rect,
        tabs: Vec<Tab>,
        active: TabIndex,
        scroll: f32,
    },
    Vertical {
        rect: Rect,
        fraction: f32,
    },
    Horizontal {
        rect: Rect,
        fraction: f32,
    },
}

Represents an abstract node of a Tree.

Variants

Empty

Empty node.

Leaf

Fields

rect: Rect

The full rectangle - tab bar plus tab body.

viewport: Rect

The tab body rectangle.

tabs: Vec<Tab>

All the tabs in this node.

active: TabIndex

The opened tab.

scroll: f32

Scroll amount of the tab bar.

Contains the actual tabs.

Vertical

Fields

rect: Rect

The rectangle in which all children of this node are drawn.

fraction: f32

The fraction taken by the top child of this node.

Parent node in the vertical orientation.

Horizontal

Fields

rect: Rect

The rectangle in which all children of this node are drawn.

fraction: f32

The fraction taken by the left child of this node.

Parent node in the horizontal orientation.

Implementations

impl<Tab> Node<Tab>

pub fn leaf(tab: Tab) -> Self

Constructs a leaf node with a given tab.

pub const fn leaf_with(tabs: Vec<Tab>) -> Self

Constructs a leaf node with a given list of tabs.

pub fn set_rect(&mut self, new_rect: Rect)

Sets the area occupied by the node.

pub fn rect(&self) -> Option<Rect>

Get a [Rect] occupied by the node, could be used e.g. to draw a highlight rect around a node.

Returns None if node is of the Empty variant.

pub const fn is_empty(&self) -> bool

Returns true if the node is a Empty, otherwise false.

pub const fn is_leaf(&self) -> bool

Returns true if the node is a Leaf, otherwise false.

pub const fn is_horizontal(&self) -> bool

Returns true if the node is a Horizontal, otherwise false.

pub const fn is_vertical(&self) -> bool

Returns true if the node is a Vertical, otherwise false.

pub const fn is_parent(&self) -> bool

Returns true if the node is either Horizontal or Vertical, otherwise false.

pub fn split(&mut self, split: Split, fraction: f32) -> Self

Replaces the node with Horizontal or Vertical (depending on split) and assigns an empty rect to it.

Panics

If fraction isn’t in range 0..=1.

pub fn tabs(&self) -> Option<&[Tab]>

Provides an immutable slice of the tabs inside this node.

Returns None if the node is not a Leaf.

Examples

let mut dock_state = DockState::new(vec![1, 2, 3, 4, 5, 6]);
assert!(dock_state.main_surface().root_node().unwrap().tabs().unwrap().contains(&4));

pub fn tabs_mut(&mut self) -> Option<&mut [Tab]>

Provides an mutable slice of the tabs inside this node.

Returns None if the node is not a Leaf.

Examples

Modifying tabs inside a node:

let mut dock_state = DockState::new(vec![1, 2, 3, 4, 5, 6]);
let mut tabs = dock_state
    .main_surface_mut()
    .root_node_mut()
    .unwrap()
    .tabs_mut()
    .unwrap();

tabs[0] = 7;
tabs[5] = 8;

assert_eq!(&tabs, &[7, 2, 3, 4, 5, 8]);

pub fn iter_tabs(&self) -> impl Iterator<Item = &Tab>

Returns an Iterator of tabs in this node.

If this node is not a Leaf, then the returned Iterator will be empty.

pub fn iter_tabs_mut(&mut self) -> impl Iterator<Item = &mut Tab>

Returns a mutable Iterator of tabs in this node.

If this node is not a Leaf, then the returned Iterator will be empty.

pub fn append_tab(&mut self, tab: Tab)

Adds tab to the node and sets it as the active tab.

Panics

If the new capacity of tabs exceeds isize::MAX bytes.

If self is not a Leaf node.

Examples

let mut dock_state = DockState::new(vec!["a tab"]);
assert_eq!(dock_state.main_surface().root_node().unwrap().tabs_count(), 1);

dock_state.main_surface_mut().root_node_mut().unwrap().append_tab("another tab");
assert_eq!(dock_state.main_surface().root_node().unwrap().tabs_count(), 2);

pub fn insert_tab(&mut self, index: TabIndex, tab: Tab)

Adds a tab to the node.

Panics

Panics if the new capacity of tabs exceeds isize::MAX bytes, or index > tabs_count().

pub fn remove_tab(&mut self, tab_index: TabIndex) -> Option<Tab>

Removes a tab at given index from the node. Returns the removed tab if the node is a Leaf, or None otherwise.

Panics

Panics if index is out of bounds.

pub fn tabs_count(&self) -> usize

Gets the number of tabs in the node.

pub fn filter_map_tabs<F, NewTab>(&self, function: F) -> Node<NewTab>

where F: FnMut(&Tab) -> Option<NewTab>,

Returns a new Node while mapping and filtering the tab type. If this Node remains empty, it will change to Node::Empty.

pub fn map_tabs<F, NewTab>(&self, function: F) -> Node<NewTab>

where F: FnMut(&Tab) -> NewTab,

Returns a new Node while mapping the tab type.

pub fn filter_tabs<F>(&self, predicate: F) -> Node<Tab>

where F: Clone + FnMut(&Tab) -> bool, Tab: Clone,

Returns a new Node while filtering the tab type. If this Node remains empty, it will change to Node::Empty.

pub fn retain_tabs<F>(&mut self, predicate: F)

where F: Clone + FnMut(&mut Tab) -> bool,

Removes all tabs for which predicate returns false. If this Node remains empty, it will change to Node::Empty.

Trait Implementations

impl<Tab: Clone> Clone for Node<Tab>

fn clone(&self) -> Node<Tab>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Tab: Debug> Debug for Node<Tab>

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

Formats the value using the given formatter.