Enum SelectionMode 

pub enum SelectionMode {
    Replace,
    Toggle,
    ExtendRange,
}

How an incoming selection event composes with the existing set.

The three modes cover the three standard click idioms:

Mode	Effect on the selected set
SelectionMode::Replace	Clear everything; the path becomes the single selection.
SelectionMode::Toggle	Add the path if absent; remove it if present.
SelectionMode::ExtendRange	Select every visible row between the anchor and the target, inclusive. The anchor is unchanged.

Variants

Replace

Clear any existing selection; the new path becomes the only selected entry. This is what a plain left-click produces from the built-in view.

Toggle

Add the path to the selection if it isn’t already there, remove it otherwise. The anchor used for range extension is updated to point at this path regardless of whether it was added or removed.

ExtendRange

Select every visible row between the current anchor and the target path, inclusive, using the row order the widget renders. The anchor itself is not moved — successive range extensions all use the same starting pivot, which matches how Windows Explorer, macOS Finder, and VS Code behave.

If the anchor is unset, or if either the anchor or the target is not currently visible (filtered out, ancestor collapsed, not yet loaded), the tree falls back to SelectionMode::Replace semantics using just the target.

Implementations

impl SelectionMode

pub fn from_modifiers(modifiers: Modifiers) -> Self

Pick the mode implied by the active modifier keys.

The mapping is:

• Shift → SelectionMode::ExtendRange
• Ctrl or Logo (Command on macOS / Windows key elsewhere) → SelectionMode::Toggle
• otherwise → SelectionMode::Replace

Shift wins over Ctrl / Logo when both are held. A future release may distinguish “extend with toggle” (the Windows Explorer Ctrl+Shift+click behavior) with a fourth variant; for now Ctrl+Shift+click behaves as Shift-click.

Example

use iced::keyboard::Modifiers;
use iced_swdir_tree::SelectionMode;

// In your update handler, when you've received a click event
// and have tracked the current modifier state:
let mode = SelectionMode::from_modifiers(current_modifiers);
// Forward a rewritten Selected event to the widget.

Examples found in repository

examples/multi_select.rs (line 75)

    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 84)

    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()
            }
        }
    }

Trait Implementations

impl Clone for SelectionMode

fn clone(&self) -> SelectionMode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SelectionMode

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

Formats the value using the given formatter.

impl Default for SelectionMode

fn default() -> SelectionMode

Returns the “default value” for a type.

impl PartialEq for SelectionMode

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for SelectionMode

impl Eq for SelectionMode

impl StructuralPartialEq for SelectionMode