Struct MultipleChoiceView 

pub struct MultipleChoiceView<T = String> { /* private fields */ }

View to make a selection from multiple items.

It contains a list of values of type T, with associated labels.

Implementations

impl<T: 'static + Send + Sync> MultipleChoiceView<T>

pub fn disable(&mut self)

Disables this view.

A disabled view cannot be selected.

pub fn disabled(self) -> Self

Disables this view.

Chainable variant.

pub fn enable(&mut self)

Re-enables this view.

pub fn set_enabled(&mut self, enabled: bool)

Enable or disable this view.

pub fn with_enabled(self, is_enabled: bool) -> Self

Enable or disable this view.

Chainable variant.

pub fn is_enabled(&self) -> bool

Returns true if this view is enabled.

pub fn new() -> Self

Creates a new empty MultipleChoiceView.

pub fn set_choice_indicators(&mut self, selection_indicators: [&'static str; 2])

Sets the visual indicators for chosen and not chosen items.

The first indicator represents the not chosen variant.

Examples

use cursive_core::traits::Nameable;
use cursive_multiple_choice_view::MultipleChoiceView;

let mut multiple_choice_view: MultipleChoiceView<String> = MultipleChoiceView::new();
 
multiple_choice_view.set_choice_indicators(["☐", "☒"]);

pub fn with_choice_indicators( self, selection_indicators: [&'static str; 2], ) -> Self

Sets the visual indicators for chosen and not chosen items.

The first indicator represents the not chosen variant.

Chainable variant.

Examples

use cursive_core::traits::Nameable;
use cursive_multiple_choice_view::MultipleChoiceView;

let multiple_choice_view: MultipleChoiceView<String> = MultipleChoiceView::new()
    .with_choice_indicators(["☐", "☒"]);

pub fn set_autojump(&mut self, autojump: bool)

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 autojump(self) -> Self

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 set_inactive_highlight(&mut self, inactive_highlight: bool)

Sets the “inactive highlight” property for this view.

• If true (the default), the selected row will be highlighted when the view is not focused.
• If false, the selected row will be printed like the others if inactive.

pub fn with_inactive_highlight(self, inactive_highlight: bool) -> Self

Sets the “inactive highlight” property for this view.

• If true (the default), the selected row will be highlighted when the view is not focused.
• If false, the selected row will be printed like the others if inactive.

Chainable variant.

pub fn get_inactive_highlight(&self) -> bool

Returns the current status of the “inactive highlight” property.

pub fn set_on_select<F>(&mut self, cb: F)

where F: Fn(&mut Cursive, &T) + 'static + Send + Sync,

Sets a callback to be used when an item is selected.

pub fn on_select<F>(self, cb: F) -> Self

where F: Fn(&mut Cursive, &T) + 'static + Send + Sync,

Sets a callback to be used when an item is selected.

Chainable variant.

Examples

use cursive_core::traits::Nameable;
use cursive_core::views::TextView;
use cursive_multiple_choice_view::MultipleChoiceView;

let text_view = TextView::new("").with_name("text");

let multiple_choice_view = MultipleChoiceView::new()
    .item("One", 1)
    .item("Two", 2)
    .on_select(|s, item| {
        let content = match *item {
            1 => "Content number one",
            2 => "Content number two! Much better!",
            _ => unreachable!("no such item"),
        };

        // Update the textview with the currently selected item.
        s.call_on_name("text", |v: &mut TextView| {
            v.set_content(content);
        })
        .unwrap();
    });

pub fn set_on_submit<F, V: ?Sized>(&mut self, cb: F)

where F: 'static + Fn(&mut Cursive, &V) + Send + Sync, T: Borrow<V>,

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 on_submit<F, V: ?Sized>(self, cb: F) -> Self

where F: Fn(&mut Cursive, &V) + 'static + Send + Sync, T: Borrow<V>,

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.

Examples

use cursive_core::views::Dialog;
use cursive_multiple_choice_view::MultipleChoiceView;

let multiple_choice_view = MultipleChoiceView::new()
    .item("One", 1)
    .item("Two", 2)
    .on_submit(|s, item| {
        let content = match *item {
            1 => "Content number one",
            2 => "Content number two! Much better!",
            _ => unreachable!("no such item"),
        };

        // Show a popup whenever the user presses <Enter>.
        s.add_layer(Dialog::info(content));
    });

pub fn align(self, align: Align) -> Self

Sets the alignment for this view.

Examples

use cursive_core::align;
use cursive_multiple_choice_view::MultipleChoiceView;

let multiple_choice_view = MultipleChoiceView::new()
    .item("One", 1)
    .align(align::Align::top_center());

pub fn v_align(self, v: VAlign) -> Self

Sets the vertical alignment for this view. (If the view is given too much space vertically.)

pub fn h_align(self, h: HAlign) -> Self

Sets the horizontal alignment for this view.

pub fn selection(&self) -> Option<Arc<T>>

Returns the value of the currently selected item.

Returns None if the list is empty.

pub fn clear(&mut self)

Removes all items from this view.

pub fn add_item<S: Into<StyledString>>(&mut self, label: S, value: T)

Adds a item to the list, with given label and value.

Examples

use cursive_multiple_choice_view::MultipleChoiceView;

let mut multiple_choice_view = MultipleChoiceView::new();

multiple_choice_view.add_item("Item 1", 1);
multiple_choice_view.add_item("Item 2", 2);

pub fn get_item(&self, i: usize) -> Option<(&str, &T)>

Gets an item at given idx or None.

use cursive_core::views::TextView;
use cursive_multiple_choice_view::MultipleChoiceView;
use cursive_core::Cursive;
let select = MultipleChoiceView::new().item("Short", 1);
assert_eq!(select.get_item(0), Some(("Short", &1)));

pub fn get_item_mut(&mut self, i: usize) -> Option<(&mut StyledString, &mut T)>

Gets a mut item at given idx or None.

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&mut StyledString, &mut T)>

where T: Clone,

Iterate mutably on the items in this view.

Returns an iterator with each item and their labels.

In some cases some items will need to be cloned (for example if a Arc<T> is still alive after calling MultipleChoiceView::selection()).

If T does not implement Clone, check MultipleChoiceView::try_iter_mut().

pub fn try_iter_mut( &mut self, ) -> impl Iterator<Item = (&mut StyledString, Option<&mut T>)>

Try to iterate mutably on the items in this view.

Returns an iterator with each item and their labels.

Some items may not be returned mutably, for example if a Arc<T> is still alive after calling MultipleChoiceView::selection().

pub fn iter(&self) -> impl Iterator<Item = (&str, &T)>

Iterate on the items in this view.

Returns an iterator with each item and their labels.

pub fn add_item_with_choice<S: Into<StyledString>>( &mut self, label: S, value: T, chosen: bool, )

Adds a item to the list, with given label, value and whether it should be marked as chosen.

Examples

use cursive_multiple_choice_view::MultipleChoiceView;

let mut multiple_choice_view = MultipleChoiceView::new();

multiple_choice_view.add_item_with_choice("Item 1", 1, true);
multiple_choice_view.add_item_with_choice("Item 2", 2, false);

pub fn remove_item(&mut self, id: usize) -> Callback

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 insert_item<S>(&mut self, index: usize, label: S, value: T)

where S: Into<StyledString>,

Inserts an item at position index, shifting all elements after it to the right.

pub fn insert_item_with_choice<S>( &mut self, index: usize, label: S, value: T, chosen: bool, )

where S: Into<StyledString>,

pub fn item<S: Into<StyledString>>(self, label: S, value: T) -> Self

Chainable variant of add_item

Examples

use cursive_multiple_choice_view::MultipleChoiceView;

let multiple_choice_view = MultipleChoiceView::new()
    .item("Item 1", 1)
    .item("Item 2", 2)
    .item("Surprise item", 42);

pub fn item_with_choice<S: Into<StyledString>>( self, label: S, value: T, chosen: bool, ) -> Self

pub fn add_all<S, I>(&mut self, iter: I)

where S: Into<StyledString>, I: IntoIterator<Item = (S, T)>,

Adds all items from from an iterator.

pub fn with_all<S, I>(self, iter: I) -> Self

where S: Into<StyledString>, I: IntoIterator<Item = (S, T)>,

Adds all items from from an iterator.

Chainable variant.

Examples

use cursive_multiple_choice_view::MultipleChoiceView;

// Create a MultipleChoiceView with 100 items
let multiple_choice_view =
    MultipleChoiceView::new().with_all((1u8..100).into_iter().map(|i| (format!("Item {}", i), i)));

pub fn selected_id(&self) -> Option<usize>

Returns the id of the item currently selected.

Returns None if the list is empty.

pub fn len(&self) -> usize

Returns the number of items in this list.

Examples

use cursive_multiple_choice_view::MultipleChoiceView;

let multiple_choice_view = MultipleChoiceView::new()
    .item("Item 1", 1)
    .item("Item 2", 2)
    .item("Item 3", 3);

assert_eq!(multiple_choice_view.len(), 3);

pub fn is_empty(&self) -> bool

Returns true if this list has no item.

Examples

use cursive_multiple_choice_view::MultipleChoiceView;

let mut multiple_choice_view = MultipleChoiceView::new();
assert!(multiple_choice_view.is_empty());

multiple_choice_view.add_item("Item 1", 1);
multiple_choice_view.add_item("Item 2", 2);
assert!(!multiple_choice_view.is_empty());

multiple_choice_view.clear();
assert!(multiple_choice_view.is_empty());

pub fn sort_by_label(&mut self)

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<F>(&mut self, compare: F)

where F: FnMut(&T, &T) -> Ordering,

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_key<K, F>(&mut self, key_of: F)

where F: FnMut(&T) -> K, K: Ord,

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 set_selection(&mut self, i: usize) -> Callback

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 selected(self, i: usize) -> Self

Sets the selection to the given position.

Chainable variant.

Does not apply on_select callbacks.

pub fn get_choice(&self) -> Vec<Arc<T>>

Get all chosen items

pub fn select_up(&mut self, n: usize) -> Callback

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:

fn select_up(siv: &mut Cursive, view: &mut MultipleChoiceView<()>) {
    let cb = view.select_up(1);
    cb(siv);
}

pub fn select_down(&mut self, n: usize) -> Callback

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.

impl MultipleChoiceView<String>

pub fn add_item_str<S: Into<String>>(&mut self, label: S)

Convenient method to use the label as value.

pub fn add_item_str_with_choice<S: Into<String>>( &mut self, label: S, chosen: bool, )

Convenient method to use the label as value.

pub fn add_item_styled<S: Into<StyledString>>(&mut self, label: S)

Convenient method to use the label unstyled text as value.

pub fn item_str<S: Into<String>>(self, label: S) -> Self

Chainable variant of add_item_str.

Examples

use cursive_multiple_choice_view::MultipleChoiceView;

let multiple_choice_view = MultipleChoiceView::new()
    .item_str("Paris")
    .item_str("New York")
    .item_str("Tokyo");

pub fn item_str_with_choice<S: Into<String>>( self, label: S, chosen: bool, ) -> Self

Chainable variant of add_item_str_with_choice.

pub fn item_styled<S: Into<StyledString>>(self, label: S) -> Self

Chainable variant of add_item_styled.

pub fn insert_item_str<S>(&mut self, index: usize, label: S)

where S: Into<String>,

Convenient method to use the label as value.

pub fn add_all_str<S, I>(&mut self, iter: I)

where S: Into<String>, I: IntoIterator<Item = S>,

Adds all strings from an iterator.

Examples

let mut multiple_choice_view = MultipleChoiceView::new();
multiple_choice_view.add_all_str(vec!["a", "b", "c"]);

pub fn with_all_str<S, I>(self, iter: I) -> Self

where S: Into<String>, I: IntoIterator<Item = S>,

Adds all strings from an iterator.

Chainable variant.

Examples

use cursive_multiple_choice_view::MultipleChoiceView;

let text = "..."; // Maybe read some config file

let multiple_choice_view = MultipleChoiceView::new().with_all_str(text.lines());

impl<T> MultipleChoiceView<T>

where T: Ord + 'static,

pub fn sort(&mut self)

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.

Trait Implementations

impl<T: 'static + Send + Sync> Default for MultipleChoiceView<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: 'static + Send + Sync> View for MultipleChoiceView<T>

fn draw(&self, printer: &Printer<'_, '_>)

Draws the view with the given printer (includes bounds) and focus.

fn required_size(&mut self, _: Vec2) -> Vec2

Returns the minimum size the view requires with the given restrictions.

fn on_event(&mut self, event: Event) -> EventResult

Called when an event is received (key press, mouse event, …).

fn take_focus(&mut self, source: Direction) -> Result<EventResult, CannotFocus>

Attempt to give this view the focus.

fn layout(&mut self, size: Vec2)

Called once the size for this view has been decided.

fn important_area(&self, size: Vec2) -> Rect

What part of the view is important and should be visible?

fn needs_relayout(&self) -> bool

Should return true if the view content changed since the last call to layout().

fn call_on_any( &mut self, _: &Selector<'_>, _: &mut dyn FnMut(&mut (dyn View + 'static)), )

Runs a closure on the view identified by the given selector.

fn focus_view(&mut self, _: &Selector<'_>) -> Result<EventResult, ViewNotFound>

Moves the focus to the view identified by the given selector.

fn type_name(&self) -> &'static str

Returns the type of this view.