cursive/src/views/select_view.rs

use crate::align::{Align, HAlign, VAlign};
use crate::direction::Direction;
use crate::event::{
    Callback, Event, EventResult, Key, MouseButton, MouseEvent,
};
use crate::menu::MenuTree;
use crate::rect::Rect;
use crate::theme::ColorStyle;
use crate::utils::markup::StyledString;
use crate::vec::Vec2;
use crate::view::{Position, View};
use crate::views::MenuPopup;
use crate::Cursive;
use crate::Printer;
use crate::With;
use std::borrow::Borrow;
use std::cell::Cell;
use std::cmp::{min, Ordering};
use std::rc::Rc;

/// View to select an item among a list.
///
/// It contains a list of values of type T, with associated labels.
///
/// # Examples
///
/// ```rust
/// # use cursive::Cursive;
/// # use cursive::views::{SelectView, Dialog, TextView};
/// # use cursive::align::HAlign;
/// # fn main() {
/// let mut time_select = SelectView::new().h_align(HAlign::Center);
/// time_select.add_item("Short", 1);
/// time_select.add_item("Medium", 5);
/// time_select.add_item("Long", 10);
///
/// time_select.set_on_submit(|s, time| {
///     s.pop_layer();
///     let text = format!("You will wait for {} minutes...", time);
///     s.add_layer(Dialog::around(TextView::new(text))
///                     .button("Quit", |s| s.quit()));
/// });
///
/// let mut siv = Cursive::dummy();
/// siv.add_layer(Dialog::around(time_select)
///                      .title("How long is your wait?"));
/// # }
///
/// ```
pub struct SelectView<T = String> {
    // The core of the view: we store a list of items
    // `Item` is more or less a `(String, Rc<T>)`.
    items: Vec<Item<T>>,

    // When disabled, we cannot change selection.
    enabled: bool,

    // Callbacks may need to manipulate focus, so give it some mutability.
    focus: Rc<Cell<usize>>,

    // This is a custom callback to include a &T.
    // It will be called whenever "Enter" is pressed or when an item is clicked.
    on_submit: Option<Rc<dyn Fn(&mut Cursive, &T)>>,

    // This callback is called when the selection is changed.
    // TODO: add the previous selection? Indices?
    on_select: Option<Rc<dyn Fn(&mut Cursive, &T)>>,

    // If `true`, when a character is pressed, jump to the next item starting
    // with this character.
    autojump: bool,

    align: Align,

    // `true` if we show a one-line view, with popup on selection.
    popup: bool,

    // We need the last offset to place the popup window
    // We "cache" it during the draw, so we need interior mutability.
    last_offset: Cell<Vec2>,
    last_size: Vec2,
}

impl<T: 'static> Default for SelectView<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: 'static> SelectView<T> {
    /// Creates a new empty SelectView.
    pub fn new() -> Self {
        SelectView {
            items: Vec::new(),
            enabled: true,
            focus: Rc::new(Cell::new(0)),
            on_select: None,
            on_submit: None,
            align: Align::top_left(),
            popup: false,
            autojump: false,
            last_offset: Cell::new(Vec2::zero()),
            last_size: Vec2::zero(),
        }
    }

    /// Sets the "auto-jump" property for this view.
    ///
    /// If enabled, when a key is pressed, the selection will jump to the next
    /// item beginning with the pressed letter.
    pub fn set_autojump(&mut self, autojump: bool) {
        self.autojump = autojump;
    }

    /// Sets the "auto-jump" property for this view.
    ///
    /// If enabled, when a key is pressed, the selection will jump to the next
    /// item beginning with the pressed letter.
    ///
    /// Chainable variant.
    pub fn autojump(self) -> Self {
        self.with(|s| s.set_autojump(true))
    }

    /// Turns `self` into a popup select view.
    ///
    /// Chainable variant.
    pub fn popup(self) -> Self {
        self.with(|s| s.set_popup(true))
    }

    /// Turns `self` into a popup select view.
    pub fn set_popup(&mut self, popup: bool) {
        self.popup = popup;
    }

    /// Disables this view.
    ///
    /// A disabled view cannot be selected.
    pub fn disable(&mut self) {
        self.enabled = false;
    }

    /// Disables this view.
    ///
    /// Chainable variant.
    pub fn disabled(self) -> Self {
        self.with(Self::disable)
    }

    /// Re-enables this view.
    pub fn enable(&mut self) {
        self.enabled = true;
    }

    /// Enable or disable this view.
    pub fn set_enabled(&mut self, enabled: bool) {
        self.enabled = enabled;
    }

    /// Returns `true` if this view is enabled.
    pub fn is_enabled(&self) -> bool {
        self.enabled
    }

    /// Sets a callback to be used when an item is selected.
    pub fn set_on_select<F>(&mut self, cb: F)
    where
        F: Fn(&mut Cursive, &T) + 'static,
    {
        self.on_select = Some(Rc::new(cb));
    }

    /// Sets a callback to be used when an item is selected.
    ///
    /// Chainable variant.
    pub fn on_select<F>(self, cb: F) -> Self
    where
        F: Fn(&mut Cursive, &T) + 'static,
    {
        self.with(|s| s.set_on_select(cb))
    }

    /// Sets a callback to be used when `<Enter>` is pressed.
    ///
    /// Also happens if the user clicks an item.
    ///
    /// The item currently selected will be given to the callback.
    ///
    /// Here, `V` can be `T` itself, or a type that can be borrowed from `T`.
    pub fn set_on_submit<F, R, V: ?Sized>(&mut self, cb: F)
    where
        F: 'static + Fn(&mut Cursive, &V) -> R,
        T: Borrow<V>,
    {
        self.on_submit = Some(Rc::new(move |s, t| {
            cb(s, t.borrow());
        }));
    }

    /// Sets a callback to be used when `<Enter>` is pressed.
    ///
    /// Also happens if the user clicks an item.
    ///
    /// The item currently selected will be given to the callback.
    ///
    /// Chainable variant.
    pub fn on_submit<F, V: ?Sized>(self, cb: F) -> Self
    where
        F: Fn(&mut Cursive, &V) + 'static,
        T: Borrow<V>,
    {
        self.with(|s| s.set_on_submit(cb))
    }

    /// Sets the alignment for this view.
    pub fn align(mut self, align: Align) -> Self {
        self.align = align;

        self
    }

    /// Sets the vertical alignment for this view.
    /// (If the view is given too much space vertically.)
    pub fn v_align(mut self, v: VAlign) -> Self {
        self.align.v = v;

        self
    }

    /// Sets the horizontal alignment for this view.
    pub fn h_align(mut self, h: HAlign) -> Self {
        self.align.h = h;

        self
    }

    /// Returns the value of the currently selected item.
    ///
    /// Returns `None` if the list is empty.
    pub fn selection(&self) -> Option<Rc<T>> {
        let focus = self.focus();
        if self.len() <= focus {
            None
        } else {
            Some(Rc::clone(&self.items[focus].value))
        }
    }

    /// Removes all items from this view.
    pub fn clear(&mut self) {
        self.items.clear();
        self.focus.set(0);
    }

    /// Adds a item to the list, with given label and value.
    pub fn add_item<S: Into<StyledString>>(&mut self, label: S, value: T) {
        self.items.push(Item::new(label.into(), value));
    }

    /// Gets an item at given idx or None.
    ///
    /// ```
    /// use cursive::Cursive;
    /// use cursive::views::{SelectView, TextView};
    /// let select = SelectView::new()
    ///     .item("Short", 1);
    /// assert_eq!(select.get_item(0), Some(("Short", &1)));
    /// ```
    pub fn get_item(&self, i: usize) -> Option<(&str, &T)> {
        self.iter().nth(i)
    }

    /// Gets a mut item at given idx or None.
    pub fn get_item_mut(
        &mut self,
        i: usize,
    ) -> Option<(&mut StyledString, &mut T)> {
        if i >= self.items.len() {
            None
        } else {
            let item = &mut self.items[i];
            if let Some(t) = Rc::get_mut(&mut item.value) {
                let label = &mut item.label;
                Some((label, t))
            } else {
                None
            }
        }
    }

    /// Iterate on the items in this view.
    ///
    /// Returns an iterator with each item and their labels.
    pub fn iter(&self) -> impl Iterator<Item = (&str, &T)> {
        self.items
            .iter()
            .map(|item| (item.label.source(), &*item.value))
    }

    /// Removes an item from the list.
    ///
    /// Returns a callback in response to the selection change.
    ///
    /// You should run this callback with a `&mut Cursive`.
    pub fn remove_item(&mut self, id: usize) -> Callback {
        self.items.remove(id);
        let focus = self.focus();
        if focus >= id && focus > 0 {
            self.focus.set(focus - 1);
        }

        self.make_select_cb().unwrap_or_else(Callback::dummy)
    }

    /// Inserts an item at position `index`, shifting all elements after it to
    /// the right.
    pub fn insert_item<S>(&mut self, index: usize, label: S, value: T)
    where
        S: Into<StyledString>,
    {
        self.items.insert(index, Item::new(label.into(), value));
    }

    /// Chainable variant of add_item
    pub fn item<S: Into<String>>(self, label: S, value: T) -> Self {
        self.with(|s| s.add_item(label, value))
    }

    /// Adds all items from from an iterator.
    pub fn add_all<S, I>(&mut self, iter: I)
    where
        S: Into<StyledString>,
        I: IntoIterator<Item = (S, T)>,
    {
        for (s, t) in iter {
            self.add_item(s, t);
        }
    }

    /// Adds all items from from an iterator.
    ///
    /// Chainable variant.
    pub fn with_all<S, I>(self, iter: I) -> Self
    where
        S: Into<StyledString>,
        I: IntoIterator<Item = (S, T)>,
    {
        self.with(|s| s.add_all(iter))
    }

    fn draw_item(&self, printer: &Printer<'_, '_>, i: usize) {
        let l = self.items[i].label.width();
        let x = self.align.h.get_offset(l, printer.size.x);
        printer.print_hline((0, 0), x, " ");
        printer.print_styled((x, 0), (&self.items[i].label).into());
        if l < printer.size.x {
            assert!((l + x) <= printer.size.x);
            printer.print_hline((x + l, 0), printer.size.x - (l + x), " ");
        }
    }

    /// Returns the id of the item currently selected.
    ///
    /// Returns `None` if the list is empty.
    pub fn selected_id(&self) -> Option<usize> {
        if self.items.is_empty() {
            None
        } else {
            Some(self.focus())
        }
    }

    /// Returns the number of items in this list.
    pub fn len(&self) -> usize {
        self.items.len()
    }

    /// Returns `true` if this list has no item.
    pub fn is_empty(&self) -> bool {
        self.items.is_empty()
    }

    fn focus(&self) -> usize {
        self.focus.get()
    }

    /// Sort the current items lexicographically by their label.
    /// Note that this does not change the current focus index, which means that the current
    /// selection will likely be changed by the sorting.
    /// This sort is stable: items with identical label will not be reordered.
    pub fn sort_by_label(&mut self) {
        self.items
            .sort_by(|a, b| a.label.source().cmp(b.label.source()));
    }

    /// Sort the current items with the given comparator function.
    /// Note that this does not change the current focus index, which means that the current
    /// selection will likely be changed by the sorting.
    /// The given comparator function must define a total order for the items.
    /// If the comparator function does not define a total order, then the order after the sort is
    /// unspecified.
    /// This sort is stable: equal items will not be reordered.
    pub fn sort_by<F>(&mut self, mut compare: F)
    where
        F: FnMut(&T, &T) -> Ordering,
    {
        self.items.sort_by(|a, b| compare(&a.value, &b.value));
    }

    /// Sort the current items with the given key extraction function.
    /// Note that this does not change the current focus index, which means that the current
    /// selection will likely be changed by the sorting.
    /// This sort is stable: items with equal keys will not be reordered.
    pub fn sort_by_key<K, F>(&mut self, mut key_of: F)
    where
        F: FnMut(&T) -> K,
        K: Ord,
    {
        self.items.sort_by_key(|item| key_of(&item.value));
    }

    /// Moves the selection to the given position.
    ///
    /// Returns a callback in response to the selection change.
    ///
    /// You should run this callback with a `&mut Cursive`.
    pub fn set_selection(&mut self, i: usize) -> Callback {
        // TODO: Check if `i >= self.len()` ?
        // assert!(i < self.len(), "SelectView: trying to select out-of-bound");
        // Or just cap the ID?
        let i = if self.is_empty() {
            0
        } else {
            min(i, self.len() - 1)
        };
        self.focus.set(i);

        self.make_select_cb().unwrap_or_else(Callback::dummy)
    }

    /// Sets the selection to the given position.
    ///
    /// Chainable variant.
    ///
    /// Does not apply `on_select` callbacks.
    pub fn selected(self, i: usize) -> Self {
        self.with(|s| {
            s.set_selection(i);
        })
    }

    /// Moves the selection up by the given number of rows.
    ///
    /// Returns a callback in response to the selection change.
    ///
    /// You should run this callback with a `&mut Cursive`:
    ///
    /// ```rust
    /// # use cursive::Cursive;
    /// # use cursive::views::SelectView;
    /// # fn main() {}
    /// fn select_up(siv: &mut Cursive, view: &mut SelectView<()>) {
    ///     let cb = view.select_up(1);
    ///     cb(siv);
    /// }
    /// ```
    pub fn select_up(&mut self, n: usize) -> Callback {
        self.focus_up(n);
        self.make_select_cb().unwrap_or_else(Callback::dummy)
    }

    /// Moves the selection down by the given number of rows.
    ///
    /// Returns a callback in response to the selection change.
    ///
    /// You should run this callback with a `&mut Cursive`.
    pub fn select_down(&mut self, n: usize) -> Callback {
        self.focus_down(n);
        self.make_select_cb().unwrap_or_else(Callback::dummy)
    }

    fn focus_up(&mut self, n: usize) {
        let focus = self.focus().saturating_sub(n);
        self.focus.set(focus);
    }

    fn focus_down(&mut self, n: usize) {
        let focus = min(self.focus() + n, self.items.len().saturating_sub(1));
        self.focus.set(focus);
    }

    fn submit(&mut self) -> EventResult {
        let cb = self.on_submit.clone().unwrap();
        // We return a Callback Rc<|s| cb(s, &*v)>
        EventResult::Consumed(
            self.selection()
                .map(|v| Callback::from_fn(move |s| cb(s, &v))),
        )
    }

    fn on_char_event(&mut self, c: char) -> EventResult {
        let i = {
            // * Starting from the current focus, find the first item that
            //   match the char.
            // * Cycle back to the beginning of the list when we reach the end.
            // * This is achieved by chaining twice the iterator.
            let iter = self.iter().chain(self.iter());

            // We'll do a lowercase check.
            let lower_c: Vec<char> = c.to_lowercase().collect();
            let lower_c: &[char] = &lower_c;

            if let Some((i, _)) = iter.enumerate().skip(self.focus() + 1).find(
                |&(_, (label, _))| label.to_lowercase().starts_with(lower_c),
            ) {
                i % self.len()
            } else {
                return EventResult::Ignored;
            }
        };

        self.focus.set(i);
        // Apply modulo in case we have a hit from the chained iterator
        let cb = self.set_selection(i);
        EventResult::Consumed(Some(cb))
    }

    fn on_event_regular(&mut self, event: Event) -> EventResult {
        match event {
            Event::Key(Key::Up) if self.focus() > 0 => self.focus_up(1),
            Event::Key(Key::Down) if self.focus() + 1 < self.items.len() => {
                self.focus_down(1)
            }
            Event::Key(Key::PageUp) => self.focus_up(10),
            Event::Key(Key::PageDown) => self.focus_down(10),
            Event::Key(Key::Home) => self.focus.set(0),
            Event::Key(Key::End) => {
                self.focus.set(self.items.len().saturating_sub(1))
            }
            Event::Mouse {
                event: MouseEvent::Press(_),
                position,
                offset,
            } if position
                .checked_sub(offset)
                .map(|position| {
                    position < self.last_size && position.y < self.len()
                })
                .unwrap_or(false) =>
            {
                self.focus.set(position.y - offset.y)
            }
            Event::Mouse {
                event: MouseEvent::Release(MouseButton::Left),
                position,
                offset,
            } if self.on_submit.is_some()
                && position
                    .checked_sub(offset)
                    .map(|position| {
                        position < self.last_size && position.y == self.focus()
                    })
                    .unwrap_or(false) =>
            {
                return self.submit();
            }
            Event::Key(Key::Enter) if self.on_submit.is_some() => {
                return self.submit();
            }
            Event::Char(c) if self.autojump => return self.on_char_event(c),
            _ => return EventResult::Ignored,
        }

        EventResult::Consumed(self.make_select_cb())
    }

    /// Returns a callback from selection change.
    fn make_select_cb(&self) -> Option<Callback> {
        self.on_select.clone().and_then(|cb| {
            self.selection()
                .map(|v| Callback::from_fn(move |s| cb(s, &v)))
        })
    }

    fn open_popup(&mut self) -> EventResult {
        // Build a shallow menu tree to mimick the items array.
        // TODO: cache it?
        let mut tree = MenuTree::new();
        for (i, item) in self.items.iter().enumerate() {
            let focus = Rc::clone(&self.focus);
            let on_submit = self.on_submit.as_ref().cloned();
            let value = Rc::clone(&item.value);
            tree.add_leaf(item.label.source(), move |s| {
                // TODO: What if an item was removed in the meantime?
                focus.set(i);
                if let Some(ref on_submit) = on_submit {
                    on_submit(s, &value);
                }
            });
        }
        // Let's keep the tree around,
        // the callback will want to use it.
        let tree = Rc::new(tree);

        let focus = self.focus();
        // This is the offset for the label text.
        // We'll want to show the popup so that the text matches.
        // It'll be soo cool.
        let item_length = self.items[focus].label.width();
        let text_offset = (self.last_size.x.saturating_sub(item_length)) / 2;
        // The total offset for the window is:
        // * the last absolute offset at which we drew this view
        // * shifted to the right of the text offset
        // * shifted to the top of the focus (so the line matches)
        // * shifted top-left of the border+padding of the popup
        let offset = self.last_offset.get();
        let offset = offset + (text_offset, 0);
        let offset = offset.saturating_sub((0, focus));
        let offset = offset.saturating_sub((2, 1));

        // And now, we can return the callback that will create the popup.
        EventResult::with_cb(move |s| {
            // The callback will want to work with a fresh Rc
            let tree = Rc::clone(&tree);
            // We'll relativise the absolute position,
            // So that we are locked to the parent view.
            // A nice effect is that window resizes will keep both
            // layers together.
            let current_offset = s.screen().offset();
            let offset = offset.signed() - current_offset;
            // And finally, put the view in view!
            s.screen_mut().add_layer_at(
                Position::parent(offset),
                MenuPopup::new(tree).focus(focus),
            );
        })
    }

    // A popup view only does one thing: open the popup on Enter.
    fn on_event_popup(&mut self, event: Event) -> EventResult {
        match event {
            // TODO: add Left/Right support for quick-switch?
            Event::Key(Key::Enter) => self.open_popup(),
            Event::Mouse {
                event: MouseEvent::Release(MouseButton::Left),
                position,
                offset,
            } if position.fits_in_rect(offset, self.last_size) => {
                self.open_popup()
            }
            _ => EventResult::Ignored,
        }
    }
}

impl SelectView<String> {
    /// Convenient method to use the label as value.
    pub fn add_item_str<S: Into<String>>(&mut self, label: S) {
        let label = label.into();
        self.add_item(label.clone(), label);
    }

    /// Chainable variant of add_item_str
    pub fn item_str<S: Into<String>>(self, label: S) -> Self {
        self.with(|s| s.add_item_str(label))
    }

    /// Convenient method to use the label as value.
    pub fn insert_item_str<S>(&mut self, index: usize, label: S)
    where
        S: Into<String>,
    {
        let label = label.into();
        self.insert_item(index, label.clone(), label);
    }

    /// Adds all strings from an iterator.
    ///
    /// # Examples
    ///
    /// ```
    /// # use cursive::views::SelectView;
    /// let mut select_view = SelectView::new();
    /// select_view.add_all_str(vec!["a", "b", "c"]);
    /// ```
    pub fn add_all_str<S, I>(&mut self, iter: I)
    where
        S: Into<String>,
        I: IntoIterator<Item = S>,
    {
        for s in iter {
            self.add_item_str(s);
        }
    }

    /// Adds all strings from an iterator.
    ///
    /// Chainable variant.
    pub fn with_all_str<S, I>(self, iter: I) -> Self
    where
        S: Into<String>,
        I: IntoIterator<Item = S>,
    {
        self.with(|s| s.add_all_str(iter))
    }
}

impl<T: 'static> SelectView<T>
where
    T: Ord,
{
    /// Sort the current items by their natural ordering.
    /// Note that this does not change the current focus index, which means that the current
    /// selection will likely be changed by the sorting.
    /// This sort is stable: items that are equal will not be reordered.
    pub fn sort(&mut self) {
        self.items.sort_by(|a, b| a.value.cmp(&b.value));
    }
}

impl<T: 'static> View for SelectView<T> {
    fn draw(&self, printer: &Printer<'_, '_>) {
        self.last_offset.set(printer.offset);

        if self.popup {
            // Popup-select only draw the active element.
            // We'll draw the full list in a popup if needed.
            let style = if !(self.enabled && printer.enabled) {
                ColorStyle::secondary()
            } else if printer.focused {
                ColorStyle::highlight()
            } else {
                ColorStyle::primary()
            };
            let x = match printer.size.x.checked_sub(1) {
                Some(x) => x,
                None => return,
            };

            printer.with_color(style, |printer| {
                // Prepare the entire background
                printer.print_hline((1, 0), x, " ");
                // Draw the borders
                printer.print((0, 0), "<");
                printer.print((x, 0), ">");

                let label = &self.items[self.focus()].label;

                // And center the text?
                let offset = HAlign::Center.get_offset(label.width(), x + 1);

                printer.print_styled((offset, 0), label.into());
            });
        } else {
            // Non-popup mode: we always print the entire list.
            let h = self.items.len();
            let offset = self.align.v.get_offset(h, printer.size.y);
            let printer = &printer.offset((0, offset));

            for i in 0..self.len() {
                printer.offset((0, i)).with_selection(
                    i == self.focus(),
                    |printer| {
                        if i != self.focus()
                            && !(self.enabled && printer.enabled)
                        {
                            printer.with_color(
                                ColorStyle::secondary(),
                                |printer| self.draw_item(printer, i),
                            );
                        } else {
                            self.draw_item(printer, i);
                        }
                    },
                );
            }
        }
    }

    fn required_size(&mut self, _: Vec2) -> Vec2 {
        // Items here are not compressible.
        // So no matter what the horizontal requirements are,
        // we'll still return our longest item.
        let w = self
            .items
            .iter()
            .map(|item| item.label.width())
            .max()
            .unwrap_or(1);
        if self.popup {
            Vec2::new(w + 2, 1)
        } else {
            let h = self.items.len();

            Vec2::new(w, h)
        }
    }

    fn on_event(&mut self, event: Event) -> EventResult {
        if self.popup {
            self.on_event_popup(event)
        } else {
            self.on_event_regular(event)
        }
    }

    fn take_focus(&mut self, _: Direction) -> bool {
        self.enabled && !self.items.is_empty()
    }

    fn layout(&mut self, size: Vec2) {
        self.last_size = size;
    }

    fn important_area(&self, size: Vec2) -> Rect {
        self.selected_id()
            .map(|i| Rect::from_size((0, i), (size.x, 1)))
            .unwrap_or_else(|| Rect::from((0, 0)))
    }
}

// We wrap each value in a `Rc` and add a label
struct Item<T> {
    label: StyledString,
    value: Rc<T>,
}

impl<T> Item<T> {
    fn new(label: StyledString, value: T) -> Self {
        let value = Rc::new(value);
        Item { label, value }
    }
}

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

    #[test]
    fn select_view_sorting() {
        // We add items in no particular order, from going by their label.
        let mut view = SelectView::new();
        view.add_item_str("Y");
        view.add_item_str("Z");
        view.add_item_str("X");

        // Then sorting the list...
        view.sort_by_label();

        // ... should observe the items in sorted order.
        // And focus is NOT changed by the sorting, so the first item is "X".
        assert_eq!(view.selection(), Some(Rc::new(String::from("X"))));
        view.on_event(Event::Key(Key::Down));
        assert_eq!(view.selection(), Some(Rc::new(String::from("Y"))));
        view.on_event(Event::Key(Key::Down));
        assert_eq!(view.selection(), Some(Rc::new(String::from("Z"))));
        view.on_event(Event::Key(Key::Down));
        assert_eq!(view.selection(), Some(Rc::new(String::from("Z"))));
    }

    #[test]
    fn select_view_sorting_with_comparator() {
        // We add items in no particular order, from going by their value.
        let mut view = SelectView::new();
        view.add_item("Y", 2);
        view.add_item("Z", 1);
        view.add_item("X", 3);

        // Then sorting the list...
        view.sort_by(|a, b| a.cmp(b));

        // ... should observe the items in sorted order.
        // And focus is NOT changed by the sorting, so the first item is "X".
        assert_eq!(view.selection(), Some(Rc::new(1)));
        view.on_event(Event::Key(Key::Down));
        assert_eq!(view.selection(), Some(Rc::new(2)));
        view.on_event(Event::Key(Key::Down));
        assert_eq!(view.selection(), Some(Rc::new(3)));
        view.on_event(Event::Key(Key::Down));
        assert_eq!(view.selection(), Some(Rc::new(3)));
    }

    #[test]
    fn select_view_sorting_by_key() {
        // We add items in no particular order, from going by their key value.
        #[derive(Eq, PartialEq, Debug)]
        struct MyStruct {
            key: i32,
        }

        let mut view = SelectView::new();
        view.add_item("Y", MyStruct { key: 2 });
        view.add_item("Z", MyStruct { key: 1 });
        view.add_item("X", MyStruct { key: 3 });

        // Then sorting the list...
        view.sort_by_key(|s| s.key);

        // ... should observe the items in sorted order.
        // And focus is NOT changed by the sorting, so the first item is "X".
        assert_eq!(view.selection(), Some(Rc::new(MyStruct { key: 1 })));
        view.on_event(Event::Key(Key::Down));
        assert_eq!(view.selection(), Some(Rc::new(MyStruct { key: 2 })));
        view.on_event(Event::Key(Key::Down));
        assert_eq!(view.selection(), Some(Rc::new(MyStruct { key: 3 })));
        view.on_event(Event::Key(Key::Down));
        assert_eq!(view.selection(), Some(Rc::new(MyStruct { key: 3 })));
    }

    #[test]
    fn select_view_sorting_orderable_items() {
        // We add items in no particular order, from going by their value.
        let mut view = SelectView::new();
        view.add_item("Y", 2);
        view.add_item("Z", 1);
        view.add_item("X", 3);

        // Then sorting the list...
        view.sort();

        // ... should observe the items in sorted order.
        // And focus is NOT changed by the sorting, so the first item is "X".
        assert_eq!(view.selection(), Some(Rc::new(1)));
        view.on_event(Event::Key(Key::Down));
        assert_eq!(view.selection(), Some(Rc::new(2)));
        view.on_event(Event::Key(Key::Down));
        assert_eq!(view.selection(), Some(Rc::new(3)));
        view.on_event(Event::Key(Key::Down));
        assert_eq!(view.selection(), Some(Rc::new(3)));
    }
}