Struct cursive_table_view::TableView

pub struct TableView<T: TableViewItem<H>, H: Eq + Hash + Copy + Clone + 'static> { /* fields omitted */ }

View to select an item among a list, supporting multiple columns for sorting.

Examples

// Provide a type for the table's columns
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
enum BasicColumn {
    Name,
    Count,
    Rate
}

// Define the item type
#[derive(Clone, Debug)]
struct Foo {
    name: String,
    count: usize,
    rate: usize
}

impl TableViewItem<BasicColumn> for Foo {

    fn to_column(&self, column: BasicColumn) -> String {
        match column {
            BasicColumn::Name => self.name.to_string(),
            BasicColumn::Count => format!("{}", self.count),
            BasicColumn::Rate => format!("{}", self.rate)
        }
    }

    fn cmp(&self, other: &Self, column: BasicColumn) -> Ordering where Self: Sized {
        match column {
            BasicColumn::Name => self.name.cmp(&other.name),
            BasicColumn::Count => self.count.cmp(&other.count),
            BasicColumn::Rate => self.rate.cmp(&other.rate)
        }
    }

}

// Configure the actual table
let table = TableView::<Foo, BasicColumn>::new()
                     .column(BasicColumn::Name, "Name", |c| c.width(20))
                     .column(BasicColumn::Count, "Count", |c| c.align(HAlign::Center))
                     .column(BasicColumn::Rate, "Rate", |c| {
                         c.ordering(Ordering::Greater).align(HAlign::Right).width(20)
                     })
                     .default_column(BasicColumn::Name);

Methods

impl<T: TableViewItem<H>, H: Eq + Hash + Copy + Clone + 'static> TableView<T, H>

fn new() -> Self

Creates a new empty TableView without any columns.

A TableView should be accompanied by a enum of type H representing the table columns.

fn column<S: Into<String>, C: FnOnce(TableColumn<H>) -> TableColumn<H>>(
    self,
    column: H,
    title: S,
    callback: C
) -> Self

Adds a column for the specified table colum from type H along with a title for its visual display.

The provided callback can be used to further configure the created TableColumn.

fn default_column(self, column: H) -> Self

Sets the initially active column of the table.

fn sort_by(&mut self, column: H, order: Ordering)

Sorts the table in the passed in order based on the values from the specified table column from type H .

fn disable(&mut self)

Disables this view.

A disabled view cannot be selected.

fn enable(&mut self)

Re-enables this view.

fn set_enabled(&mut self, enabled: bool)

Enable or disable this view.

fn is_enabled(&self) -> bool

Returns true if this view is enabled.

fn set_on_sort<F>(&mut self, cb: F) where
    F: Fn(&mut Cursive, H, Ordering) + 'static, 

Sets a callback to be used when a column is sorted.

fn on_sort<F>(self, cb: F) -> Self where
    F: Fn(&mut Cursive, H, Ordering) + 'static, 

Sets a callback to be used when a column is sorted.

Chainable variant.

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

Sets a callback to be used when <Enter> is pressed while an item is selected.

Both the currently selected row and the index of the corresponding item within the underlying storage vector will be given to the callback.

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

Sets a callback to be used when <Enter> is pressed while an item is selected.

Both the currently selected row and the index of the corresponding item within the underlying storage vector will be given to the callback.

Chainable variant.

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

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

Both the currently selected row and the index of the corresponding item within the underlying storage vector will be given to the callback.

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

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

Both the currently selected row and the index of the corresponding item within the underlying storage vector will be given to the callback.

Chainable variant.

fn clear(&mut self)

Removes all items from this view.

fn len(&self) -> usize

Returns the number of items in this table.

fn is_empty(&self) -> bool

Returns true if this table has no item.

fn row(&self) -> Option<usize>

Returns the index of the currently selected table row.

fn set_selected_row(&mut self, row_index: usize)

Selects the row at the specified index.

fn selected_row(self, row_index: usize) -> Self

Selects the row at the specified index.

Chainable variant.

fn set_items(&mut self, items: Vec<T>)

Sets the contained items of the table.

The order of the items will be preserved even when the table is sorted.

fn items(self, items: Vec<T>) -> Self

Sets the contained items of the table.

The order of the items will be preserved even when the table is sorted.

Chainable variant.

fn borrow_item(&mut self, index: usize) -> Option<&T>

Returns a immmutable reference to the item at the specified index within the underlying storage vector.

fn borrow_item_mut(&mut self, index: usize) -> Option<&mut T>

Returns a mutable reference to the item at the specified index within the underlying storage vector.

fn item(&self) -> Option<usize>

Returns the index of the currently selected item within the underlying storage vector.

fn set_selected_item(&mut self, item_index: usize)

Selects the item at the specified index within the underlying storage vector.

fn selected_item(self, item_index: usize) -> Self

Selects the item at the specified index within the underlying storage vector.

Chainable variant.

fn insert_item(&mut self, item: T)

Inserts a new item into the table.

Sort order is preserved and the item will be inserted accordingly.

fn remove_item(&mut self, item_index: usize) -> Option<T>

Removes the item at the specified index within the underlying storage vector and returns it.

fn take_items(&mut self) -> Vec<T>

Removes all items from the underlying storage and returns them.

Trait Implementations

impl<T: TableViewItem<H> + 'static, H: Eq + Hash + Copy + Clone + 'static> View for TableView<T, H>

fn draw(&self, printer: &Printer)

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

fn layout(&mut self, size: Vec2)

Called once the size for this view has been decided,

fn take_focus(&mut self, _: Direction) -> bool

This view is offered focus. Will it take it?

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

Called when a key was pressed.

fn required_size(&mut self, constraint: XY<usize>) -> XY<usize>

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

fn needs_relayout(&self) -> bool

Returns true if the view content changed since last layout phase.

fn call_on_any(&mut self, &Selector, Box<FnMut(&mut Any + 'static) + 'a>)

Finds the view identified by the given selector.

fn focus_view(&mut self, &Selector) -> Result<(), ()>

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