Struct egui_tiles::Tree

pub struct Tree<Pane> {
    pub root: Option<TileId>,
    pub tiles: Tiles<Pane>,
}

The top level type. Contains all persistent state, including layouts and sizes.

You’ll usually construct this once and then store it, calling Tree::ui each frame.

See the crate-level documentation for a complete example.

How to constriuct a Tree

use egui_tiles::{Tiles, TileId, Tree};

struct Pane { } // put some state here

let mut tiles = Tiles::default();
let tabs: Vec<TileId> = vec![tiles.insert_pane(Pane { }), tiles.insert_pane(Pane { })];
let root: TileId = tiles.insert_tab_tile(tabs);

let tree = Tree::new(root, tiles);

Fields

root: Option<TileId>

None = empty tree

tiles: Tiles<Pane>

All the tiles in the tree.

Implementations

impl<Pane> Tree<Pane>

pub fn empty() -> Self

pub fn new(root: TileId, tiles: Tiles<Pane>) -> Self

The most flexible constructor, allowing you to set up the tiles however you want.

pub fn new_tabs(panes: Vec<Pane>) -> Self

Create a top-level crate::Tabs container with the given panes.

pub fn new_horizontal(panes: Vec<Pane>) -> Self

Create a top-level horizontal crate::Linear container with the given panes.

pub fn new_vertical(panes: Vec<Pane>) -> Self

Create a top-level vertical crate::Linear container with the given panes.

pub fn new_grid(panes: Vec<Pane>) -> Self

Create a top-level crate::Grid container with the given panes.

pub fn new_container(kind: ContainerKind, panes: Vec<Pane>) -> Self

Create a top-level container with the given panes.

pub fn is_empty(&self) -> bool

Check if Self::root is None.

pub fn root(&self) -> Option<TileId>

pub fn is_root(&self, tile: TileId) -> bool

pub fn is_visible(&self, tile_id: TileId) -> bool

Tiles are visible by default.

Invisible tiles still retain their place in the tile hierarchy.

pub fn set_visible(&mut self, tile_id: TileId, visible: bool)

Tiles are visible by default.

Invisible tiles still retain their place in the tile hierarchy.

pub fn ui(&mut self, behavior: &mut dyn Behavior<Pane>, ui: &mut Ui)

Show the tree in the given Ui.

The tree will use upp all the available space - nothing more, nothing less.

pub fn make_active(&mut self, should_activate: impl Fn(&Tile<Pane>) -> bool)

Recursively “activate” the ancestors of the tiles that matches the given predicate.

This means making the matching tiles and its ancestors the active tab in any tab layout.

pub fn dragged_id(&self, ctx: &Context) -> Option<TileId>

Find the currently dragged tile, if any.

Trait Implementations

impl<Pane: Clone> Clone for Tree<Pane>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Pane: Debug> Debug for Tree<Pane>

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

Formats the value using the given formatter.

impl<Pane> Default for Tree<Pane>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, Pane> Deserialize<'de> for Tree<Pane>where Pane: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Pane: PartialEq> PartialEq<Tree<Pane>> for Tree<Pane>

fn eq(&self, other: &Tree<Pane>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Pane> Serialize for Tree<Pane>where Pane: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Pane> StructuralPartialEq for Tree<Pane>