Struct cursive_extras::AdvancedSelectView

pub struct AdvancedSelectView<T = String>where
    T: 'static,{ /* private fields */ }

A view that is a lot like a SelectView but allows mutable access to the selection and allows multiline items

Implementations

impl AdvancedSelectView

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

Add an item with the label as the value

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

Add an item with the label as the value

Chainable version

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

Insert an item with the label as the value

pub fn add_all_str<S, I>(&mut self, iter: I)where S: Display, I: IntoIterator<Item = S>,

Add all the strings from a string iterator

pub fn with_all_str<S, I>(self, iter: I) -> Selfwhere S: Display, I: IntoIterator<Item = S>,

Add all the strings from a string iterator

Chainable version

impl<T: Ord + 'static> AdvancedSelectView<T>

pub fn sort(&mut self)

Sort all the items by their ordering

impl<T: 'static> AdvancedSelectView<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() -> AdvancedSelectView<T>

Create a new AdvancedSelectView

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

Allow jumping to items starting with the the pressed letter key

pub fn autojump(self) -> Self

Allow jumping to items starting with the the pressed letter key

Chainable version

pub fn set_popup(&mut self, popup: bool)

Show this view as a pop up view

pub fn popup(self) -> Self

Show this view as a pop up view

Chainable version

pub fn set_on_select<F: Fn(&mut Cursive, &T) + 'static>(&mut self, cb: F)

Set the select callback

pub fn on_select<F: Fn(&mut Cursive, &T) + 'static>(self, cb: F) -> Self

Set the select callback

Chainable version

pub fn set_on_submit<F: Fn(&mut Cursive, &T) + 'static>(&mut self, cb: F)

Set the callback when Enter is pressed

pub fn on_submit<F: Fn(&mut Cursive, &T) + 'static>(self, cb: F) -> Self

Set the callback when Enter is pressed

Chainable version

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

The current selection

Returns None if the view is empty

pub fn selection_mut(&mut self) -> Option<&mut T>

The current selection as a mutable reference

Returns None if the view is empty

pub fn selected_index(&self) -> usize

The index of the current selection

pub fn selected_label(&self) -> Option<&StyledString>

The label of the current selected item

pub fn selected_label_mut(&mut self) -> Option<&mut StyledString>

The label of the current selected item

pub fn set_selection(&mut self, index: usize)

Set the selected item index

pub fn selected(self, index: usize) -> Self

Set the selected item ID

Chainable version

pub fn move_down(&mut self) -> bool

Move the selection down

Returns true if successful

pub fn move_up(&mut self) -> bool

Move the selection up

Returns true if successful

pub fn clear(&mut self)

Clear all items

pub fn len(&self) -> usize

How many items are in this view?

pub fn is_empty(&self) -> bool

Is this view empty?

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

Add an item to this view

pub fn add_all<L, I>(&mut self, iter: I)where L: Into<StyledString>, I: IntoIterator<Item = (L, T)>,

Add all items from an iterator

pub fn with_all<L, I>(self, iter: I) -> Selfwhere L: Into<StyledString>, I: IntoIterator<Item = (L, T)>,

Add all items from an iterator

Chainable version

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

Add an item to this view

Chainable version

pub fn get_item(&self, index: usize) -> Option<(&StyledString, &T)>

Get an item at the index

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

Get an item (mutable reference) at the index

pub fn iter( &self ) -> impl Iterator<Item = (&StyledString, &T)> + DoubleEndedIterator + ExactSizeIterator

Iterate over all the items

pub fn iter_mut( &mut self ) -> impl Iterator<Item = (&mut StyledString, &mut T)> + DoubleEndedIterator + ExactSizeIteratorwhere T: Clone,

Iterate over all the items with mutability

pub fn remove_item(&mut self, index: usize)

Remove an item at a specific index

pub fn insert_item<L: Into<StyledString>>( &mut self, index: usize, label: L, item: T )

Insert an item at a specific index

pub fn label_sort(&mut self)

Sort the view by label

pub fn sort_by<F>(&mut self, compare: F)where F: FnMut(&T, &T) -> Ordering,

Sort the view with the specified comparator function

pub fn sort_by_key<K, F>(&mut self, key_of: F)where F: FnMut(&T) -> K, K: Ord,

Sort the view with a key extraction function

pub fn move_item_up(&mut self, index: usize)

Move an item up in the view

pub fn move_item_down(&mut self, index: usize)

Move an item down in the view

Trait Implementations

impl<T: 'static> Default for AdvancedSelectView<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: 'static> View for AdvancedSelectView<T>

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

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

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

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

fn layout(&mut self, size: Vec2)

Called once the size for this view has been decided.

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

Attempt to give this view the focus.

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

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

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.