Struct PaneTree 

pub struct PaneTree { /* private fields */ }

Everything gpui_base::dock exports, so a consumer never has to depend on the foundation crate directly to write a skin or read a container’s state. Kept in step with base’s own list by every_base_dock_export_is_reachable_from_here.

Two names are handled elsewhere and one is deliberately absent: base’s Panel and PanelView arrive as BasePanel and BasePanelView because this module’s Panel/PanelView are the presentation halves that extend them, and base’s Dock — a plain state struct holding one dock’s open, collapsible, size and resizing flags — is not re-exported at all, because the name meant a panel container in every released version of this crate and handing it back with a different meaning is worse than dropping it. A skin reads a dock through DockContext. One region’s layout, as pure data.

A DockArea owns one of these per region — the center plus each dock it has. Containers are addressed by NodeId and panels by PanelId; no entity handle lives in here, so a tree can be built, edited, compared and serialized with no App in sight.

Every edit method normalizes before returning and reports what it did as an EditResult, so there is no window in which a caller can observe a tree with an empty container, a one-child split, or an out-of-range active index.

Implementations

impl PaneTree

pub fn insert_panel( &mut self, panel: PanelId, target: InsertTarget, ) -> EditResult

pub fn remove_panel(&mut self, panel: PanelId) -> EditResult

pub fn move_panel(&mut self, panel: PanelId, target: InsertTarget) -> EditResult

Move a panel to a new home without ever removing it from the tree’s perspective, so the caller never fires on_removed for a drag.

pub fn split( &mut self, at: NodeId, panel: PanelId, placement: Placement, size: Option<Pixels>, ) -> EditResult

pub fn set_active(&mut self, node: NodeId, ix: usize) -> EditResult

pub fn set_sizes( &mut self, node: NodeId, new_sizes: Vec<Option<Pixels>>, ) -> EditResult

Replace a split’s slot sizes wholesale.

A no-op, like every other operation given input it cannot resolve, if new_sizes.len() does not match the split’s child count: no rule in normalize repairs a length mismatch, so applying it would otherwise leave children.len() != sizes.len() and trip normalize’s debug_assert!.

pub fn set_tile_bounds( &mut self, panel: PanelId, bounds: Bounds<Pixels>, ) -> EditResult

pub fn bring_to_front(&mut self, panel: PanelId) -> EditResult

impl PaneTree

pub fn contains_panel(&self, panel: PanelId) -> bool

Whether panel is anywhere in this tree.

impl PaneTree

pub fn normalize(&mut self)

Collapse the tree to canonical shape.

One post-order pass repeated to a fixpoint. This is the only place a container is removed for being empty, replacing the mutually recursive remove_self_if_empty pair the old implementation used. It needs no parent pointers and no deferred work, so the tree is self-consistent the instant an edit returns.

Rules, applied bottom up:

1. An empty Tabs, Tiles, or Split is removed from its parent.
2. A Split with one child is replaced by that child. The child keeps its own NodeId and inherits the split’s slot size.
3. A Split whose child is a Split of the same axis splices that child’s children into itself.
4. active_ix is clamped.
5. The root is preserved according to RootKind.

Idempotent: normalize(normalize(t)) == normalize(t).

impl PaneTree

pub fn new(root_kind: RootKind) -> PaneTree

pub fn root(&self) -> &PaneNode

pub fn root_kind(&self) -> RootKind

pub fn node_ids(&self) -> Vec<NodeId>

Every container id in the tree, in pre-order.

pub fn panels(&self) -> impl Iterator<Item = PanelId>

Every panel in the tree, in pre-order.

pub fn find_node(&self, id: NodeId) -> Option<&PaneNode>

pub fn find_panel_node(&self, panel: PanelId) -> Option<NodeId>

The tab or tiles node holding panel.

impl PaneTree

pub fn to_state(&self, source: &dyn PanelSource) -> PanelState

impl PaneTree

pub fn from_state( state: &PanelState, root_kind: RootKind, builder: &mut dyn PanelBuilder, ) -> PaneTree

Read a persisted layout.

Compatibility rules, all previously implicit in PanelState::to_item:

• a Tabs whose children are themselves Tabs is flattened;
• a bare Panel leaf appearing where a container belongs is wrapped in a Tabs;
• a node named TabPanel carrying PanelInfo::Panel is read as an empty tab group, recovering data written by the old dump defect (an empty TabPanel never entered the loop that set its info to Tabs, so it kept PanelState’s default Panel(Value::Null)). The old reader had no such rule: it looked “TabPanel” up in the panel registry, found nothing, and rendered an InvalidPanel placeholder where an empty tab group belonged. This rule is a genuine fix, not a preserved behavior;
• a Tiles child without a matching meta keeps the default placement. The old writer’s counterpart (DockItem::tiles) hard-asserted items.len() == metas.len() and panicked the whole load on a short metas list, so this rule is a new safety net, not a preserved graceful-degradation path.

Trait Implementations

impl Clone for PaneTree

fn clone(&self) -> PaneTree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PaneTree

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

Formats the value using the given formatter.

impl PartialEq for PaneTree

fn eq(&self, other: &PaneTree) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PaneTree