Struct TreeDataSlice 

pub struct TreeDataSlice<K: ItemKey, T> { /* private fields */ }

Per-view flattened projection of an external, indent-ordered tree source. See the module documentation.

Implementations

impl<K: ItemKey, T> TreeDataSlice<K, T>

pub fn new() -> Self

Create an empty slice. Configure it (set_source / set_reorder / policies / set_expand_new_nodes) then populate with reload or set_rows.

pub fn set_source(&self, f: impl Fn() -> Vec<TreeRow<K, T>> + 'static)

Install the row source (rows::load). reload and a committed drop call it to re-materialise the tree.

pub fn set_reorder(&self, f: impl Fn(K, K, DropPosition) -> bool + 'static)

Install the reorder command (dragged, target, position -> applied). Without one, drops are refused.

pub fn set_drag_policy(&self, f: impl Fn(&K) -> DragEligibility + 'static)

Install the per-row drag gate. Without one, no row is draggable.

pub fn set_drop_resolver( &self, f: impl Fn(&K, &K, &T, DropPosition) -> Option<DropPosition> + 'static, )

Install the domain drop resolver. The engine’s cycle guard (no drop into your own subtree, no self-drop) runs first, then hands the resolver (dragged, target, target_item, position); return Some(pos) to accept at pos (a different pos snaps the indicator, i.e. DropResponse::Redirect) or None to forbid. Without one, any non-cyclic drop is accepted at the requested position.

pub fn set_expand_new_nodes(&self, expand: bool)

Whether nodes appearing for the first time start expanded (true) or collapsed (false, the default, matching TreeSlice). Set this before the first populate to affect the initial rows.

pub fn from_rows(rows: Vec<TreeRow<K, T>>) -> Self

Build a slice directly from an initial row stream (no version bump / no divergence — construction is not a change).

pub fn reload(&self)

where T: PartialEq,

Re-source the rows via the set_source closure and reproject. No-op if no source is installed.

pub fn set_rows(&self, rows: Vec<TreeRow<K, T>>)

where T: PartialEq,

Replace the rows with a freshly-sourced stream, preserving per-view expand state by key, computing first_changed_index, and bumping the version signal.

pub fn visible_count(&self) -> usize

Number of currently-visible (flattened) rows.

pub fn with_entry<R>( &self, flat_index: usize, f: impl FnOnce(&T, &FlatEntry<K>) -> R, ) -> Option<R>

Access the item + flat metadata at a visible index via callback.

pub fn with_key<R>(&self, key: &K, f: impl FnOnce(&T) -> R) -> Option<R>

Access a node’s item by key via callback, regardless of visibility (a node hidden under a collapsed ancestor is still reachable). Returns None if the key is absent from the source. The by-key counterpart of with_entry (which is by visible index) — use it to resolve a key to its domain payload.

pub fn key_at(&self, flat_index: usize) -> Option<K>

The key of the row at a visible index.

pub fn entry_at(&self, flat_index: usize) -> Option<FlatEntry<K>>

The FlatEntry at a visible index (cloned).

pub fn depth_at(&self, flat_index: usize) -> usize

Structural depth at a visible index (0 for a root).

pub fn flat_index_of(&self, key: &K) -> Option<usize>

The visible index of a key, if currently visible.

pub fn contains_key(&self, key: &K) -> bool

Whether key still exists in the source, independent of visibility (a node hidden under a collapsed ancestor still exists).

pub fn parent_of(&self, key: &K) -> Option<K>

The parent of a node (None for a root or an absent key).

pub fn child_keys_of(&self, key: &K) -> Vec<K>

The children of a node, in order (empty for a leaf / absent key). O(children).

pub fn is_expanded(&self, key: &K) -> bool

Whether the node is effectively expanded (its children shown) — true for every branch while the set_all_expanded reveal override is on, otherwise its per-view expand state. Use expanded_keys for the persistent set.

pub fn expand(&self, key: &K)

where T: PartialEq,

Expand a node (make its children visible).

pub fn collapse(&self, key: &K)

where T: PartialEq,

Collapse a node (hide its children).

pub fn toggle(&self, key: &K)

where T: PartialEq,

Toggle a node’s expand state.

pub fn expand_all(&self)

where T: PartialEq,

Expand every node that has children.

pub fn collapse_all(&self)

where T: PartialEq,

Collapse every node (only roots remain visible).

pub fn expanded_keys(&self) -> Vec<K>

The currently-expanded keys (for persistence).

pub fn set_expanded_keys(&self, keys: &[K])

where T: PartialEq,

Restore expanded state (for persistence). Keys absent from the source are ignored on the next reflatten.

pub fn version_signal(&self) -> Signal<u64>

Version signal — bind at BindingLevel::Rebuild. Bumps on every set_rows / expand / collapse.

pub fn first_changed_index(&self) -> Option<usize>

First visible index whose content may differ after the latest change — rows 0..index are unchanged (same key, depth, has-children, expand, and item content), so per-row derived state remains valid for them. Equal to visible_count() when nothing visible changed; None before the first change (construction is not a change).

pub fn set_all_expanded(&self, on: bool)

where T: PartialEq,

Reveal override for a filtered view: when on, the flatten treats every node as expanded, so all rows in the (already sort/filter-narrowed) stream are visible — the ancestors TreeRowFilter::KeepAncestors keeps no longer hide their matching descendants. The per-view expand set is preserved underneath, so turning it off restores the user’s real collapse state. Flip it on with the filter and off when it clears. No-op if unchanged.

pub fn all_expanded(&self) -> bool

Whether the reveal-all override is on (see set_all_expanded).

Trait Implementations

impl<K: ItemKey, T> Clone for TreeDataSlice<K, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: ItemKey, T> Debug for TreeDataSlice<K, T>

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

Formats the value using the given formatter.

impl<K: ItemKey, T> Default for TreeDataSlice<K, T>

fn default() -> Self

Returns the “default value” for a type.

impl<K: ItemKey, T: PartialEq + 'static> TreeDataSource for TreeDataSlice<K, T>

TreeDataSlice is a reusable per-view TreeDataSource over an external, indent-ordered source. Identity is the domain key K; a SameView drop is resolved by the cycle guard + injected drop resolver and applied via the injected reorder command (then the slice re-sources). Foreign drops are rejected.

type Item = T

The item type stored at each node.

type Key = K

The stable per-node identity (NodeId for in-memory trees, an entity id for an external store).

fn visible_count(&self) -> usize

Number of currently-visible (flattened) rows.

fn with_entry<R>( &self, flat_index: usize, f: impl FnOnce(&Self::Item, &FlatEntry<Self::Key>) -> R, ) -> Option<R>

Access the item + flat metadata at a visible index via callback.

fn key_at(&self, flat_index: usize) -> Option<K>

The key of the row at a visible index.

fn flat_index_of(&self, key: &K) -> Option<usize>

The visible index of a key, if currently visible.

fn parent(&self, key: &K) -> Option<K>

The parent of a node (None for a root) — drives sibling nav + the drop cycle-guard.

fn child_keys(&self, key: &K) -> Vec<K>

The children of a node, in order.

fn version_signal(&self) -> Signal<u64>

A version signal that bumps on every structural/projection change — the view binds it at BindingLevel::Rebuild.

fn first_changed_index(&self) -> Option<usize>

First visible index whose content may differ after the latest change — rows 0..index are unchanged, so per-row derived state (e.g. a measured height) remains valid. None means unknown (treat as a full change).

fn contains_key(&self, key: &K) -> bool

Whether key still exists in the source, independent of visibility — a node hidden under a collapsed ancestor (or scrolled out of a lazy window) still exists. Drives keyed-selection pruning, so that a collapsed-but-present node keeps its selection and only a deleted node is dropped. Default: visible-only (flat_index_of(key).is_some()); sources whose nodes persist while collapsed/scrolled out should override this to consult their full store.

fn is_expanded(&self, key: &K) -> bool

Whether the node is expanded.

fn set_expanded(&self, key: &K, expanded: bool)

Expand (true) or collapse (false) the node.

fn drag(&self, key: &K) -> DragEligibility

Whether the node may begin a drag (the transferable gate).

fn can_accept(&self, query: &DropQuery<'_, K>) -> DropResponse

Whether a hovered drop is permitted (and where) — the pre-commit verdict.

fn accept_drop(&self, commit: DropCommit<'_, K>) -> bool

Apply a committed drop. Returns whether it was applied.

fn reorder_within( &self, sources: &[Self::Key], target: &Self::Key, position: DropPosition, ) -> bool

Reorder a whole set of this source’s OWN nodes so they land contiguously at a drop gap — the multi-row same-view reorder commit. sources are the dragged nodes’ keys in visible order; target / position name the drop gap. Returns whether anything moved.

fn on_drag_out(&self, _key: &Self::Key)

Called on the origin source after one of its rows was accepted by a different view (source-side completion). Sources backed by a shared / command model no-op this; independent models use it to drop the moved row.

fn row_state(&self, _flat_index: usize) -> RowState

Whether the row at a visible index is loaded.

fn request_window(&self, _range: Range<usize>)

Nudge the source to load the given visible range (the view calls this each build with its visible + buffer window).

fn can_fetch_more(&self) -> bool

Whether more rows can be appended (infinite scroll).

fn fetch_more(&self)

Fetch the next page (append-only growth).