Struct TreeModel 

pub struct TreeModel { /* private fields */ }

The lazy tree model. All methods are &mut self because expand/collapse mutate the cache; the UI mutates it freely since it owns it.

Implementations

impl TreeModel

pub fn new(root: PathBuf, sort: SortOptions, show_hidden: bool) -> Self

Create a model rooted at root, applying sort and hiding dotfiles unless show_hidden. The root node is created eagerly but its listing is only read on demand (lazy — the panel can start without blocking).

pub fn root(&self) -> &Path

The tree root directory.

pub fn filter(&self) -> &str

The current filter (lowercased). Empty means “no filter”.

pub fn set_filter(&mut self, filter: &str)

Set the type-ahead filter. Empty string clears it.

pub fn sort(&self) -> SortOptions

Current sorting rules.

pub fn set_sort(&mut self, sort: SortOptions)

Replace the sorting rules. Callers must re-read loaded listings (see Self::reload_all) for the change to take effect, since nodes cache their already-sorted entries.

pub fn show_hidden(&self) -> bool

Whether hidden (dot) entries are currently shown.

pub fn set_show_hidden(&mut self, show_hidden: bool)

Toggle hidden-file visibility. Callers must re-read loaded listings (see Self::reload_all) for the change to take effect.

pub fn reload_all(&mut self, src: &dyn DirSource)

Re-read every loaded directory so sort/hidden changes take effect. Expanded nodes are refreshed; collapses are unaffected. Errors on a single directory are ignored (that node simply becomes empty).

pub fn under_root(&self, path: &Path) -> bool

Whether path (strictly below, or equal to, the root) belongs to this tree.

pub fn is_expanded(&self, path: &Path) -> bool

True when the cached node for path is considered expanded.

pub fn node(&self, path: &Path) -> Option<&DirNode>

Cached listing for path, if that directory has been loaded.

pub fn expanded_loaded_dirs(&self) -> Vec<PathBuf>

Paths of every directory that is expanded and loaded — the set of directories the UI should be watching (the root is always in this set once open_root has expanded it). Used to keep the filesystem watcher aligned with the lazily-expanded tree.

pub fn expand(&mut self, path: &Path, src: &dyn DirSource) -> Result<(), Error>

Expand path, reading its listing the first time. Collapsed state is untouched: expanding a previously loaded (then collapsed) node is cheap.

pub fn collapse(&mut self, path: &Path)

Collapse path and drop its cached listing to free memory.

pub fn toggle(&mut self, path: &Path, src: &dyn DirSource) -> Result<(), Error>

Toggle expansion state of path, loading children on expand.

pub fn apply(&mut self, change: &Change, src: &dyn DirSource)

Apply a change event. Only loaded directories are refreshed, so unloaded parts of the tree stay untouched (cheap) and lazily re-read later anyway.

pub fn visible_rows(&self) -> Vec<VisibleRow>

Render the visible rows of the tree in display order.

The root directory itself is not included as a row — its path is shown in the toolbar path entry instead. Children of the root start at depth 0.

Filter semantics (MVP): the filter narrows the children shown beneath each expanded directory to name matches, and keeps a directory row visible (even when the name itself does not match) as long as a loaded descendant matches — the classic “show the path to the match” behaviour. Searching inside not-yet-expanded directories is intentionally not performed, to preserve lazy loading — full-tree search arrives with Phase 2 (ripgrep).

pub fn visible_rows_into(&self, out: &mut Vec<VisibleRow>)

Same as Self::visible_rows, but clears and refills a caller-owned buffer. Reusing one Vec across rebuilds avoids re-allocating the full row list (and its PathBuf/String payloads) on every interaction.