Struct DirectoryTree 

pub struct DirectoryTree { /* private fields */ }

A directory tree widget state.

Hold one DirectoryTree per visible tree in your application state. The widget is cheap to construct: DirectoryTree::new creates only the root node — child folders are scanned lazily when the user expands them.

Lifecycle

1. DirectoryTree::new — build with a root path.
2. Optionally chain DirectoryTree::with_filter and/or DirectoryTree::with_max_depth to configure.
3. Call DirectoryTree::view from your view function.
4. Route emitted DirectoryTreeEvents through your app’s message system and pass them to DirectoryTree::update, which returns an iced::Task the parent should .map(..) back into its own message type.

Implementations

impl DirectoryTree

pub fn handle_key( &self, key: &Key, modifiers: Modifiers, ) -> Option<DirectoryTreeEvent>

Translate a key press into the event that keyboard navigation should produce.

Returns None when the key has no binding in the current state (e.g. Right on a file, or Up when no row is selected and the tree is empty). Callers can safely ignore the None case.

This method is &self — it never mutates the tree. The returned event, if any, must be fed back through DirectoryTree::update like any other event so the existing state-machine (selection set, cache, generation counter) stays authoritative.

Example

use iced::keyboard;
// ...in your iced subscription function:
fn subscription(app: &App) -> iced::Subscription<Message> {
    keyboard::listen().map(|event| match event {
        keyboard::Event::KeyPressed { key, modifiers, .. } =>
            Message::TreeKey(key, modifiers),
        _ => Message::Noop,
    })
}

// ...in your update:
Message::TreeKey(key, mods) => {
    if let Some(event) = app.tree.handle_key(&key, mods) {
        return app.tree.update(event).map(Message::Tree);
    }
    Task::none()
}

Examples found in repository

examples/keyboard_nav.rs (line 70)

    fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            Message::Tree(event) => {
                if let DirectoryTreeEvent::Selected(p, _, _) = &event {
                    self.last_selected = Some(p.clone());
                }
                self.tree.update(event).map(Message::Tree)
            }
            Message::Key(key, mods) => {
                // handle_key is `&self` — it only *produces* an
                // event. We still have to route the returned event
                // back through update so state transitions (cursor
                // move, expand/collapse) actually happen.
                if let Some(event) = self.tree.handle_key(&key, mods) {
                    if let DirectoryTreeEvent::Selected(p, _, _) = &event {
                        self.last_selected = Some(p.clone());
                    }
                    return self.tree.update(event).map(Message::Tree);
                }
                Task::none()
            }
        }
    }

examples/multi_select.rs (line 85)

    fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            // Intercept plain-click `Selected` events and rewrite the
            // mode based on the current modifier state. The built-in
            // view always produces Replace; keyboard events produce
            // the right mode already (handled by handle_key).
            Message::Tree(DirectoryTreeEvent::Selected(path, is_dir, _from_view)) => {
                let mode = SelectionMode::from_modifiers(self.modifiers);
                let event = DirectoryTreeEvent::Selected(path, is_dir, mode);
                self.tree.update(event).map(Message::Tree)
            }
            Message::Tree(event) => self.tree.update(event).map(Message::Tree),
            Message::ModifiersChanged(m) => {
                self.modifiers = m;
                Task::none()
            }
            Message::Key(key, mods) => {
                if let Some(event) = self.tree.handle_key(&key, mods) {
                    return self.tree.update(event).map(Message::Tree);
                }
                Task::none()
            }
        }
    }

examples/drag_drop.rs (line 129)

    fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            // As in the multi-select example, rewrite the built-in
            // view's `Replace`-only `Selected` events using the
            // current modifier state. Keyboard events come through
            // `handle_key` with the correct mode already.
            Message::Tree(DirectoryTreeEvent::Selected(path, is_dir, _)) => {
                let mode = SelectionMode::from_modifiers(self.modifiers);
                let event = DirectoryTreeEvent::Selected(path, is_dir, mode);
                self.tree.update(event).map(Message::Tree)
            }
            // The headline case: the user released the mouse over a
            // valid drop target. Perform the actual filesystem
            // operation, then refresh affected folders so the tree
            // view reflects the new layout.
            Message::Tree(DirectoryTreeEvent::DragCompleted {
                sources,
                destination,
            }) => {
                let outcome = move_paths(&sources, &destination);
                self.status = outcome.summary();
                // The set of folders that need re-scanning: the
                // destination (for the newly-arrived entries) and
                // every source's parent (for the departed entries).
                let mut to_refresh: HashSet<PathBuf> = HashSet::new();
                to_refresh.insert(destination);
                for s in &sources {
                    if let Some(parent) = s.parent() {
                        to_refresh.insert(parent.to_path_buf());
                    }
                }
                // Issue a collapse+expand for each affected folder.
                // A collapse followed by a `Toggled` on the same
                // path is the simplest way in v0.4 to invalidate
                // the cached children and re-scan from scratch.
                let tasks: Vec<Task<Message>> = to_refresh
                    .into_iter()
                    .flat_map(|p| {
                        [
                            Task::done(Message::Tree(DirectoryTreeEvent::Toggled(p.clone()))),
                            Task::done(Message::Tree(DirectoryTreeEvent::Toggled(p))),
                        ]
                    })
                    .collect();
                Task::batch(tasks)
            }
            Message::Tree(event) => self.tree.update(event).map(Message::Tree),
            Message::ModifiersChanged(m) => {
                self.modifiers = m;
                Task::none()
            }
            Message::Key(key, mods) => {
                if let Some(event) = self.tree.handle_key(&key, mods) {
                    return self.tree.update(event).map(Message::Tree);
                }
                Task::none()
            }
        }
    }

impl DirectoryTree

pub fn update(&mut self, msg: DirectoryTreeEvent) -> Task<DirectoryTreeEvent>

Feed an event into the widget.

Returns an iced::Task the parent should .map(..) back into its own message type. For Selected this is always Task::none(); for Toggled on an unloaded folder it carries the pending async scan; for Loaded it is again Task::none().

Parent apps typically route every tree-related message here unconditionally:

fn update(&mut self, msg: MyMessage) -> Task<MyMessage> {
    match msg {
        MyMessage::Tree(e) => self.tree.update(e).map(MyMessage::Tree),
    }
}

Examples found in repository

examples/with_icons.rs (line 53)

    fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            Message::Tree(event) => {
                if let DirectoryTreeEvent::Selected(p, _, _) = &event {
                    self.last_selected = Some(p.clone());
                }
                self.tree.update(event).map(Message::Tree)
            }
            Message::SetFilter(filter) => {
                self.tree.set_filter(filter);
                Task::none()
            }
        }
    }

examples/icon_theme.rs (line 130)

    fn new() -> (Self, Task<Message>) {
        let root = resolve_root();
        let tree = DirectoryTree::new(root.clone())
            .with_filter(DirectoryFilter::FilesAndFolders)
            .with_icon_theme(ThemeChoice::Unicode.to_theme());
        let mut app = App {
            tree,
            choice: ThemeChoice::Unicode,
            root: root.clone(),
        };
        let task = app
            .tree
            .update(DirectoryTreeEvent::Toggled(root))
            .map(Message::Tree);
        (app, task)
    }

    fn update(&mut self, msg: Message) -> Task<Message> {
        match msg {
            Message::Tree(ev) => self.tree.update(ev).map(Message::Tree),
            Message::ThemePicked(choice) => {
                // Swapping a theme today requires rebuilding the
                // tree (it's set at construction via the builder).
                // We preserve nothing across the swap — a real app
                // would carry selection/expansion forward, but
                // this is a demo so a clean rebuild keeps it
                // short.
                self.choice = choice;
                self.tree = DirectoryTree::new(self.root.clone())
                    .with_filter(DirectoryFilter::FilesAndFolders)
                    .with_icon_theme(choice.to_theme());
                self.tree
                    .update(DirectoryTreeEvent::Toggled(self.root.clone()))
                    .map(Message::Tree)
            }
        }
    }

examples/basic.rs (line 52)

    fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            Message::Tree(event) => {
                // Side-effect: remember the last selection so we can
                // show it in the status bar.
                if let DirectoryTreeEvent::Selected(p, _, _) = &event {
                    self.last_selected = Some(p.clone());
                }
                self.tree.update(event).map(Message::Tree)
            }
            Message::SetFilter(filter) => {
                self.tree.set_filter(filter);
                Task::none()
            }
        }
    }

examples/search.rs (line 65)

    fn new() -> (Self, Task<Message>) {
        let root = resolve_root();
        let tree = DirectoryTree::new(root.clone())
            .with_filter(DirectoryFilter::FilesAndFolders)
            // Prefetch one level helps search cover more ground
            // without the user expanding everything manually.
            .with_prefetch_limit(20);
        let mut app = App {
            tree,
            query: String::new(),
        };
        // Kick off the initial scan of the root.
        let task = app
            .tree
            .update(DirectoryTreeEvent::Toggled(root))
            .map(Message::Tree);
        (app, task)
    }

    fn update(&mut self, msg: Message) -> Task<Message> {
        match msg {
            Message::Tree(ev) => self.tree.update(ev).map(Message::Tree),
            Message::SearchChanged(q) => {
                self.query = q.clone();
                self.tree.set_search_query(q);
                Task::none()
            }
            Message::ExpandAll => {
                // Toggle every loaded folder that isn't already
                // expanded. The widget's on_loaded handler will
                // cascade more scans via prefetch.
                let mut tasks = Vec::new();
                let to_expand = collect_collapsed_folders(&self.tree);
                for p in to_expand {
                    tasks.push(
                        self.tree
                            .update(DirectoryTreeEvent::Toggled(p))
                            .map(Message::Tree),
                    );
                }
                Task::batch(tasks)
            }
        }
    }

examples/keyboard_nav.rs (line 63)

    fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            Message::Tree(event) => {
                if let DirectoryTreeEvent::Selected(p, _, _) = &event {
                    self.last_selected = Some(p.clone());
                }
                self.tree.update(event).map(Message::Tree)
            }
            Message::Key(key, mods) => {
                // handle_key is `&self` — it only *produces* an
                // event. We still have to route the returned event
                // back through update so state transitions (cursor
                // move, expand/collapse) actually happen.
                if let Some(event) = self.tree.handle_key(&key, mods) {
                    if let DirectoryTreeEvent::Selected(p, _, _) = &event {
                        self.last_selected = Some(p.clone());
                    }
                    return self.tree.update(event).map(Message::Tree);
                }
                Task::none()
            }
        }
    }

examples/multi_select.rs (line 77)

    fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            // Intercept plain-click `Selected` events and rewrite the
            // mode based on the current modifier state. The built-in
            // view always produces Replace; keyboard events produce
            // the right mode already (handled by handle_key).
            Message::Tree(DirectoryTreeEvent::Selected(path, is_dir, _from_view)) => {
                let mode = SelectionMode::from_modifiers(self.modifiers);
                let event = DirectoryTreeEvent::Selected(path, is_dir, mode);
                self.tree.update(event).map(Message::Tree)
            }
            Message::Tree(event) => self.tree.update(event).map(Message::Tree),
            Message::ModifiersChanged(m) => {
                self.modifiers = m;
                Task::none()
            }
            Message::Key(key, mods) => {
                if let Some(event) = self.tree.handle_key(&key, mods) {
                    return self.tree.update(event).map(Message::Tree);
                }
                Task::none()
            }
        }
    }

Additional examples can be found in:

• examples/drag_drop.rs

impl DirectoryTree

pub fn view<'a, Message, F>(&'a self, on_event: F) -> Element<'a, Message>

where Message: Clone + 'a, F: Fn(DirectoryTreeEvent) -> Message + Copy + 'a,

Build an iced::Element that renders this tree.

on_event is the closure that maps the widget’s internal DirectoryTreeEvents into the parent application’s own message type. See the crate-level docs for a worked example.

Examples found in repository

examples/keyboard_nav.rs (line 115)

    fn view(&self) -> Element<'_, Message> {
        let status = text(match &self.last_selected {
            Some(p) => format!(
                "Selected: {}  |  Try ↑ ↓ ← →, Enter, Space, Home, End.",
                p.display()
            ),
            None => "Press ↓ to select the first row.".into(),
        })
        .size(12);

        container(
            column![self.tree.view(Message::Tree), status]
                .spacing(8.0)
                .padding(8.0),
        )
        .width(Length::Fill)
        .height(Length::Fill)
        .into()
    }

examples/icon_theme.rs (line 166)

    fn view(&self) -> Element<'_, Message> {
        let picker = pick_list(
            &ThemeChoice::ALL[..],
            Some(self.choice),
            Message::ThemePicked,
        );
        let header = row![text("Theme:").size(13), picker].spacing(8);

        column![
            header,
            container(self.tree.view(Message::Tree))
                .width(Length::Fill)
                .height(Length::Fill),
            text(
                "Switch themes to see the icon trait in action. \
                 The 'Label' and 'Ascii' themes are defined in \
                 this example file; 'Unicode' is shipped with \
                 the crate."
            )
            .size(12),
        ]
        .spacing(8)
        .padding(10)
        .into()
    }

examples/drag_drop.rs (line 171)

    fn view(&self) -> Element<'_, Message> {
        // While a drag is in progress, override the static status
        // line with a live preview of where the drop will land.
        let live_status = if self.tree.is_dragging() {
            match self.tree.drop_target() {
                Some(dest) => format!(
                    "Drop {} onto {}?",
                    describe_sources(self.tree.drag_sources()),
                    short_name(dest),
                ),
                None => format!(
                    "Dragging {} — hover over a folder",
                    describe_sources(self.tree.drag_sources()),
                ),
            }
        } else {
            self.status.clone()
        };

        let status = Column::new().push(text(live_status).size(13)).spacing(2);

        container(
            column![
                scrollable(self.tree.view(Message::Tree)).height(Length::Fill),
                status,
            ]
            .spacing(8.0)
            .padding(8.0),
        )
        .width(Length::Fill)
        .height(Length::Fill)
        .into()
    }

examples/search.rs (line 126)

    fn view(&self) -> Element<'_, Message> {
        let search_bar = text_input("Search filenames...", &self.query)
            .on_input(Message::SearchChanged)
            .padding(6);

        let status_text = if self.tree.is_searching() {
            format!(
                "{} match{} for \"{}\"",
                self.tree.search_match_count(),
                if self.tree.search_match_count() == 1 {
                    ""
                } else {
                    "es"
                },
                self.query,
            )
        } else {
            "Type above to filter. Press Expand-all to load deeper \
             folders for broader coverage."
                .into()
        };

        let controls = row![
            search_bar,
            button(text("Expand all")).on_press(Message::ExpandAll),
        ]
        .spacing(8);

        column![
            controls,
            container(self.tree.view(Message::Tree))
                .width(Length::Fill)
                .height(Length::Fill),
            text(status_text).size(13),
        ]
        .spacing(8)
        .padding(10)
        .into()
    }

examples/with_icons.rs (line 99)

    fn view(&self) -> Element<'_, Message> {
        use iced::widget::{button, column, container, row, text};

        let filter_row = row![
            text("Filter:"),
            button("Folders only")
                .on_press(Message::SetFilter(DirectoryFilter::FoldersOnly))
                .style(if self.tree.filter() == DirectoryFilter::FoldersOnly {
                    button::primary
                } else {
                    button::secondary
                }),
            button("Files + folders")
                .on_press(Message::SetFilter(DirectoryFilter::FilesAndFolders))
                .style(if self.tree.filter() == DirectoryFilter::FilesAndFolders {
                    button::primary
                } else {
                    button::secondary
                }),
            button("All (w/ hidden)")
                .on_press(Message::SetFilter(DirectoryFilter::AllIncludingHidden))
                .style(
                    if self.tree.filter() == DirectoryFilter::AllIncludingHidden {
                        button::primary
                    } else {
                        button::secondary
                    },
                ),
        ]
        .spacing(8.0);

        let status = text(match &self.last_selected {
            Some(p) => format!("Selected: {}", p.display()),
            None => "No selection yet. Click any row to select; click folders to expand.".into(),
        });

        container(
            column![filter_row, self.tree.view(Message::Tree), status]
                .spacing(8.0)
                .padding(8.0),
        )
        .width(Length::Fill)
        .height(Length::Fill)
        .into()
    }

examples/basic.rs (line 100)

    fn view(&self) -> Element<'_, Message> {
        use iced::widget::{button, column, container, row, text};

        // Three plain buttons for filter selection. Keeps the example
        // dependency-free of `Display` impls or pick_list complexity.
        let filter_row = row![
            text("Filter:"),
            button("Folders only")
                .on_press(Message::SetFilter(DirectoryFilter::FoldersOnly))
                .style(if self.tree.filter() == DirectoryFilter::FoldersOnly {
                    button::primary
                } else {
                    button::secondary
                }),
            button("Files + folders")
                .on_press(Message::SetFilter(DirectoryFilter::FilesAndFolders))
                .style(if self.tree.filter() == DirectoryFilter::FilesAndFolders {
                    button::primary
                } else {
                    button::secondary
                }),
            button("All (w/ hidden)")
                .on_press(Message::SetFilter(DirectoryFilter::AllIncludingHidden))
                .style(
                    if self.tree.filter() == DirectoryFilter::AllIncludingHidden {
                        button::primary
                    } else {
                        button::secondary
                    },
                ),
        ]
        .spacing(8.0);

        let status = text(match &self.last_selected {
            Some(p) => format!("Selected: {}", p.display()),
            None => "No selection yet. Click any row to select; click folders to expand.".into(),
        });

        container(
            column![filter_row, self.tree.view(Message::Tree), status]
                .spacing(8.0)
                .padding(8.0),
        )
        .width(Length::Fill)
        .height(Length::Fill)
        .into()
    }

Additional examples can be found in:

• examples/multi_select.rs

impl DirectoryTree

pub fn new(root: PathBuf) -> Self

Create a new tree rooted at root.

Only the root node is created eagerly; the first level of children is scanned when the user first expands the root (or, for convenience, when you call DirectoryTree::update with a Toggled(root) event yourself).

Defaults: DirectoryFilter::FilesAndFolders, no depth limit.

Examples found in repository

examples/basic.rs (line 34)

    fn new() -> (Self, Task<Message>) {
        let root = std::env::args()
            .nth(1)
            .map(PathBuf::from)
            .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));
        let tree = DirectoryTree::new(root).with_filter(DirectoryFilter::FilesAndFolders);
        (
            Self {
                tree,
                last_selected: None,
            },
            Task::none(),
        )
    }

examples/with_icons.rs (line 37)

    fn new() -> (Self, Task<Message>) {
        let root = std::env::args()
            .nth(1)
            .map(PathBuf::from)
            .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));
        let tree = DirectoryTree::new(root).with_filter(DirectoryFilter::FilesAndFolders);
        (
            Self {
                tree,
                last_selected: None,
            },
            Task::none(),
        )
    }

examples/icon_theme.rs (line 120)

    fn new() -> (Self, Task<Message>) {
        let root = resolve_root();
        let tree = DirectoryTree::new(root.clone())
            .with_filter(DirectoryFilter::FilesAndFolders)
            .with_icon_theme(ThemeChoice::Unicode.to_theme());
        let mut app = App {
            tree,
            choice: ThemeChoice::Unicode,
            root: root.clone(),
        };
        let task = app
            .tree
            .update(DirectoryTreeEvent::Toggled(root))
            .map(Message::Tree);
        (app, task)
    }

    fn update(&mut self, msg: Message) -> Task<Message> {
        match msg {
            Message::Tree(ev) => self.tree.update(ev).map(Message::Tree),
            Message::ThemePicked(choice) => {
                // Swapping a theme today requires rebuilding the
                // tree (it's set at construction via the builder).
                // We preserve nothing across the swap — a real app
                // would carry selection/expansion forward, but
                // this is a demo so a clean rebuild keeps it
                // short.
                self.choice = choice;
                self.tree = DirectoryTree::new(self.root.clone())
                    .with_filter(DirectoryFilter::FilesAndFolders)
                    .with_icon_theme(choice.to_theme());
                self.tree
                    .update(DirectoryTreeEvent::Toggled(self.root.clone()))
                    .map(Message::Tree)
            }
        }
    }

examples/drag_drop.rs (line 63)

    fn new() -> (Self, Task<Message>) {
        let root = resolve_root();
        let root_for_task = root.clone();
        let tree = DirectoryTree::new(root).with_filter(DirectoryFilter::FilesAndFolders);
        (
            Self {
                tree,
                modifiers: Modifiers::default(),
                status: "Drag a row onto a folder to move it. \
                         Shift/Ctrl-click for multi-select. \
                         Esc cancels an in-flight drag."
                    .to_string(),
            },
            Task::done(Message::Tree(DirectoryTreeEvent::Toggled(root_for_task))),
        )
    }

examples/multi_select.rs (line 57)

    fn new() -> (Self, Task<Message>) {
        let root = std::env::args()
            .nth(1)
            .map(PathBuf::from)
            .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));
        let root_for_task = root.clone();
        let tree = DirectoryTree::new(root).with_filter(DirectoryFilter::FilesAndFolders);
        (
            Self {
                tree,
                modifiers: Modifiers::default(),
            },
            // Kick off the first expansion so the user sees content.
            Task::done(Message::Tree(DirectoryTreeEvent::Toggled(root_for_task))),
        )
    }

examples/search.rs (line 53)

    fn new() -> (Self, Task<Message>) {
        let root = resolve_root();
        let tree = DirectoryTree::new(root.clone())
            .with_filter(DirectoryFilter::FilesAndFolders)
            // Prefetch one level helps search cover more ground
            // without the user expanding everything manually.
            .with_prefetch_limit(20);
        let mut app = App {
            tree,
            query: String::new(),
        };
        // Kick off the initial scan of the root.
        let task = app
            .tree
            .update(DirectoryTreeEvent::Toggled(root))
            .map(Message::Tree);
        (app, task)
    }

Additional examples can be found in:

• examples/keyboard_nav.rs

pub fn with_filter(self, filter: DirectoryFilter) -> Self

Set the display filter.

This is the builder form used at construction. For runtime filter changes call DirectoryTree::set_filter — or use this method with std::mem::replace / std::mem::take-style moves if that fits the shape of your state better. Either route re-derives visible children from the cache, so the tree updates instantly without re-scanning the filesystem.

Examples found in repository

examples/basic.rs (line 34)

    fn new() -> (Self, Task<Message>) {
        let root = std::env::args()
            .nth(1)
            .map(PathBuf::from)
            .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));
        let tree = DirectoryTree::new(root).with_filter(DirectoryFilter::FilesAndFolders);
        (
            Self {
                tree,
                last_selected: None,
            },
            Task::none(),
        )
    }

examples/with_icons.rs (line 37)

    fn new() -> (Self, Task<Message>) {
        let root = std::env::args()
            .nth(1)
            .map(PathBuf::from)
            .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));
        let tree = DirectoryTree::new(root).with_filter(DirectoryFilter::FilesAndFolders);
        (
            Self {
                tree,
                last_selected: None,
            },
            Task::none(),
        )
    }

examples/icon_theme.rs (line 121)

    fn new() -> (Self, Task<Message>) {
        let root = resolve_root();
        let tree = DirectoryTree::new(root.clone())
            .with_filter(DirectoryFilter::FilesAndFolders)
            .with_icon_theme(ThemeChoice::Unicode.to_theme());
        let mut app = App {
            tree,
            choice: ThemeChoice::Unicode,
            root: root.clone(),
        };
        let task = app
            .tree
            .update(DirectoryTreeEvent::Toggled(root))
            .map(Message::Tree);
        (app, task)
    }

    fn update(&mut self, msg: Message) -> Task<Message> {
        match msg {
            Message::Tree(ev) => self.tree.update(ev).map(Message::Tree),
            Message::ThemePicked(choice) => {
                // Swapping a theme today requires rebuilding the
                // tree (it's set at construction via the builder).
                // We preserve nothing across the swap — a real app
                // would carry selection/expansion forward, but
                // this is a demo so a clean rebuild keeps it
                // short.
                self.choice = choice;
                self.tree = DirectoryTree::new(self.root.clone())
                    .with_filter(DirectoryFilter::FilesAndFolders)
                    .with_icon_theme(choice.to_theme());
                self.tree
                    .update(DirectoryTreeEvent::Toggled(self.root.clone()))
                    .map(Message::Tree)
            }
        }
    }

examples/drag_drop.rs (line 63)

    fn new() -> (Self, Task<Message>) {
        let root = resolve_root();
        let root_for_task = root.clone();
        let tree = DirectoryTree::new(root).with_filter(DirectoryFilter::FilesAndFolders);
        (
            Self {
                tree,
                modifiers: Modifiers::default(),
                status: "Drag a row onto a folder to move it. \
                         Shift/Ctrl-click for multi-select. \
                         Esc cancels an in-flight drag."
                    .to_string(),
            },
            Task::done(Message::Tree(DirectoryTreeEvent::Toggled(root_for_task))),
        )
    }

examples/multi_select.rs (line 57)

    fn new() -> (Self, Task<Message>) {
        let root = std::env::args()
            .nth(1)
            .map(PathBuf::from)
            .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));
        let root_for_task = root.clone();
        let tree = DirectoryTree::new(root).with_filter(DirectoryFilter::FilesAndFolders);
        (
            Self {
                tree,
                modifiers: Modifiers::default(),
            },
            // Kick off the first expansion so the user sees content.
            Task::done(Message::Tree(DirectoryTreeEvent::Toggled(root_for_task))),
        )
    }

examples/search.rs (line 54)

    fn new() -> (Self, Task<Message>) {
        let root = resolve_root();
        let tree = DirectoryTree::new(root.clone())
            .with_filter(DirectoryFilter::FilesAndFolders)
            // Prefetch one level helps search cover more ground
            // without the user expanding everything manually.
            .with_prefetch_limit(20);
        let mut app = App {
            tree,
            query: String::new(),
        };
        // Kick off the initial scan of the root.
        let task = app
            .tree
            .update(DirectoryTreeEvent::Toggled(root))
            .map(Message::Tree);
        (app, task)
    }

Additional examples can be found in:

• examples/keyboard_nav.rs

pub fn with_max_depth(self, depth: u32) -> Self

Limit how deep the widget will load. depth == 0 means only the root’s direct children are ever loaded; depth == 1 allows one more level of descent; and so on. No limit by default.

pub fn with_prefetch_limit(self, limit: usize) -> Self

v0.5: configure parallel pre-expansion of visible descendants.

When a user-initiated expansion finishes loading a folder, the widget will eagerly issue background scans for up to limit of that folder’s direct children-that-are-folders, in parallel via the widget’s ScanExecutor. Those children’s data is loaded into the in-memory cache (is_loaded = true) but they are not automatically expanded in the UI — the user still controls what’s drawn. When they click to expand a prefetched child, no I/O happens: the expansion is instant.

Passing 0 (the default) disables prefetch and restores v0.1–0.4 behaviour exactly. Typical app values: 5–25, sized to the number of folder-children a user plausibly targets with their next click. A very high value effectively means “prefetch every child folder” — the crate doesn’t cap it, because apps with fast executors (tokio / rayon / smol) can legitimately want that.

let tree = DirectoryTree::new(root)
    .with_executor(my_tokio_executor)   // fast pool
    .with_prefetch_limit(20);           // up to 20 parallel scans

Prefetch is one level deep only: a folder that loaded via prefetch does not itself trigger further prefetches. This avoids the exponential limit ^ depth cascade that would otherwise paper-over I/O costs the user didn’t ask for.

Prefetch respects with_max_depth the same way user-initiated scans do — a prefetch target past the cap is skipped, not scanned.

See TreeConfig::prefetch_per_parent for the full contract.

Examples found in repository

examples/search.rs (line 57)

    fn new() -> (Self, Task<Message>) {
        let root = resolve_root();
        let tree = DirectoryTree::new(root.clone())
            .with_filter(DirectoryFilter::FilesAndFolders)
            // Prefetch one level helps search cover more ground
            // without the user expanding everything manually.
            .with_prefetch_limit(20);
        let mut app = App {
            tree,
            query: String::new(),
        };
        // Kick off the initial scan of the root.
        let task = app
            .tree
            .update(DirectoryTreeEvent::Toggled(root))
            .map(Message::Tree);
        (app, task)
    }

pub fn with_prefetch_skip<I, S>(self, names: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

v0.6.1: replace the prefetch skip list.

The list holds basenames that with_prefetch_limit- driven scans will refuse to enter. Match is exact-basename, ASCII case-insensitive — "target" skips target/ and Target/ but not my-target-files/. The list applies only to automatic prefetch; a user click on a skipped folder still expands it normally.

Replacing the list drops the default entries (see DEFAULT_PREFETCH_SKIP). To add entries while keeping the defaults, read them and append:

use iced_swdir_tree::{DirectoryTree, DEFAULT_PREFETCH_SKIP};

let mut skip: Vec<String> = DEFAULT_PREFETCH_SKIP
    .iter()
    .map(|&s| s.to_string())
    .collect();
skip.push("huge_media_library".into());

let tree = DirectoryTree::new(root)
    .with_prefetch_limit(10)
    .with_prefetch_skip(skip);

To disable skipping entirely (dangerous — means .git/ and node_modules/ will be prefetched), pass an empty list:

let tree = DirectoryTree::new(root)
    .with_prefetch_limit(10)
    .with_prefetch_skip(Vec::<String>::new());

See DEFAULT_PREFETCH_SKIP for the set populated by default.

pub fn with_executor(self, executor: Arc<dyn ScanExecutor>) -> Self

Route blocking scan_dir calls through a custom executor.

By default the widget spawns a fresh std::thread per expansion via ThreadExecutor. Apps that already manage a blocking-task pool (tokio, smol, rayon, …) can implement ScanExecutor and swap it in here:

use std::sync::Arc;
let tree = DirectoryTree::new(root).with_executor(Arc::new(MyTokioExecutor));

Calling this mid-session is allowed (the next scan will use the new executor); in-flight scans initiated under the old executor still complete through it.

pub fn with_icon_theme(self, theme: Arc<dyn IconTheme>) -> Self

v0.7: replace the icon theme.

Install an IconTheme implementation to control which glyph, font, and size the view uses for each IconRole (folder-closed / folder-open / file / caret-right / caret-down / error).

The crate ships two stock themes:

• UnicodeTheme — always available, renders short Unicode symbols (📁 📂 📄 ⚠ ▸ ▾). Default when the icons feature is disabled.
• LucideTheme — available with the icons feature, renders real lucide vector glyphs. Default when icons is enabled.

You don’t need to call this if you’re happy with the stock default — DirectoryTree::new picks the right one for your feature configuration automatically.

Custom themes implement the IconTheme trait. A minimal example:

use std::sync::Arc;
use iced_swdir_tree::{
    DirectoryTree, IconRole, IconSpec, IconTheme,
};

#[derive(Debug)]
struct LabelTheme;

impl IconTheme for LabelTheme {
    fn glyph(&self, role: IconRole) -> IconSpec {
        let label: &'static str = match role {
            IconRole::FolderClosed => "[D]",
            IconRole::FolderOpen => "[O]",
            IconRole::File => "[F]",
            IconRole::Error => "[!]",
            IconRole::CaretRight => ">",
            IconRole::CaretDown => "v",
            _ => "?",
        };
        IconSpec::new(label)
    }
}

let tree = DirectoryTree::new(".".into())
    .with_icon_theme(Arc::new(LabelTheme));

Note the _ => fallback: IconRole is #[non_exhaustive] so new variants may be added in future minor releases.

Examples found in repository

examples/icon_theme.rs (line 122)

    fn new() -> (Self, Task<Message>) {
        let root = resolve_root();
        let tree = DirectoryTree::new(root.clone())
            .with_filter(DirectoryFilter::FilesAndFolders)
            .with_icon_theme(ThemeChoice::Unicode.to_theme());
        let mut app = App {
            tree,
            choice: ThemeChoice::Unicode,
            root: root.clone(),
        };
        let task = app
            .tree
            .update(DirectoryTreeEvent::Toggled(root))
            .map(Message::Tree);
        (app, task)
    }

    fn update(&mut self, msg: Message) -> Task<Message> {
        match msg {
            Message::Tree(ev) => self.tree.update(ev).map(Message::Tree),
            Message::ThemePicked(choice) => {
                // Swapping a theme today requires rebuilding the
                // tree (it's set at construction via the builder).
                // We preserve nothing across the swap — a real app
                // would carry selection/expansion forward, but
                // this is a demo so a clean rebuild keeps it
                // short.
                self.choice = choice;
                self.tree = DirectoryTree::new(self.root.clone())
                    .with_filter(DirectoryFilter::FilesAndFolders)
                    .with_icon_theme(choice.to_theme());
                self.tree
                    .update(DirectoryTreeEvent::Toggled(self.root.clone()))
                    .map(Message::Tree)
            }
        }
    }

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

Change the display filter at runtime. The tree re-derives its visible children from the unfiltered cache, so the change is instant — no re-scan, no blocking the UI.

Selection is preserved. Selection is kept by path on the widget, not on the TreeNodes that this call rebuilds, so every selected path survives the filter swap. Paths that become invisible under the new filter are not lost — flipping the filter back re-reveals them unchanged. This is true for both single and multi-select.

Expansion state is preserved too. rebuild_from_cache copies the whole child subtree from the old node into its freshly-built replacement, so directories the user had opened stay open.

Examples found in repository

examples/with_icons.rs (line 56)

    fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            Message::Tree(event) => {
                if let DirectoryTreeEvent::Selected(p, _, _) = &event {
                    self.last_selected = Some(p.clone());
                }
                self.tree.update(event).map(Message::Tree)
            }
            Message::SetFilter(filter) => {
                self.tree.set_filter(filter);
                Task::none()
            }
        }
    }

examples/basic.rs (line 55)

    fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            Message::Tree(event) => {
                // Side-effect: remember the last selection so we can
                // show it in the status bar.
                if let DirectoryTreeEvent::Selected(p, _, _) = &event {
                    self.last_selected = Some(p.clone());
                }
                self.tree.update(event).map(Message::Tree)
            }
            Message::SetFilter(filter) => {
                self.tree.set_filter(filter);
                Task::none()
            }
        }
    }

pub fn root_path(&self) -> &Path

Return the root path.

Examples found in repository

examples/search.rs (line 161)

fn collect_collapsed_folders(tree: &DirectoryTree) -> Vec<PathBuf> {
    // There's no public "walk every node" API, so we do a BFS by
    // repeatedly querying visible_rows() of the tree's internal
    // view - but that requires crate-internal access. Instead, we
    // use the public root_path and do our own filesystem walk of
    // directories only.
    let mut out = Vec::new();
    fn recurse(p: &std::path::Path, out: &mut Vec<PathBuf>) {
        if !p.is_dir() {
            return;
        }
        out.push(p.to_path_buf());
        if let Ok(read) = fs::read_dir(p) {
            for entry in read.flatten() {
                let ep = entry.path();
                if ep.is_dir() {
                    recurse(&ep, out);
                }
            }
        }
    }
    recurse(tree.root_path(), &mut out);
    out
}

pub fn filter(&self) -> DirectoryFilter

Return the current filter.

Examples found in repository

examples/with_icons.rs (line 69)

    fn view(&self) -> Element<'_, Message> {
        use iced::widget::{button, column, container, row, text};

        let filter_row = row![
            text("Filter:"),
            button("Folders only")
                .on_press(Message::SetFilter(DirectoryFilter::FoldersOnly))
                .style(if self.tree.filter() == DirectoryFilter::FoldersOnly {
                    button::primary
                } else {
                    button::secondary
                }),
            button("Files + folders")
                .on_press(Message::SetFilter(DirectoryFilter::FilesAndFolders))
                .style(if self.tree.filter() == DirectoryFilter::FilesAndFolders {
                    button::primary
                } else {
                    button::secondary
                }),
            button("All (w/ hidden)")
                .on_press(Message::SetFilter(DirectoryFilter::AllIncludingHidden))
                .style(
                    if self.tree.filter() == DirectoryFilter::AllIncludingHidden {
                        button::primary
                    } else {
                        button::secondary
                    },
                ),
        ]
        .spacing(8.0);

        let status = text(match &self.last_selected {
            Some(p) => format!("Selected: {}", p.display()),
            None => "No selection yet. Click any row to select; click folders to expand.".into(),
        });

        container(
            column![filter_row, self.tree.view(Message::Tree), status]
                .spacing(8.0)
                .padding(8.0),
        )
        .width(Length::Fill)
        .height(Length::Fill)
        .into()
    }

examples/basic.rs (line 70)

    fn view(&self) -> Element<'_, Message> {
        use iced::widget::{button, column, container, row, text};

        // Three plain buttons for filter selection. Keeps the example
        // dependency-free of `Display` impls or pick_list complexity.
        let filter_row = row![
            text("Filter:"),
            button("Folders only")
                .on_press(Message::SetFilter(DirectoryFilter::FoldersOnly))
                .style(if self.tree.filter() == DirectoryFilter::FoldersOnly {
                    button::primary
                } else {
                    button::secondary
                }),
            button("Files + folders")
                .on_press(Message::SetFilter(DirectoryFilter::FilesAndFolders))
                .style(if self.tree.filter() == DirectoryFilter::FilesAndFolders {
                    button::primary
                } else {
                    button::secondary
                }),
            button("All (w/ hidden)")
                .on_press(Message::SetFilter(DirectoryFilter::AllIncludingHidden))
                .style(
                    if self.tree.filter() == DirectoryFilter::AllIncludingHidden {
                        button::primary
                    } else {
                        button::secondary
                    },
                ),
        ]
        .spacing(8.0);

        let status = text(match &self.last_selected {
            Some(p) => format!("Selected: {}", p.display()),
            None => "No selection yet. Click any row to select; click folders to expand.".into(),
        });

        container(
            column![filter_row, self.tree.view(Message::Tree), status]
                .spacing(8.0)
                .padding(8.0),
        )
        .width(Length::Fill)
        .height(Length::Fill)
        .into()
    }

pub fn max_depth(&self) -> Option<u32>

Return the current max depth, if any.

pub fn selected_path(&self) -> Option<&Path>

Return a reference to the currently-active selected path, if any.

The active path is the path the user most recently acted on — the last row clicked, the last Space-toggled, the last target of a Shift-range, etc. For single-select applications this is exactly the one selected path and matches v0.2 semantics.

For multi-select, use DirectoryTree::selected_paths to see the whole set and DirectoryTree::anchor_path to read the pivot for range extension.

The returned path may point to a node that is currently invisible (because an ancestor is collapsed, or because the active filter hides it); the view layer handles that gracefully.

pub fn selected_paths(&self) -> &[PathBuf]

All currently-selected paths.

Order is not semantically meaningful — treat the slice as a set. The slice is empty iff nothing is selected. Runs in O(1) (returns a reference to the internal Vec).

Examples found in repository

examples/multi_select.rs (line 110)

    fn view(&self) -> Element<'_, Message> {
        let selected = self.tree.selected_paths();
        let count = selected.len();

        // Human-readable summary of currently-selected rows.
        let summary_text = if count == 0 {
            "No selection. Click to select, Shift+click for range, \
             Ctrl/Cmd+click to toggle."
                .to_string()
        } else {
            format!(
                "{count} selected (anchor: {})",
                self.tree
                    .anchor_path()
                    .map(short_name)
                    .unwrap_or_else(|| "-".into())
            )
        };

        // Compact list of selected basenames. Capped to avoid the
        // status bar eating the screen when the user ranges over
        // a huge folder.
        const MAX_SHOWN: usize = 10;
        let names: HashSet<String> = selected.iter().map(|p| short_name(p)).collect();
        let mut names_sorted: Vec<String> = names.into_iter().collect();
        names_sorted.sort();
        let shown: String = if names_sorted.len() <= MAX_SHOWN {
            names_sorted.join(", ")
        } else {
            format!(
                "{}, +{} more",
                names_sorted
                    .iter()
                    .take(MAX_SHOWN)
                    .cloned()
                    .collect::<Vec<_>>()
                    .join(", "),
                names_sorted.len() - MAX_SHOWN
            )
        };

        let status = Column::new()
            .push(text(summary_text).size(13))
            .push(text(shown).size(11))
            .spacing(2);

        container(
            column![
                scrollable(self.tree.view(Message::Tree)).height(Length::Fill),
                status,
            ]
            .spacing(8.0)
            .padding(8.0),
        )
        .width(Length::Fill)
        .height(Length::Fill)
        .into()
    }

pub fn anchor_path(&self) -> Option<&Path>

The anchor used as the pivot for SelectionMode::ExtendRange.

The anchor is set by Replace and Toggle selections, and is not moved by ExtendRange — so two successive Shift+clicks from the same starting point select different ranges with the same origin.

Returns None before the first selection.

Examples found in repository

examples/multi_select.rs (line 122)

    fn view(&self) -> Element<'_, Message> {
        let selected = self.tree.selected_paths();
        let count = selected.len();

        // Human-readable summary of currently-selected rows.
        let summary_text = if count == 0 {
            "No selection. Click to select, Shift+click for range, \
             Ctrl/Cmd+click to toggle."
                .to_string()
        } else {
            format!(
                "{count} selected (anchor: {})",
                self.tree
                    .anchor_path()
                    .map(short_name)
                    .unwrap_or_else(|| "-".into())
            )
        };

        // Compact list of selected basenames. Capped to avoid the
        // status bar eating the screen when the user ranges over
        // a huge folder.
        const MAX_SHOWN: usize = 10;
        let names: HashSet<String> = selected.iter().map(|p| short_name(p)).collect();
        let mut names_sorted: Vec<String> = names.into_iter().collect();
        names_sorted.sort();
        let shown: String = if names_sorted.len() <= MAX_SHOWN {
            names_sorted.join(", ")
        } else {
            format!(
                "{}, +{} more",
                names_sorted
                    .iter()
                    .take(MAX_SHOWN)
                    .cloned()
                    .collect::<Vec<_>>()
                    .join(", "),
                names_sorted.len() - MAX_SHOWN
            )
        };

        let status = Column::new()
            .push(text(summary_text).size(13))
            .push(text(shown).size(11))
            .spacing(2);

        container(
            column![
                scrollable(self.tree.view(Message::Tree)).height(Length::Fill),
                status,
            ]
            .spacing(8.0)
            .padding(8.0),
        )
        .width(Length::Fill)
        .height(Length::Fill)
        .into()
    }

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

true if path is in the selected set. O(n) in the set size.

pub fn is_dragging(&self) -> bool

true when a drag gesture is in progress.

Apps can use this to dim unrelated UI or change cursors, but the widget’s own rendering already reflects drag state via the drop-target highlight.

Examples found in repository

examples/drag_drop.rs (line 151)

    fn view(&self) -> Element<'_, Message> {
        // While a drag is in progress, override the static status
        // line with a live preview of where the drop will land.
        let live_status = if self.tree.is_dragging() {
            match self.tree.drop_target() {
                Some(dest) => format!(
                    "Drop {} onto {}?",
                    describe_sources(self.tree.drag_sources()),
                    short_name(dest),
                ),
                None => format!(
                    "Dragging {} — hover over a folder",
                    describe_sources(self.tree.drag_sources()),
                ),
            }
        } else {
            self.status.clone()
        };

        let status = Column::new().push(text(live_status).size(13)).spacing(2);

        container(
            column![
                scrollable(self.tree.view(Message::Tree)).height(Length::Fill),
                status,
            ]
            .spacing(8.0)
            .padding(8.0),
        )
        .width(Length::Fill)
        .height(Length::Fill)
        .into()
    }

pub fn drop_target(&self) -> Option<&Path>

Read-only view of the currently-hovered drop target, iff a drag is in progress and the cursor is over a valid folder.

Returns None when there is no drag, or when the cursor is over an invalid target (a file, one of the sources, a descendant of a source, or empty space).

Examples found in repository

examples/drag_drop.rs (line 152)

    fn view(&self) -> Element<'_, Message> {
        // While a drag is in progress, override the static status
        // line with a live preview of where the drop will land.
        let live_status = if self.tree.is_dragging() {
            match self.tree.drop_target() {
                Some(dest) => format!(
                    "Drop {} onto {}?",
                    describe_sources(self.tree.drag_sources()),
                    short_name(dest),
                ),
                None => format!(
                    "Dragging {} — hover over a folder",
                    describe_sources(self.tree.drag_sources()),
                ),
            }
        } else {
            self.status.clone()
        };

        let status = Column::new().push(text(live_status).size(13)).spacing(2);

        container(
            column![
                scrollable(self.tree.view(Message::Tree)).height(Length::Fill),
                status,
            ]
            .spacing(8.0)
            .padding(8.0),
        )
        .width(Length::Fill)
        .height(Length::Fill)
        .into()
    }

pub fn drag_sources(&self) -> &[PathBuf]

Read-only view of the paths being dragged, iff a drag is in progress. Empty slice if there’s no drag.

Examples found in repository

examples/drag_drop.rs (line 155)

    fn view(&self) -> Element<'_, Message> {
        // While a drag is in progress, override the static status
        // line with a live preview of where the drop will land.
        let live_status = if self.tree.is_dragging() {
            match self.tree.drop_target() {
                Some(dest) => format!(
                    "Drop {} onto {}?",
                    describe_sources(self.tree.drag_sources()),
                    short_name(dest),
                ),
                None => format!(
                    "Dragging {} — hover over a folder",
                    describe_sources(self.tree.drag_sources()),
                ),
            }
        } else {
            self.status.clone()
        };

        let status = Column::new().push(text(live_status).size(13)).spacing(2);

        container(
            column![
                scrollable(self.tree.view(Message::Tree)).height(Length::Fill),
                status,
            ]
            .spacing(8.0)
            .padding(8.0),
        )
        .width(Length::Fill)
        .height(Length::Fill)
        .into()
    }

pub fn set_search_query(&mut self, query: impl Into<String>)

v0.6: set or update the incremental search query.

Apps typically call this from their TextInput’s on_input callback. The widget narrows its visible rows to those whose basename matches the query as a case-insensitive substring — plus every ancestor of every match, so the user sees the tree context leading to their matches.

// In your update handler:
Message::SearchChanged(q) => {
    self.tree.set_search_query(q);
    Task::none()
}

An empty string clears the search — equivalent to clear_search. This is a deliberate simplification: having three states (none / empty-string / non-empty-string) tends to produce surprising UI where clearing the text box leaves the widget in a visually identical-but-semantically-distinct “searching for nothing” mode. With this contract there are only two states.

Search operates on already-loaded nodes only. Matches inside unloaded folders don’t appear until the folder loads (by user expansion or v0.5 prefetch). It does descend into loaded-but-collapsed folders, though — collapsed state doesn’t hide content from search.

Selection (including multi-selection) is orthogonal to search and is fully preserved: a selected row hidden by the query stays selected, and reappears when the query clears.

See the crate-internal search module for the full contract (visible in the source tree at src/directory_tree/search.rs).

Examples found in repository

examples/search.rs (line 75)

    fn update(&mut self, msg: Message) -> Task<Message> {
        match msg {
            Message::Tree(ev) => self.tree.update(ev).map(Message::Tree),
            Message::SearchChanged(q) => {
                self.query = q.clone();
                self.tree.set_search_query(q);
                Task::none()
            }
            Message::ExpandAll => {
                // Toggle every loaded folder that isn't already
                // expanded. The widget's on_loaded handler will
                // cascade more scans via prefetch.
                let mut tasks = Vec::new();
                let to_expand = collect_collapsed_folders(&self.tree);
                for p in to_expand {
                    tasks.push(
                        self.tree
                            .update(DirectoryTreeEvent::Toggled(p))
                            .map(Message::Tree),
                    );
                }
                Task::batch(tasks)
            }
        }
    }

pub fn clear_search(&mut self)

Clear the active search query, if any. No-op if there is no active search.

After this call is_searching returns false, search_query returns None, and the widget returns to its normal view where rows are hidden only by is_expanded chain (plus the ordinary DirectoryFilter).

pub fn search_query(&self) -> Option<&str>

The current search query as the application set it (preserving the app’s original case), or None when search is inactive.

pub fn is_searching(&self) -> bool

true iff a search query is currently active.

Convenience wrapper around search_query; apps can use either depending on taste.

Examples found in repository

examples/search.rs (line 101)

    fn view(&self) -> Element<'_, Message> {
        let search_bar = text_input("Search filenames...", &self.query)
            .on_input(Message::SearchChanged)
            .padding(6);

        let status_text = if self.tree.is_searching() {
            format!(
                "{} match{} for \"{}\"",
                self.tree.search_match_count(),
                if self.tree.search_match_count() == 1 {
                    ""
                } else {
                    "es"
                },
                self.query,
            )
        } else {
            "Type above to filter. Press Expand-all to load deeper \
             folders for broader coverage."
                .into()
        };

        let controls = row![
            search_bar,
            button(text("Expand all")).on_press(Message::ExpandAll),
        ]
        .spacing(8);

        column![
            controls,
            container(self.tree.view(Message::Tree))
                .width(Length::Fill)
                .height(Length::Fill),
            text(status_text).size(13),
        ]
        .spacing(8)
        .padding(10)
        .into()
    }

pub fn search_match_count(&self) -> usize

Count of nodes that directly match the current search query.

Returns 0 when no search is active. This is distinct from “visible rows” — the visible set also includes ancestor breadcrumbs leading down to matches, which are typically not what the user wants counted in their UI’s “X results” display.

Examples found in repository

examples/search.rs (line 104)

    fn view(&self) -> Element<'_, Message> {
        let search_bar = text_input("Search filenames...", &self.query)
            .on_input(Message::SearchChanged)
            .padding(6);

        let status_text = if self.tree.is_searching() {
            format!(
                "{} match{} for \"{}\"",
                self.tree.search_match_count(),
                if self.tree.search_match_count() == 1 {
                    ""
                } else {
                    "es"
                },
                self.query,
            )
        } else {
            "Type above to filter. Press Expand-all to load deeper \
             folders for broader coverage."
                .into()
        };

        let controls = row![
            search_bar,
            button(text("Expand all")).on_press(Message::ExpandAll),
        ]
        .spacing(8);

        column![
            controls,
            container(self.tree.view(Message::Tree))
                .width(Length::Fill)
                .height(Length::Fill),
            text(status_text).size(13),
        ]
        .spacing(8)
        .padding(10)
        .into()
    }