guise/input/

transfer.rs

//! `Transfer` — a dual-list membership editor (gpui entity).
//!
//! One item pool, two panes: items are either left (available) or right
//! (chosen). Click rows to check them, move checked items with the middle
//! buttons. Emits [`TransferEvent`] with the right side's indices after
//! every move.

use std::collections::BTreeSet;

use gpui::prelude::*;
use gpui::{div, px, Context, EventEmitter, FocusHandle, IntoElement, SharedString, Window};

use crate::devtools::Probed;
use crate::icon::{Icon, IconName};
use crate::theme::{theme, Size};

/// Emitted after a move. Carries the right pane's item indices, ascending.
#[derive(Debug, Clone)]
pub struct TransferEvent(pub Vec<usize>);

/// Move `checked ∩ side` to the other side; returns whether anything moved.
fn move_checked(
    right: &mut BTreeSet<usize>,
    checked: &mut BTreeSet<usize>,
    to_right: bool,
) -> bool {
    let movers: Vec<usize> = checked
        .iter()
        .copied()
        .filter(|i| right.contains(i) != to_right)
        .collect();
    for i in &movers {
        if to_right {
            right.insert(*i);
        } else {
            right.remove(i);
        }
        checked.remove(i);
    }
    !movers.is_empty()
}

/// A dual-list picker. Create with `cx.new(|cx| Transfer::new(cx).data([..]))`.
pub struct Transfer {
    items: Vec<SharedString>,
    right: BTreeSet<usize>,
    checked: BTreeSet<usize>,
    titles: (SharedString, SharedString),
    height: f32,
    focus: FocusHandle,
    disabled: bool,
}

impl EventEmitter<TransferEvent> for Transfer {}

impl Transfer {
    pub fn new(cx: &mut Context<Self>) -> Self {
        Transfer {
            items: Vec::new(),
            right: BTreeSet::new(),
            checked: BTreeSet::new(),
            titles: (
                SharedString::new_static("Available"),
                SharedString::new_static("Chosen"),
            ),
            height: 200.0,
            focus: cx.focus_handle(),
            disabled: false,
        }
    }

    pub fn data<I, S>(mut self, items: I) -> Self
    where
        I: IntoIterator<Item = S>,
        S: Into<SharedString>,
    {
        self.items = items.into_iter().map(Into::into).collect();
        self
    }

    /// Start with these item indices on the right side.
    pub fn chosen(mut self, indices: impl IntoIterator<Item = usize>) -> Self {
        self.right = indices.into_iter().collect();
        self
    }

    pub fn titles(mut self, left: impl Into<SharedString>, right: impl Into<SharedString>) -> Self {
        self.titles = (left.into(), right.into());
        self
    }

    pub fn height(mut self, height: f32) -> Self {
        self.height = height.max(80.0);
        self
    }

    pub fn disabled(mut self, disabled: bool) -> Self {
        self.disabled = disabled;
        self
    }

    /// The right pane's item indices, ascending.
    pub fn chosen_indices(&self) -> Vec<usize> {
        self.right.iter().copied().collect()
    }

    fn toggle_checked(&mut self, index: usize, cx: &mut Context<Self>) {
        if !self.checked.remove(&index) {
            self.checked.insert(index);
        }
        cx.notify();
    }

    fn transfer(&mut self, to_right: bool, cx: &mut Context<Self>) {
        if move_checked(&mut self.right, &mut self.checked, to_right) {
            cx.emit(TransferEvent(self.chosen_indices()));
            cx.notify();
        }
    }

    fn pane(
        &self,
        title: &SharedString,
        indices: Vec<usize>,
        list_id: &'static str,
        cx: &mut Context<Self>,
    ) -> impl IntoElement {
        let t = theme(cx);
        let radius = t.radius(t.default_radius);
        let surface = t.surface().hsla();
        let surface_hover = t.surface_hover().hsla();
        let border = t.border().hsla();
        let text_color = t.text().hsla();
        let dimmed = t.dimmed().hsla();
        let checked_bg = t.primary().alpha(0.12);
        let font = t.font_size(Size::Sm);

        let mut rows = div()
            .id(list_id)
            .flex()
            .flex_col()
            .gap(px(2.0))
            .p(px(4.0))
            .flex_1()
            .overflow_y_scroll();
        for i in indices {
            let is_checked = self.checked.contains(&i);
            let mut row = div()
                .id((list_id, i))
                .px(px(8.0))
                .py(px(5.0))
                .rounded(px(4.0))
                .text_size(px(font))
                .text_color(text_color)
                .child(self.items[i].clone())
                .on_click(cx.listener(move |this, _ev, _window, cx| {
                    if !this.disabled {
                        this.toggle_checked(i, cx);
                    }
                }));
            if is_checked {
                row = row.bg(checked_bg);
            } else {
                row = row.hover(move |s| s.bg(surface_hover));
            }
            rows = rows.child(row);
        }

        div()
            .flex()
            .flex_col()
            .flex_1()
            .h(px(self.height))
            .rounded(px(radius))
            .border_1()
            .border_color(border)
            .bg(surface)
            .child(
                div()
                    .px(px(8.0))
                    .py(px(5.0))
                    .border_b_1()
                    .border_color(border)
                    .text_size(px(font - 1.0))
                    .text_color(dimmed)
                    .child(title.clone()),
            )
            .child(rows)
    }
}

impl Render for Transfer {
    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let t = theme(cx);
        let surface = t.surface().hsla();
        let surface_hover = t.surface_hover().hsla();
        let border = t.border().hsla();
        let dimmed = t.dimmed().hsla();

        let left: Vec<usize> = (0..self.items.len())
            .filter(|i| !self.right.contains(i))
            .collect();
        let right: Vec<usize> = self.chosen_indices();

        let (left_title, right_title) = self.titles.clone();
        let left_pane = self.pane(&left_title, left, "guise-transfer-left", cx);
        let right_pane = self.pane(&right_title, right, "guise-transfer-right", cx);

        let mut buttons = div().flex().flex_col().justify_center().gap(px(6.0));
        for (key, icon, to_right) in [
            ("guise-transfer-toright", IconName::ChevronRight, true),
            ("guise-transfer-toleft", IconName::ChevronLeft, false),
        ] {
            buttons = buttons.child(
                div()
                    .id(key)
                    .flex()
                    .items_center()
                    .justify_center()
                    .w(px(26.0))
                    .h(px(26.0))
                    .rounded(px(6.0))
                    .bg(surface)
                    .border_1()
                    .border_color(border)
                    .text_color(dimmed)
                    .hover(move |s| s.bg(surface_hover))
                    .child(Icon::new(icon).size(Size::Xs))
                    .on_click(cx.listener(move |this, _ev, _window, cx| {
                        if !this.disabled {
                            this.transfer(to_right, cx);
                        }
                    })),
            );
        }

        let row = div()
            .track_focus(&self.focus)
            .flex()
            .items_center()
            .gap(px(10.0))
            .w_full()
            .child(left_pane)
            .child(buttons)
            .child(right_pane);

        let element = if self.disabled { row.opacity(0.6) } else { row };

        element.probe("Transfer")
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn moves_only_checked_items_on_the_source_side() {
        let mut right: BTreeSet<usize> = [3].into_iter().collect();
        let mut checked: BTreeSet<usize> = [0, 1, 3].into_iter().collect();
        // Moving right: 0 and 1 cross; 3 is already right so it stays checked-cleared? No —
        // it's skipped (not a mover) and stays checked.
        assert!(move_checked(&mut right, &mut checked, true));
        assert_eq!(right.iter().copied().collect::<Vec<_>>(), vec![0, 1, 3]);
        assert!(checked.contains(&3) && !checked.contains(&0));

        // Move 3 back left.
        assert!(move_checked(&mut right, &mut checked, false));
        assert_eq!(right.iter().copied().collect::<Vec<_>>(), vec![0, 1]);
        assert!(checked.is_empty());
    }

    #[test]
    fn no_movers_reports_false() {
        let mut right = BTreeSet::new();
        let mut checked = BTreeSet::new();
        assert!(!move_checked(&mut right, &mut checked, true));
        checked.insert(2);
        // 2 is on the left; moving left is a no-op.
        assert!(!move_checked(&mut right, &mut checked, false));
        assert!(checked.contains(&2));
    }
}