vizia_core/views/

list.rs

use std::{collections::BTreeSet, ops::Deref, rc::Rc};

use crate::prelude::*;

/// Represents how items can be selected in a list.
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Data)]
pub enum Selectable {
    #[default]
    /// Items in the list cannot be selected.
    None,
    /// A single item in the list can be selected.
    Single,
    /// Multiple items in the list can be selected simultaneously.
    Multi,
}

impl_res_simple!(Selectable);

/// Events used by the [List] view
pub enum ListEvent {
    /// Selects a list item with the given index.
    Select(usize),
    /// Selects the focused list item.
    SelectFocused,
    ///  Moves the focus to the next item in the list.
    FocusNext,
    ///  Moves the focus to the previous item in the list.
    FocusPrev,
    /// Deselects all items from the list
    ClearSelection,
    /// Scrolls the list to the given x and y position.
    Scroll(f32, f32),
}

/// A view for creating a list of items from a binding to an iteratable list.
#[derive(Lens)]
pub struct List {
    /// The number of items in the list.
    num_items: usize,
    /// The set of selected items in the list.
    selected: BTreeSet<usize>,
    /// Whether the list items are selectable.
    selectable: Selectable,
    /// The index of the currently focused item in the list.
    focused: Option<usize>,
    /// Whether the selection should follow the focus.
    selection_follows_focus: bool,
    /// The orientation of the list, either vertical or horizontal.
    orientation: Orientation,
    /// Whether the scrollview should scroll to the cursor when the scrollbar is pressed.
    scroll_to_cursor: bool,
    /// Callback called when a list item is selected.
    #[lens(ignore)]
    on_select: Option<Box<dyn Fn(&mut EventContext, usize)>>,
    /// Callback called when the scrollview is scrolled.
    #[lens(ignore)]
    on_scroll: Option<Box<dyn Fn(&mut EventContext, f32, f32) + Send + Sync>>,
    /// The horizontal scroll position of the list.
    scroll_x: f32,
    /// The vertical scroll position of the list.
    scroll_y: f32,
    /// Whether the horizontal scrollbar should be visible.
    show_horizontal_scrollbar: bool,
    /// Whether the vertical scrollbar should be visible.
    show_vertical_scrollbar: bool,
}

impl List {
    /// Creates a new [List] view.
    pub fn new<L: Lens, T: 'static>(
        cx: &mut Context,
        list: L,
        item_content: impl 'static + Fn(&mut Context, usize, MapRef<L, T>),
    ) -> Handle<Self>
    where
        L::Target: Deref<Target = [T]> + Data,
    {
        Self::new_generic(
            cx,
            list,
            |list| list.len(),
            |list, index| &list[index],
            |_| true,
            item_content,
        )
    }

    /// Creates a new [List] view with a provided filter closure.
    pub fn new_filtered<L: Lens, T: 'static>(
        cx: &mut Context,
        list: L,
        filter: impl 'static + Clone + FnMut(&&T) -> bool,
        item_content: impl 'static + Fn(&mut Context, usize, MapRef<L, T>),
    ) -> Handle<Self>
    where
        L::Target: Deref<Target = [T]> + Data,
    {
        let f = filter.clone();
        Self::new_generic(
            cx,
            list,
            move |list| list.iter().filter(filter.clone()).count(),
            move |list, index| &list[index],
            f,
            item_content,
        )
    }

    /// Creates a new [List] view with a binding to the given lens and a template for constructing the list items.
    pub fn new_generic<L: Lens, T: 'static>(
        cx: &mut Context,
        list: L,
        list_len: impl 'static + Fn(&L::Target) -> usize,
        list_index: impl 'static + Clone + Fn(&L::Target, usize) -> &T,
        filter: impl 'static + Clone + FnMut(&&T) -> bool,
        item_content: impl 'static + Fn(&mut Context, usize, MapRef<L, T>),
    ) -> Handle<Self>
    where
        L::Target: Deref<Target = [T]> + Data,
    {
        let content = Rc::new(item_content);
        let num_items = list.map(list_len);
        Self {
            num_items: num_items.get(cx),
            selected: BTreeSet::default(),
            selectable: Selectable::None,
            focused: None,
            selection_follows_focus: false,
            orientation: Orientation::Vertical,
            scroll_to_cursor: false,
            on_select: None,
            on_scroll: None,
            scroll_x: 0.0,
            scroll_y: 0.0,
            show_horizontal_scrollbar: true,
            show_vertical_scrollbar: true,
        }
        .build(cx, move |cx| {
            Keymap::from(vec![
                (
                    KeyChord::new(Modifiers::empty(), Code::ArrowDown),
                    KeymapEntry::new("Focus Next", |cx| cx.emit(ListEvent::FocusNext)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::ArrowUp),
                    KeymapEntry::new("Focus Previous", |cx| cx.emit(ListEvent::FocusPrev)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::Space),
                    KeymapEntry::new("Select Focused", |cx| cx.emit(ListEvent::SelectFocused)),
                ),
                (
                    KeyChord::new(Modifiers::empty(), Code::Enter),
                    KeymapEntry::new("Select Focused", |cx| cx.emit(ListEvent::SelectFocused)),
                ),
            ])
            .build(cx);

            Binding::new(cx, List::orientation, |cx, orientation| {
                if orientation.get(cx) == Orientation::Horizontal {
                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowDown),
                        "Focus Next",
                    ));

                    cx.emit(KeymapEvent::RemoveAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowUp),
                        "Focus Previous",
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowRight),
                        KeymapEntry::new("Focus Next", |cx| cx.emit(ListEvent::FocusNext)),
                    ));

                    cx.emit(KeymapEvent::InsertAction(
                        KeyChord::new(Modifiers::empty(), Code::ArrowLeft),
                        KeymapEntry::new("Focus Previous", |cx| cx.emit(ListEvent::FocusPrev)),
                    ));
                }
            });

            ScrollView::new(cx, move |cx| {
                // Bind to the list data
                Binding::new(cx, num_items, move |cx, _| {
                    // If the number of list items is different to the number of children of the ListView
                    // then remove and rebuild all the children

                    let mut f = filter.clone();
                    let ll = list
                        .get(cx)
                        .iter()
                        .enumerate()
                        .filter(|(_, v)| f(v))
                        .map(|(idx, _)| idx)
                        .collect::<Vec<_>>();

                    for index in ll.into_iter() {
                        let ll = list_index.clone();
                        let item = list.map_ref(move |list| ll(list, index));
                        let content = content.clone();
                        ListItem::new(
                            cx,
                            index,
                            item,
                            List::selected,
                            List::focused,
                            move |cx, index, item| {
                                content(cx, index, item);
                            },
                        );
                    }
                });
            })
            .show_horizontal_scrollbar(Self::show_horizontal_scrollbar)
            .show_vertical_scrollbar(Self::show_vertical_scrollbar)
            .scroll_to_cursor(Self::scroll_to_cursor)
            .scroll_x(Self::scroll_x)
            .scroll_y(Self::scroll_y)
            .on_scroll(|cx, x, y| {
                if y.is_finite() {
                    cx.emit(ListEvent::Scroll(x, y));
                }
            });
        })
        .toggle_class("selectable", List::selectable.map(|s| *s != Selectable::None))
        .toggle_class(
            "horizontal",
            Self::orientation.map(|orientation| *orientation == Orientation::Horizontal),
        )
        .navigable(true)
        .role(Role::List)
    }
}

impl View for List {
    fn element(&self) -> Option<&'static str> {
        Some("list")
    }

    fn event(&mut self, cx: &mut EventContext, event: &mut Event) {
        event.take(|list_event, meta| match list_event {
            ListEvent::Select(index) => {
                cx.focus();
                match self.selectable {
                    Selectable::Single => {
                        if self.selected.contains(&index) {
                            self.selected.clear();
                            self.focused = None;
                        } else {
                            self.selected.clear();
                            self.selected.insert(index);
                            self.focused = Some(index);
                            if let Some(on_select) = &self.on_select {
                                on_select(cx, index);
                            }
                        }
                    }

                    Selectable::Multi => {
                        if self.selected.contains(&index) {
                            self.selected.remove(&index);
                            self.focused = None;
                        } else {
                            self.selected.insert(index);
                            self.focused = Some(index);
                            if let Some(on_select) = &self.on_select {
                                on_select(cx, index);
                            }
                        }
                    }

                    Selectable::None => {}
                }

                meta.consume();
            }

            ListEvent::SelectFocused => {
                if let Some(focused) = &self.focused {
                    cx.emit(ListEvent::Select(*focused))
                }
                meta.consume();
            }

            ListEvent::ClearSelection => {
                self.selected.clear();
                meta.consume();
            }

            ListEvent::FocusNext => {
                if let Some(focused) = &mut self.focused {
                    if *focused < self.num_items.saturating_sub(1) {
                        *focused = focused.saturating_add(1);
                        if self.selection_follows_focus {
                            cx.emit(ListEvent::SelectFocused);
                        }
                    }
                } else {
                    self.focused = Some(0);
                    if self.selection_follows_focus {
                        cx.emit(ListEvent::SelectFocused);
                    }
                }

                meta.consume();
            }

            ListEvent::FocusPrev => {
                if let Some(focused) = &mut self.focused {
                    if *focused > 0 {
                        *focused = focused.saturating_sub(1);
                        if self.selection_follows_focus {
                            cx.emit(ListEvent::SelectFocused);
                        }
                    }
                } else {
                    self.focused = Some(self.num_items.saturating_sub(1));
                    if self.selection_follows_focus {
                        cx.emit(ListEvent::SelectFocused);
                    }
                }

                meta.consume();
            }

            ListEvent::Scroll(x, y) => {
                self.scroll_x = x;
                self.scroll_y = y;
                if let Some(callback) = &self.on_scroll {
                    (callback)(cx, x, y);
                }

                meta.consume();
            }
        })
    }
}

impl Handle<'_, List> {
    /// Sets the  selected items of the list. Takes a lens to a list of indices.
    pub fn selected<S: Lens>(self, selected: S) -> Self
    where
        S::Target: Deref<Target = [usize]> + Data,
    {
        self.bind(selected, |handle, s| {
            let ss = s.get(&handle).deref().to_vec();
            handle.modify(|list| {
                list.selected.clear();
                for idx in ss {
                    list.selected.insert(idx);
                    list.focused = Some(idx);
                }
            });
        })
    }

    /// Sets the callback triggered when a [ListItem] is selected.
    pub fn on_select<F>(self, callback: F) -> Self
    where
        F: 'static + Fn(&mut EventContext, usize),
    {
        self.modify(|list: &mut List| list.on_select = Some(Box::new(callback)))
    }

    /// Set the selectable state of the [List].
    pub fn selectable<U: Into<Selectable>>(self, selectable: impl Res<U>) -> Self {
        self.bind(selectable, |handle, selectable| {
            let s = selectable.get(&handle).into();
            handle.modify(|list: &mut List| list.selectable = s);
        })
    }

    /// Sets whether the selection should follow the focus.
    pub fn selection_follows_focus<U: Into<bool>>(self, flag: impl Res<U>) -> Self {
        self.bind(flag, |handle, selection_follows_focus| {
            let s = selection_follows_focus.get(&handle).into();
            handle.modify(|list: &mut List| list.selection_follows_focus = s);
        })
    }

    /// Sets the orientation of the list.
    pub fn orientation<U: Into<Orientation>>(self, orientation: impl Res<U>) -> Self {
        self.bind(orientation, |handle, orientation| {
            let orientation = orientation.get(&handle).into();
            handle.modify(|list: &mut List| {
                list.orientation = orientation;
            });
        })
    }

    /// Sets whether the scrollbar should move to the cursor when pressed.
    pub fn scroll_to_cursor(self, flag: bool) -> Self {
        self.modify(|list| {
            list.scroll_to_cursor = flag;
        })
    }

    /// Sets a callback which will be called when a scrollview is scrolled, either with the mouse wheel, touchpad, or using the scroll bars.
    pub fn on_scroll(
        self,
        callback: impl Fn(&mut EventContext, f32, f32) + 'static + Send + Sync,
    ) -> Self {
        self.modify(|list: &mut List| list.on_scroll = Some(Box::new(callback)))
    }

    /// Set the horizontal scroll position of the [ScrollView]. Accepts a value or lens to an 'f32' between 0 and 1.
    pub fn scroll_x(self, scrollx: impl Res<f32>) -> Self {
        self.bind(scrollx, |handle, scrollx| {
            let sx = scrollx.get(&handle);
            handle.modify(|list| list.scroll_x = sx);
        })
    }

    /// Set the vertical scroll position of the [ScrollView]. Accepts a value or lens to an 'f32' between 0 and 1.
    pub fn scroll_y(self, scrollx: impl Res<f32>) -> Self {
        self.bind(scrollx, |handle, scrolly| {
            let sy = scrolly.get(&handle);
            handle.modify(|list| list.scroll_y = sy);
        })
    }

    /// Sets whether the horizontal scrollbar should be visible.
    pub fn show_horizontal_scrollbar(self, flag: impl Res<bool>) -> Self {
        self.bind(flag, |handle, show_scrollbar| {
            let s = show_scrollbar.get(&handle);
            handle.modify(|list| list.show_horizontal_scrollbar = s);
        })
    }

    /// Sets whether the vertical scrollbar should be visible.
    pub fn show_vertical_scrollbar(self, flag: impl Res<bool>) -> Self {
        self.bind(flag, |handle, show_scrollbar| {
            let s = show_scrollbar.get(&handle);
            handle.modify(|list| list.show_vertical_scrollbar = s);
        })
    }
}

/// A view which represents a selectable item within a list.
pub struct ListItem {}

impl ListItem {
    /// Create a new [ListItem] view.
    pub fn new<L: Lens, T: 'static>(
        cx: &mut Context,
        index: usize,
        item: MapRef<L, T>,
        selected: impl Lens<Target = BTreeSet<usize>>,
        focused: impl Lens<Target = Option<usize>>,
        item_content: impl 'static + Fn(&mut Context, usize, MapRef<L, T>),
    ) -> Handle<Self> {
        let is_focused =
            focused.map(move |focused| focused.as_ref().is_some_and(|f| *f == index)).get(cx);
        Self {}
            .build(cx, move |cx| {
                item_content(cx, index, item);
            })
            .role(Role::ListItem)
            .toggle_class(
                "focused",
                focused.map(move |focused| focused.as_ref().is_some_and(|f| *f == index)),
            )
            .checked(selected.map(move |selected| selected.contains(&index)))
            .bind(
                focused.map(move |focused| focused.as_ref().is_some_and(|f| *f == index)),
                move |handle, focused| {
                    if focused.get(&handle) != is_focused {
                        handle.cx.emit(ScrollEvent::ScrollToView(handle.entity()));
                    }
                },
            )
            .on_press(move |cx| cx.emit(ListEvent::Select(index)))
    }
}

impl View for ListItem {
    fn element(&self) -> Option<&'static str> {
        Some("list-item")
    }
}