Enum DirectoryTreeEvent 

pub enum DirectoryTreeEvent {
    Toggled(PathBuf),
    Selected(PathBuf, bool, SelectionMode),
    Drag(DragMsg),
    DragCompleted {
        sources: Vec<PathBuf>,
        destination: PathBuf,
    },
    Loaded(LoadPayload),
}

A message emitted by or consumed by the DirectoryTree widget.

For parent applications

Wrap this in one of your own Message variants:

enum MyMessage {
    Tree(iced_swdir_tree::DirectoryTreeEvent),
    // ...
}

Route every Tree(event) to DirectoryTree::update and map its returned Task back. Pattern-match on Toggled / Selected before forwarding if you want app-level side effects (e.g. previewing the selected file):

fn update(&mut self, msg: MyMessage) -> Task<MyMessage> {
    match msg {
        MyMessage::Tree(event) => {
            if let DirectoryTreeEvent::Selected(path, _, _) = &event {
                self.preview(path);
            }
            self.tree.update(event).map(MyMessage::Tree)
        }
    }
}

Variants

Toggled(PathBuf)

A folder was toggled open/closed by the user.

On first expansion the widget issues an async scan whose result arrives later as DirectoryTreeEvent::Loaded. Subsequent toggles of the same folder are instant — children stay in the internal cache.

Selected(PathBuf, bool, SelectionMode)

A row was selected.

The bool indicates whether the path is a directory (true) or a file (false). The SelectionMode controls how the click composes with any existing selection — see its docs for the full matrix.

The built-in view always emits this with SelectionMode::Replace because iced 0.14’s button callbacks cannot observe modifier keys at press time. Applications that want multi-select track modifier state themselves (see examples/multi_select.rs) and rewrite the mode before forwarding the event — SelectionMode::from_modifiers makes that a one-liner.

Drag(DragMsg)

Internal drag-machinery event.

Emitted by the widget’s built-in view as the user presses a row, moves across others, and releases. Applications should treat these as opaque and always route them back to DirectoryTree::update — just like Loaded.

The widget’s internal state machine may produce a Selected or a DragCompleted as the downstream effect of a Drag message. Apps observe those downstream events via the usual .map(MyMessage::Tree) routing — no extra plumbing needed.

DragCompleted

The user completed a drag gesture with intent to move (or otherwise transplant) sources into destination.

The widget performs no filesystem operation on its own. Applications observe this event, perform whatever action they wish (move, copy, symlink, upload, ignore), and re-scan affected folders by emitting Toggled events (collapse then re-expand) to refresh the tree view.

destination is guaranteed to be a directory that is not itself in sources nor a descendant of any source — see DragMsg for the validity rules. sources is non-empty.

Fields

sources: Vec<PathBuf>

One or more paths the user started dragging. This is the selected set at drag start if the pressed row was in the selection, otherwise just the pressed row.

destination: PathBuf

The folder over which the user released the mouse.

Loaded(LoadPayload)

Internal: an asynchronous scan completed.

Parent applications should not construct this variant themselves; it is produced by iced::Tasks that DirectoryTree::update returns and is routed back to update through the app’s message plumbing. Treat it as opaque.

Trait Implementations

impl Clone for DirectoryTreeEvent

fn clone(&self) -> DirectoryTreeEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DirectoryTreeEvent

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

Formats the value using the given formatter.