better_cursive_table/

lib.rs

//! A basic table view implementation for [cursive](https://crates.io/crates/cursive).
#![deny(
    missing_docs,
    missing_copy_implementations,
    trivial_casts,
    trivial_numeric_casts,
    unsafe_code,
    unused_import_braces,
    unused_qualifications
)]

// Crate Dependencies ---------------------------------------------------------
use cursive_core as cursive;

// STD Dependencies -----------------------------------------------------------
use std::cmp::{self, Ordering};
use std::collections::HashMap;
use std::hash::Hash;
use std::sync::Arc;

// External Dependencies ------------------------------------------------------
use cursive::{
    align::HAlign,
    direction::Direction,
    event::{Callback, Event, EventResult, Key, MouseButton, MouseEvent},
    theme,
    vec::Vec2,
    view::{scroll, CannotFocus, View},
    Cursive, Printer, Rect, With,
};

/// A trait for displaying and sorting items inside a
/// [`TableView`](struct.TableView.html).
pub trait TableViewItem<H>: Clone + Sized
where
    H: Eq + Hash + Copy + Clone + Send + Sync + 'static,
{
    /// Method returning a string representation of the item for the
    /// specified column from type `H`.
    fn to_column(&self, column: H) -> String;

    /// Method comparing two items via their specified column from type `H`.
    fn cmp(&self, other: &Self, column: H) -> Ordering
    where
        Self: Sized;
}

/// Controls whether a table selection targets rows or individual cells.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum SelectMode {
    /// Selection is row-based.
    Row,
    /// Selection is cell-based.
    Cell,
}

/// A trait for displaying items inside an
/// [`ArrayView`](struct.ArrayView.html).
pub trait ArrayViewItem<H>: Clone + Sized
where
    H: Eq + Hash + Copy + Clone + Send + Sync + 'static,
{
    /// Method returning a string representation of the item for the
    /// specified column from type `H`.
    fn to_column(&self, column: H) -> String;

    /// Method returning a string representation of the item for the row
    /// header.
    fn to_row(&self) -> String;

    /// Returns the column definitions used by [`ArrayViewItem::to_array_view`].
    ///
    /// The default implementation returns an empty list, creating an
    /// `ArrayView` with no columns.
    fn columns() -> Vec<(H, String)> {
        Vec::new()
    }

    /// Creates an [`ArrayView`](struct.ArrayView.html) from the provided items.
    ///
    /// Columns are populated from [`ArrayViewItem::columns`].
    fn to_array_view(items: Vec<Self>) -> ArrayView<Self, H>
    where
        Self: Sized,
    {
        let mut array = ArrayView::<Self, H>::new();
        for (column, title) in Self::columns() {
            array.add_column(column, title, |c| c);
        }
        array.set_items(items);
        array
    }
}

/// A simple row type for building array views from raw headers and data.
///
/// Row labels are stored separately and referenced by index.
#[derive(Clone)]
pub struct ArrayDataRow<T> {
    row_index: usize,
    row_headers: Arc<Vec<String>>,
    cells: Vec<T>,
}

impl<T> ArrayDataRow<T> {
    fn new(row_index: usize, row_headers: Arc<Vec<String>>, cells: Vec<T>) -> Self {
        Self {
            row_index,
            row_headers,
            cells,
        }
    }
}

impl<T> ArrayViewItem<usize> for ArrayDataRow<T>
where
    T: ToString + Clone,
{
    fn to_column(&self, column: usize) -> String {
        self.cells
            .get(column)
            .map(|value| value.to_string())
            .unwrap_or_default()
    }

    fn to_row(&self) -> String {
        self.row_headers
            .get(self.row_index)
            .cloned()
            .unwrap_or_else(|| format!("R{}", self.row_index + 1))
    }
}

/// A builder for creating `ArrayView` instances from headers and raw data.
pub struct ArrayBuilder<T> {
    row_headers: Vec<String>,
    column_headers: Vec<String>,
    array_name: Option<String>,
    data: Vec<Vec<T>>,
    row_header_alignment: HAlign,
    column_header_alignment: HAlign,
    data_alignment: HAlign,
}

impl<T> Default for ArrayBuilder<T> {
    fn default() -> Self {
        Self {
            row_headers: Vec::new(),
            column_headers: Vec::new(),
            array_name: None,
            data: Vec::new(),
            row_header_alignment: HAlign::Center,
            column_header_alignment: HAlign::Center,
            data_alignment: HAlign::Center,
        }
    }
}

impl<T> ArrayBuilder<T>
where
    T: ToString + Clone,
{
    /// Creates a new empty builder.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the row header labels.
    pub fn row_header<S: Into<String>>(mut self, rows: Vec<S>) -> Self {
        self.row_headers = rows.into_iter().map(Into::into).collect();
        self
    }

    /// Sets the row header labels.
    pub fn row_headers<S: Into<String>>(self, rows: Vec<S>) -> Self {
        self.row_header(rows)
    }

    /// Sets the column header labels.
    pub fn column_header<S: Into<String>>(mut self, columns: Vec<S>) -> Self {
        self.column_headers = columns.into_iter().map(Into::into).collect();
        self
    }

    /// Sets the column header labels.
    pub fn column_headers<S: Into<String>>(self, columns: Vec<S>) -> Self {
        self.column_header(columns)
    }

    /// Sets the row header alignment.
    pub fn row_header_orientation(mut self, alignment: HAlign) -> Self {
        self.row_header_alignment = alignment;
        self
    }

    /// Sets the column header alignment.
    pub fn column_header_orientation(mut self, alignment: HAlign) -> Self {
        self.column_header_alignment = alignment;
        self
    }

    /// Sets the data cell alignment.
    pub fn data_orientation(mut self, alignment: HAlign) -> Self {
        self.data_alignment = alignment;
        self
    }

    /// Sets the top-left array name.
    pub fn array_name<S: Into<String>>(mut self, name: S) -> Self {
        self.array_name = Some(name.into());
        self
    }

    /// Sets the raw row data.
    pub fn data(mut self, data: Vec<Vec<T>>) -> Self {
        self.data = data;
        self
    }

    /// Adds a column header.
    pub fn add_column<S: Into<String>>(mut self, column: S) -> Self {
        self.column_headers.push(column.into());
        self
    }

    /// Adds a column header and appends a default value to each existing row.
    pub fn add_column_with_default<S: Into<String>>(mut self, column: S, default: T) -> Self {
        self.column_headers.push(column.into());
        for row in &mut self.data {
            row.push(default.clone());
        }
        self
    }

    /// Builds the array view using `usize` column keys.
    pub fn add_row<S: Into<String>>(mut self, row: S, data: Vec<T>) -> Self {
        self.row_headers.push(row.into());
        self.data.push(data);
        self
    }

    /// Removes the last row, if any.
    pub fn remove_row(mut self) -> Self {
        if self.data.pop().is_some() {
            self.row_headers.pop();
        }
        self
    }

    /// Removes the last column, if any.
    pub fn remove_column(mut self) -> Self {
        if self.column_headers.pop().is_some() {
            for row in &mut self.data {
                row.pop();
            }
        }
        self
    }

    /// Builds the array view using `usize` column keys.
    pub fn build(self) -> ArrayView<ArrayDataRow<T>, usize> {
        let col_count = if self.column_headers.is_empty() {
            self.data.iter().map(Vec::len).max().unwrap_or(0)
        } else {
            self.column_headers.len()
        };

        let mut row_headers = self.row_headers;
        if row_headers.len() < self.data.len() {
            let start = row_headers.len();
            let end = self.data.len();
            row_headers.extend((start..end).map(|i| format!("R{}", i + 1)));
        }

        let mut row_header_width = row_headers
            .iter()
            .map(|header| header.chars().count())
            .max()
            .unwrap_or(0);
        if let Some(name) = self.array_name.as_ref() {
            row_header_width = row_header_width.max(name.chars().count());
        }

        let mut titles = Vec::with_capacity(col_count);
        let mut column_widths = vec![0; col_count];
        for i in 0..col_count {
            let title = self
                .column_headers
                .get(i)
                .cloned()
                .unwrap_or_else(|| format!("C{}", i + 1));
            column_widths[i] = title.chars().count();
            titles.push(title);
        }

        for row in &self.data {
            for (i, cell) in row.iter().enumerate() {
                if i >= col_count {
                    break;
                }
                let width = cell.to_string().chars().count();
                if width > column_widths[i] {
                    column_widths[i] = width;
                }
            }
        }
        let mut array = ArrayView::<ArrayDataRow<T>, usize>::new();
        array.set_row_header(|h| {
            let h = h.align(self.row_header_alignment);
            if row_header_width > 0 {
                h.width(row_header_width)
            } else {
                h
            }
        });

        for i in 0..col_count {
            let title = titles[i].clone();
            let width = column_widths[i];
            let column_header_alignment = self.column_header_alignment;
            let data_alignment = self.data_alignment;
            array.add_column(i, title, move |c| {
                let c = c.align(data_alignment).header_align(column_header_alignment);
                if width > 0 {
                    c.width(width)
                } else {
                    c
                }
            });
        }

        let row_headers = Arc::new(row_headers);
        let mut items = Vec::with_capacity(self.data.len());
        for (i, mut cells) in self.data.into_iter().enumerate() {
            if col_count > 0 && cells.len() > col_count {
                cells.truncate(col_count);
            }
            items.push(ArrayDataRow::new(i, Arc::clone(&row_headers), cells));
        }
        array.set_items(items);

        if let Some(name) = self.array_name {
            array.set_array_name(name);
        }

        array
    }
}

/// A simple row type for building table views from raw headers and data.
#[derive(Clone)]
pub struct TableDataRow<T> {
    cells: Vec<T>,
}

impl<T> TableDataRow<T> {
    fn new(cells: Vec<T>) -> Self {
        Self { cells }
    }
}

impl<T> TableViewItem<usize> for TableDataRow<T>
where
    T: ToString + Clone,
{
    fn to_column(&self, column: usize) -> String {
        self.cells
            .get(column)
            .map(|value| value.to_string())
            .unwrap_or_default()
    }

    fn cmp(&self, other: &Self, column: usize) -> Ordering {
        let left = self
            .cells
            .get(column)
            .map(|value| value.to_string())
            .unwrap_or_default();
        let right = other
            .cells
            .get(column)
            .map(|value| value.to_string())
            .unwrap_or_default();
        left.cmp(&right)
    }
}

/// A builder for creating `TableView` instances from headers and raw data.
pub struct TableBuilder<T> {
    column_headers: Vec<String>,
    data: Vec<Vec<T>>,
    column_header_alignment: HAlign,
    data_alignment: HAlign,
    sortable: bool,
}

impl<T> Default for TableBuilder<T> {
    fn default() -> Self {
        Self {
            column_headers: Vec::new(),
            data: Vec::new(),
            column_header_alignment: HAlign::Center,
            data_alignment: HAlign::Center,
            sortable: false,
        }
    }
}

impl<T> TableBuilder<T>
where
    T: ToString + Clone,
{
    /// Creates a new empty builder.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the column header labels.
    pub fn column_header<S: Into<String>>(mut self, columns: Vec<S>) -> Self {
        self.column_headers = columns.into_iter().map(Into::into).collect();
        self
    }

    /// Sets the column header labels.
    pub fn column_headers<S: Into<String>>(self, columns: Vec<S>) -> Self {
        self.column_header(columns)
    }

    /// Sets the column header alignment.
    pub fn column_header_orientation(mut self, alignment: HAlign) -> Self {
        self.column_header_alignment = alignment;
        self
    }

    /// Sets the data cell alignment.
    pub fn data_orientation(mut self, alignment: HAlign) -> Self {
        self.data_alignment = alignment;
        self
    }

    /// Enables or disables sorting.
    pub fn sortable(mut self, sortable: bool) -> Self {
        self.sortable = sortable;
        self
    }

    /// Sets the raw row data.
    pub fn data(mut self, data: Vec<Vec<T>>) -> Self {
        self.data = data;
        self
    }

    /// Adds a column header.
    pub fn add_column<S: Into<String>>(mut self, column: S) -> Self {
        self.column_headers.push(column.into());
        self
    }

    /// Adds a column header and appends a default value to each existing row.
    pub fn add_column_with_default<S: Into<String>>(mut self, column: S, default: T) -> Self {
        self.column_headers.push(column.into());
        for row in &mut self.data {
            row.push(default.clone());
        }
        self
    }

    /// Adds a row of data.
    pub fn add_row(mut self, data: Vec<T>) -> Self {
        self.data.push(data);
        self
    }

    /// Removes the last row, if any.
    pub fn remove_row(mut self) -> Self {
        self.data.pop();
        self
    }

    /// Removes the last column, if any.
    pub fn remove_column(mut self) -> Self {
        if self.column_headers.pop().is_some() {
            for row in &mut self.data {
                row.pop();
            }
        }
        self
    }

    /// Builds the table view using `usize` column keys.
    pub fn build(self) -> TableView<TableDataRow<T>, usize> {
        let col_count = if self.column_headers.is_empty() {
            self.data.iter().map(Vec::len).max().unwrap_or(0)
        } else {
            self.column_headers.len()
        };

        let mut titles = Vec::with_capacity(col_count);
        let mut column_widths = vec![0; col_count];
        for i in 0..col_count {
            let title = self
                .column_headers
                .get(i)
                .cloned()
                .unwrap_or_else(|| format!("C{}", i + 1));
            column_widths[i] = title.chars().count();
            titles.push(title);
        }

        for row in &self.data {
            for (i, cell) in row.iter().enumerate() {
                if i >= col_count {
                    break;
                }
                let width = cell.to_string().chars().count();
                if width > column_widths[i] {
                    column_widths[i] = width;
                }
            }
        }
        if self.sortable {
            for (i, title) in titles.iter().enumerate() {
                let target = title.chars().count().saturating_add(4);
                if column_widths[i] < target {
                    column_widths[i] = target;
                }
            }
        }

        let mut table = TableView::<TableDataRow<T>, usize>::new();
        for i in 0..col_count {
            let title = titles[i].clone();
            let width = column_widths[i];
            let header_alignment = self.column_header_alignment;
            let data_alignment = self.data_alignment;
            table.add_column(i, title, move |c| {
                let c = c.align(data_alignment).header_align(header_alignment);
                if width > 0 {
                    c.width(width)
                } else {
                    c
                }
            });
        }

        table.set_sortable(self.sortable);

        let mut items = Vec::with_capacity(self.data.len());
        for mut row in self.data.into_iter() {
            if col_count > 0 && row.len() > col_count {
                row.truncate(col_count);
            }
            items.push(TableDataRow::new(row));
        }
        table.set_items(items);

        table
    }
}

/// Callback used when a column is sorted.
///
/// It takes the column and the ordering as input.
///
/// This is a private type to help readability.
type OnSortCallback<H> = Arc<dyn Fn(&mut Cursive, H, Ordering) + Send + Sync>;

/// Callback taking as argument the row and the index of an element.
///
/// This is a private type to help readability.
type IndexCallback = Arc<dyn Fn(&mut Cursive, usize, usize) + Send + Sync>;

/// Callback taking as argument the row and the column of an array cell.
///
/// This is a private type to help readability.
type CellCallback<H> = Arc<dyn Fn(&mut Cursive, usize, H) + Send + Sync>;

/// View to select an item among a list, supporting multiple columns for sorting.
///
/// # Examples
///
/// ```rust
/// # extern crate cursive;
/// # extern crate better_cursive_table;
/// # use std::cmp::Ordering;
/// # use better_cursive_table::{TableView, TableViewItem};
/// # use cursive::align::HAlign;
/// # fn main() {
/// // 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);
/// # }
/// ```
pub struct TableView<T, H> {
    enabled: bool,
    sortable: bool,
    scroll_core: scroll::Core,
    needs_relayout: bool,

    column_select: bool,
    columns: Vec<TableColumn<H>>,
    // Column enum -> columns vector index lookup.
    column_indices: HashMap<H, usize>,

    focus: usize,
    focus_col: usize,
    items: Vec<T>,
    // Row index -> item index after sorting.
    rows_to_items: Vec<usize>,

    on_sort: Option<OnSortCallback<H>>,
    // TODO Pass drawing offsets into the handlers so a popup menu
    // can be created easily?
    on_submit: Option<IndexCallback>,
    on_submit_cell: Option<CellCallback<H>>,
    on_select: Option<IndexCallback>,
    selection_mode: SelectMode,
}

cursive::impl_scroller!(TableView < T, H > ::scroll_core);

impl<T, H> Default for TableView<T, H>
where
    T: TableViewItem<H> + PartialEq,
    H: Eq + Hash + Copy + Clone + Send + Sync + 'static,
{
    /// Creates a new empty `TableView` without any columns.
    ///
    /// See [`TableView::new()`].
    fn default() -> Self {
        Self::new()
    }
}

impl<T, H> TableView<T, H>
where
    T: TableViewItem<H> + PartialEq,
    H: Eq + Hash + Copy + Clone + Send + Sync + 'static,
{
    /// Sets the contained items of the table.
    ///
    /// The currently active sort order is preserved and will be applied to all
    /// items.
    ///
    /// Compared to `set_items`, the current selection will be preserved.
    /// (But this is only available for `T: PartialEq`.)
    pub fn set_items_stable(&mut self, items: Vec<T>) {
        // Preserve selection
        let new_location = self
            .item()
            .and_then(|old_item| {
                let old_item = &self.items[old_item];
                items.iter().position(|new| new == old_item)
            })
            .unwrap_or(0);

        self.set_items_and_focus(items, new_location);
    }
}

impl<T, H> TableView<T, H>
where
    T: TableViewItem<H>,
    H: Eq + Hash + Copy + Clone + Send + Sync + 'static,
{
    /// Creates a new empty `TableView` without any columns.
    ///
    /// A TableView should be accompanied by a enum of type `H` representing
    /// the table columns.
    pub fn new() -> Self {
        Self {
            enabled: true,
            sortable: true,
            scroll_core: scroll::Core::new(),
            needs_relayout: true,

            column_select: false,
            columns: Vec::new(),
            column_indices: HashMap::new(),

            focus: 0,
            focus_col: 0,
            items: Vec::new(),
            rows_to_items: Vec::new(),

            on_sort: None,
            on_submit: None,
            on_submit_cell: None,
            on_select: None,
            selection_mode: SelectMode::Row,
        }
    }

    /// Adds a column for the specified table column from type `H` along with
    /// a title for its visual display.
    ///
    /// The provided callback can be used to further configure the
    /// created [`TableColumn`](struct.TableColumn.html).
    pub fn column<S: Into<String>, C: FnOnce(TableColumn<H>) -> TableColumn<H>>(
        mut self,
        column: H,
        title: S,
        callback: C,
    ) -> Self {
        self.add_column(column, title, callback);
        self
    }

    /// Adds a column for the specified table column from type `H` along with
    /// a title for its visual display.
    ///
    /// The provided callback can be used to further configure the
    /// created [`TableColumn`](struct.TableColumn.html).
    pub fn add_column<S: Into<String>, C: FnOnce(TableColumn<H>) -> TableColumn<H>>(
        &mut self,
        column: H,
        title: S,
        callback: C,
    ) {
        self.insert_column(self.columns.len(), column, title, callback);
    }

    /// Remove a column.
    pub fn remove_column(&mut self, i: usize) {
        // Update the existing indices
        for column in &self.columns[i + 1..] {
            *self.column_indices.get_mut(&column.column).unwrap() -= 1;
        }

        let column = self.columns.remove(i);
        self.column_indices.remove(&column.column);
        if self.focus_col >= self.columns.len() {
            self.focus_col = self.columns.len().saturating_sub(1);
        } else if i <= self.focus_col {
            self.focus_col = self.focus_col.saturating_sub(1);
        }
        self.needs_relayout = true;
    }

    /// Adds a column for the specified table column from type `H` along with
    /// a title for its visual display.
    ///
    /// The provided callback can be used to further configure the
    /// created [`TableColumn`](struct.TableColumn.html).
    pub fn insert_column<S: Into<String>, C: FnOnce(TableColumn<H>) -> TableColumn<H>>(
        &mut self,
        i: usize,
        column: H,
        title: S,
        callback: C,
    ) {
        // Update all existing indices
        for column in &self.columns[i..] {
            *self.column_indices.get_mut(&column.column).unwrap() += 1;
        }

        self.column_indices.insert(column, i);
        self.columns
            .insert(i, callback(TableColumn::new(column, title.into())));

        if i <= self.focus_col {
            self.focus_col += 1;
        }

        // Make the first column the default one
        if self.columns.len() == 1 {
            self.set_default_column(column);
        }
        self.needs_relayout = true;
    }

    /// Sets the initially active column of the table.
    pub fn default_column(mut self, column: H) -> Self {
        self.set_default_column(column);
        self
    }

    /// Sets the initially active column of the table.
    pub fn set_default_column(&mut self, column: H) {
        if self.column_indices.contains_key(&column) {
            for c in &mut self.columns {
                c.selected = c.column == column;
                if c.selected {
                    c.order = c.default_order;
                } else {
                    c.order = Ordering::Equal;
                }
            }
            if let Some(index) = self.column_indices.get(&column) {
                self.focus_col = *index;
            }
        }
    }

    /// Sorts the table using the specified table `column` and the passed
    /// `order`.
    pub fn sort_by(&mut self, column: H, order: Ordering) {
        if !self.sortable {
            return;
        }

        if self.column_indices.contains_key(&column) {
            for c in &mut self.columns {
                // Move selection back to the sorted column.
                let selected = c.column == column;
                c.selected = selected;
                c.order = if selected { order } else { Ordering::Equal };
            }
        }

        self.sort_items(column, order);
    }

    /// Sorts the table using the currently active column and its
    /// ordering.
    pub fn sort(&mut self) {
        if !self.sortable || self.items.len() <= 1 {
            return;
        }

        if let Some((column, order)) = self.order() {
            self.sort_items(column, order);
        }
    }

    /// Returns the currently active column that is used for sorting
    /// along with its ordering.
    ///
    /// Might return `None` if there are currently no items in the table
    /// and it has not been sorted yet.
    pub fn order(&self) -> Option<(H, Ordering)> {
        for c in &self.columns {
            if c.order != Ordering::Equal {
                return Some((c.column, c.order));
            }
        }
        None
    }

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

    /// 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;
    }

    /// Enable or disable sorting, header selection, and sort indicators.
    pub fn set_sortable(&mut self, sortable: bool) {
        self.sortable = sortable;
        self.column_select &= sortable;
    }

    /// Sets the selection mode for this table.
    pub fn set_selection_mode(&mut self, mode: SelectMode) {
        self.selection_mode = mode;
        if mode == SelectMode::Row {
            self.column_select = false;
        }
    }

    /// Sets the selection mode for this table.
    ///
    /// Chainable variant.
    pub fn selection_mode(mut self, mode: SelectMode) -> Self {
        self.set_selection_mode(mode);
        self
    }

    /// Enable or disable sorting, header selection, and sort indicators.
    ///
    /// Chainable variant.
    pub fn sortable(self, sortable: bool) -> Self {
        self.with(|t| t.set_sortable(sortable))
    }

    /// Returns `true` if sorting is enabled.
    pub fn is_sortable(&self) -> bool {
        self.sortable
    }

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

    /// Sets a callback to be used when a selected column is sorted by
    /// pressing `<Enter>`.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use std::cmp::Ordering;
    /// # use cursive_core::Cursive;
    /// # use better_cursive_table::{TableView, TableViewItem};
    /// # #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    /// # enum BasicColumn { Name }
    /// # #[derive(Clone)]
    /// # struct Item { name: String }
    /// # impl TableViewItem<BasicColumn> for Item {
    /// #     fn to_column(&self, column: BasicColumn) -> String {
    /// #         match column { BasicColumn::Name => self.name.clone() }
    /// #     }
    /// #     fn cmp(&self, other: &Self, column: BasicColumn) -> Ordering where Self: Sized {
    /// #         match column { BasicColumn::Name => self.name.cmp(&other.name) }
    /// #     }
    /// # }
    /// # let mut table = TableView::<Item, BasicColumn>::new()
    /// #     .column(BasicColumn::Name, "Name", |c| c);
    /// table.set_on_sort(|_siv: &mut Cursive, _column: BasicColumn, _order: Ordering| {
    /// });
    /// ```
    pub fn set_on_sort<F>(&mut self, cb: F)
    where
        F: Fn(&mut Cursive, H, Ordering) + Send + Sync + 'static,
    {
        self.on_sort = Some(Arc::new(move |s, h, o| cb(s, h, o)));
    }

    /// Sets a callback to be used when a selected column is sorted by
    /// pressing `<Enter>`.
    ///
    /// Chainable variant.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use std::cmp::Ordering;
    /// # use cursive_core::Cursive;
    /// # use better_cursive_table::{TableView, TableViewItem};
    /// # #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    /// # enum BasicColumn { Name }
    /// # #[derive(Clone)]
    /// # struct Item { name: String }
    /// # impl TableViewItem<BasicColumn> for Item {
    /// #     fn to_column(&self, column: BasicColumn) -> String {
    /// #         match column { BasicColumn::Name => self.name.clone() }
    /// #     }
    /// #     fn cmp(&self, other: &Self, column: BasicColumn) -> Ordering where Self: Sized {
    /// #         match column { BasicColumn::Name => self.name.cmp(&other.name) }
    /// #     }
    /// # }
    /// # let table = TableView::<Item, BasicColumn>::new()
    /// #     .column(BasicColumn::Name, "Name", |c| c);
    /// let _table =
    ///     table.on_sort(|_siv: &mut Cursive, _column: BasicColumn, _order: Ordering| {});
    /// ```
    pub fn on_sort<F>(self, cb: F) -> Self
    where
        F: Fn(&mut Cursive, H, Ordering) + Send + Sync + 'static,
    {
        self.with(|t| t.set_on_sort(cb))
    }

    /// 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.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use cursive_core::Cursive;
    /// # use std::cmp::Ordering;
    /// # use better_cursive_table::{TableView, TableViewItem};
    /// # #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    /// # enum BasicColumn { Name }
    /// # #[derive(Clone)]
    /// # struct Item { name: String }
    /// # impl TableViewItem<BasicColumn> for Item {
    /// #     fn to_column(&self, column: BasicColumn) -> String {
    /// #         match column { BasicColumn::Name => self.name.clone() }
    /// #     }
    /// #     fn cmp(&self, other: &Self, column: BasicColumn) -> Ordering where Self: Sized {
    /// #         match column { BasicColumn::Name => self.name.cmp(&other.name) }
    /// #     }
    /// # }
    /// # let mut table = TableView::<Item, BasicColumn>::new()
    /// #     .column(BasicColumn::Name, "Name", |c| c);
    /// table.set_on_submit(|_siv: &mut Cursive, _row: usize, _index: usize| {
    /// });
    /// ```
    pub fn set_on_submit<F>(&mut self, cb: F)
    where
        F: Fn(&mut Cursive, usize, usize) + Send + Sync + 'static,
    {
        self.on_submit = Some(Arc::new(move |s, row, index| cb(s, row, index)));
    }

    /// Sets a callback to be used when `<Enter>` is pressed while a cell
    /// is selected.
    ///
    /// The currently selected row and column will be given to the callback.
    pub fn set_on_submit_cell<F>(&mut self, cb: F)
    where
        F: Fn(&mut Cursive, usize, H) + Send + Sync + 'static,
    {
        self.on_submit_cell = Some(Arc::new(move |s, row, column| cb(s, row, column)));
    }

    /// 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.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use cursive_core::Cursive;
    /// # use std::cmp::Ordering;
    /// # use better_cursive_table::{TableView, TableViewItem};
    /// # #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    /// # enum BasicColumn { Name }
    /// # #[derive(Clone)]
    /// # struct Item { name: String }
    /// # impl TableViewItem<BasicColumn> for Item {
    /// #     fn to_column(&self, column: BasicColumn) -> String {
    /// #         match column { BasicColumn::Name => self.name.clone() }
    /// #     }
    /// #     fn cmp(&self, other: &Self, column: BasicColumn) -> Ordering where Self: Sized {
    /// #         match column { BasicColumn::Name => self.name.cmp(&other.name) }
    /// #     }
    /// # }
    /// # let table = TableView::<Item, BasicColumn>::new()
    /// #     .column(BasicColumn::Name, "Name", |c| c);
    /// let _table = table.on_submit(|_siv: &mut Cursive, _row: usize, _index: usize| {});
    /// ```
    pub fn on_submit<F>(self, cb: F) -> Self
    where
        F: Fn(&mut Cursive, usize, usize) + Send + Sync + 'static,
    {
        self.with(|t| t.set_on_submit(cb))
    }

    /// Sets a callback to be used when `<Enter>` is pressed while a cell
    /// is selected.
    ///
    /// The currently selected row and column will be given to the callback.
    ///
    /// Chainable variant.
    pub fn on_submit_cell<F>(self, cb: F) -> Self
    where
        F: Fn(&mut Cursive, usize, H) + Send + Sync + 'static,
    {
        self.with(|t| t.set_on_submit_cell(cb))
    }

    /// 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.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use cursive_core::Cursive;
    /// # use std::cmp::Ordering;
    /// # use better_cursive_table::{TableView, TableViewItem};
    /// # #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    /// # enum BasicColumn { Name }
    /// # #[derive(Clone)]
    /// # struct Item { name: String }
    /// # impl TableViewItem<BasicColumn> for Item {
    /// #     fn to_column(&self, column: BasicColumn) -> String {
    /// #         match column { BasicColumn::Name => self.name.clone() }
    /// #     }
    /// #     fn cmp(&self, other: &Self, column: BasicColumn) -> Ordering where Self: Sized {
    /// #         match column { BasicColumn::Name => self.name.cmp(&other.name) }
    /// #     }
    /// # }
    /// # let mut table = TableView::<Item, BasicColumn>::new()
    /// #     .column(BasicColumn::Name, "Name", |c| c);
    /// table.set_on_select(|_siv: &mut Cursive, _row: usize, _index: usize| {
    /// });
    /// ```
    pub fn set_on_select<F>(&mut self, cb: F)
    where
        F: Fn(&mut Cursive, usize, usize) + Send + Sync + 'static,
    {
        self.on_select = Some(Arc::new(move |s, row, index| cb(s, row, index)));
    }

    /// 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.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use cursive_core::Cursive;
    /// # use std::cmp::Ordering;
    /// # use better_cursive_table::{TableView, TableViewItem};
    /// # #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    /// # enum BasicColumn { Name }
    /// # #[derive(Clone)]
    /// # struct Item { name: String }
    /// # impl TableViewItem<BasicColumn> for Item {
    /// #     fn to_column(&self, column: BasicColumn) -> String {
    /// #         match column { BasicColumn::Name => self.name.clone() }
    /// #     }
    /// #     fn cmp(&self, other: &Self, column: BasicColumn) -> Ordering where Self: Sized {
    /// #         match column { BasicColumn::Name => self.name.cmp(&other.name) }
    /// #     }
    /// # }
    /// # let table = TableView::<Item, BasicColumn>::new()
    /// #     .column(BasicColumn::Name, "Name", |c| c);
    /// let _table = table.on_select(|_siv: &mut Cursive, _row: usize, _index: usize| {});
    /// ```
    pub fn on_select<F>(self, cb: F) -> Self
    where
        F: Fn(&mut Cursive, usize, usize) + Send + Sync + 'static,
    {
        self.with(|t| t.set_on_select(cb))
    }

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

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

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

    /// Returns the index of the currently selected table row.
    pub fn row(&self) -> Option<usize> {
        if self.items.is_empty() {
            None
        } else {
            Some(self.focus)
        }
    }

    /// Selects the row at the specified index.
    pub fn set_selected_row(&mut self, row_index: usize) {
        self.focus = row_index;
        self.scroll_core.scroll_to_y(row_index);
    }

    /// Selects the row at the specified index.
    ///
    /// Chainable variant.
    pub fn selected_row(self, row_index: usize) -> Self {
        self.with(|t| t.set_selected_row(row_index))
    }

    /// Sets the contained items of the table.
    ///
    /// The currently active sort order is preserved and will be applied to all
    /// items.
    pub fn set_items(&mut self, items: Vec<T>) {
        self.set_items_and_focus(items, 0);
    }

    fn set_items_and_focus(&mut self, items: Vec<T>, new_location: usize) {
        self.items = items;
        self.rows_to_items = Vec::with_capacity(self.items.len());

        for i in 0..self.items.len() {
            self.rows_to_items.push(i);
        }

        if let Some((column, order)) = self.order() {
            // Preserve the selected column if possible.
            let selected_column = self.columns.iter().find(|c| c.selected).map(|c| c.column);
            self.sort_by(column, order);
            if let Some(column) = selected_column {
                for c in &mut self.columns {
                    c.selected = c.column == column;
                }
            }
        }

        self.set_selected_item(new_location);
        self.needs_relayout = true;
    }

    /// Sets the contained items of the table.
    ///
    /// The order of the items will be preserved even when the table is sorted.
    ///
    /// Chainable variant.
    pub fn items(self, items: Vec<T>) -> Self {
        self.with(|t| t.set_items(items))
    }

    /// Returns an immutable reference to the item at the specified index
    /// within the underlying storage vector.
    pub fn borrow_item(&self, index: usize) -> Option<&T> {
        self.items.get(index)
    }

    /// Returns a mutable reference to the item at the specified index within
    /// the underlying storage vector.
    pub fn borrow_item_mut(&mut self, index: usize) -> Option<&mut T> {
        self.items.get_mut(index)
    }

    /// Returns an immutable reference to the items contained within the table.
    pub fn borrow_items(&self) -> &[T] {
        &self.items
    }

    /// Returns a mutable reference to the items contained within the table.
    ///
    /// Can be used to modify the items in place.
    pub fn borrow_items_mut(&mut self) -> &mut [T] {
        self.needs_relayout = true;
        &mut self.items
    }

    /// Returns the index of the currently selected item within the underlying
    /// storage vector.
    pub fn item(&self) -> Option<usize> {
        self.rows_to_items.get(self.focus).copied()
    }

    /// Selects the item at the specified index within the underlying storage
    /// vector.
    pub fn set_selected_item(&mut self, item_index: usize) {
        if item_index >= self.items.len() {
            return;
        }

        if let Some(row) = self
            .rows_to_items
            .iter()
            .position(|&item| item == item_index)
        {
            self.focus = row;
            self.scroll_core.scroll_to_y(row);
        }
    }

    /// Selects the item at the specified index within the underlying storage
    /// vector.
    ///
    /// Chainable variant.
    pub fn selected_item(self, item_index: usize) -> Self {
        self.with(|t| t.set_selected_item(item_index))
    }

    /// Inserts a new item into the table.
    ///
    /// The currently active sort order is preserved and will be applied to the
    /// newly inserted item.
    ///
    /// If no sort option is set, the item will be added to the end of the table.
    pub fn insert_item(&mut self, item: T) {
        self.insert_item_at(self.items.len(), item);
    }

    /// Inserts a new item into the table.
    ///
    /// The currently active sort order is preserved and will be applied to the
    /// newly inserted item.
    ///
    /// If no sort option is set, the item will be inserted at the given index.
    ///
    /// # Panics
    ///
    /// If `index > self.len()`.
    pub fn insert_item_at(&mut self, index: usize, item: T) {
        self.items.push(item);

        // Here we know self.items.len() > 0
        self.rows_to_items.insert(index, self.items.len() - 1);

        if let Some((column, order)) = self.order() {
            self.sort_by(column, order);
        }
        self.needs_relayout = true;
    }

    /// Removes the item at the specified index within the underlying storage
    /// vector and returns it.
    pub fn remove_item(&mut self, item_index: usize) -> Option<T> {
        if item_index < self.items.len() {
            // Move the selection if the currently selected item gets removed
            if let Some(selected_index) = self.item() {
                if selected_index == item_index {
                    self.focus_up(1);
                }
            }

            // Remove the sorted reference to the item
            self.rows_to_items.retain(|i| *i != item_index);

            // Adjust remaining references
            for ref_index in &mut self.rows_to_items {
                if *ref_index > item_index {
                    *ref_index -= 1;
                }
            }
            self.needs_relayout = true;

            // Remove actual item from the underlying storage
            Some(self.items.remove(item_index))
        } else {
            None
        }
    }

    /// Removes all items from the underlying storage and returns them.
    pub fn take_items(&mut self) -> Vec<T> {
        self.set_selected_row(0);
        self.rows_to_items.clear();
        self.needs_relayout = true;
        self.items.drain(0..).collect()
    }
}

impl<T, H> TableView<T, H>
where
    T: TableViewItem<H>,
    H: Eq + Hash + Copy + Clone + Send + Sync + 'static,
{
    fn draw_columns<C: Fn(&Printer, &TableColumn<H>)>(
        &self,
        printer: &Printer,
        sep: &str,
        callback: C,
    ) {
        let mut column_offset = 0;
        let column_count = self.columns.len();
        for (index, column) in self.columns.iter().enumerate() {
            let printer = &printer.offset((column_offset, 0)).focused(true);

            callback(printer, column);

            if 1 + index < column_count {
                printer.print((column.width + 1, 0), sep);
            }

            column_offset += column.width + 3;
        }
    }

    fn sort_items(&mut self, column: H, order: Ordering) {
        if !self.is_empty() {
            let old_item = self.item();

            let items = &self.items;
            let rows_to_items = &mut self.rows_to_items;
            let ascending = order == Ordering::Less;
            rows_to_items.sort_by(|a, b| {
                if ascending {
                    items[*a].cmp(&items[*b], column)
                } else {
                    items[*b].cmp(&items[*a], column)
                }
            });

            if let Some(old_item) = old_item {
                self.set_selected_item(old_item);
            }
        }
    }

    fn draw_item(&self, printer: &Printer, i: usize) {
        let focused_row = i == self.focus && self.enabled;
        let focused_col = self.focus_col;
        self.draw_columns(printer, "┆ ", |printer, column| {
            let index = self.column_indices[&column.column];
            let color = if self.selection_mode == SelectMode::Cell
                && focused_row
                && index == focused_col
            {
                if printer.focused {
                    theme::ColorStyle::highlight()
                } else {
                    theme::ColorStyle::highlight_inactive()
                }
            } else if self.selection_mode == SelectMode::Row && focused_row {
                if printer.focused {
                    theme::ColorStyle::highlight()
                } else {
                    theme::ColorStyle::highlight_inactive()
                }
            } else {
                theme::ColorStyle::primary()
            };

            let value = self.items[self.rows_to_items[i]].to_column(column.column);
            printer.with_color(color, |printer| {
                column.draw_row(printer, value.as_str());
            });
        });
    }

    fn on_focus_change(&self) -> EventResult {
        let row = self.row().unwrap();
        let index = self.item().unwrap();
        EventResult::Consumed(
            self.on_select
                .clone()
                .map(|cb| Callback::from_fn(move |s| cb(s, row, index))),
        )
    }

    fn focus_up(&mut self, n: usize) {
        self.focus -= cmp::min(self.focus, n);
    }

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

    fn active_column(&self) -> usize {
        self.columns.iter().position(|c| c.selected).unwrap_or(0)
    }

    fn column_cancel(&mut self) {
        self.column_select = false;
        for column in &mut self.columns {
            column.selected = column.order != Ordering::Equal;
        }
    }

    fn column_next(&mut self) -> bool {
        let column = self.active_column();
        if 1 + column < self.columns.len() {
            self.columns[column].selected = false;
            self.columns[column + 1].selected = true;
            self.focus_col = column + 1;
            true
        } else {
            false
        }
    }

    fn column_prev(&mut self) -> bool {
        let column = self.active_column();
        if column > 0 {
            self.columns[column].selected = false;
            self.columns[column - 1].selected = true;
            self.focus_col = column - 1;
            true
        } else {
            false
        }
    }

    fn column_select(&mut self) -> EventResult {
        if !self.sortable {
            self.column_cancel();
            return EventResult::Ignored;
        }

        let next = self.active_column();
        let column = self.columns[next].column;
        let current = self
            .columns
            .iter()
            .position(|c| c.order != Ordering::Equal)
            .unwrap_or(0);

        let order = if current != next {
            self.columns[next].default_order
        } else if self.columns[current].order == Ordering::Less {
            Ordering::Greater
        } else {
            Ordering::Less
        };

        self.sort_by(column, order);

        if self.on_sort.is_some() {
            let c = &self.columns[self.active_column()];
            let column = c.column;
            let order = c.order;

            let cb = self.on_sort.clone().unwrap();
            EventResult::with_cb(move |s| cb(s, column, order))
        } else {
            EventResult::Consumed(None)
        }
    }

    fn column_for_x(&self, mut x: usize) -> Option<usize> {
        for (i, col) in self.columns.iter().enumerate() {
            x = match x.checked_sub(col.width) {
                None => return Some(i),
                Some(x) => x.checked_sub(3)?,
            };
        }

        None
    }

    fn draw_content(&self, printer: &Printer) {
        for i in 0..self.rows_to_items.len() {
            let printer = printer.offset((0, i));
            let color = if i == self.focus && self.enabled {
                if !self.column_select && self.enabled && printer.focused {
                    theme::ColorStyle::highlight()
                } else {
                    theme::ColorStyle::highlight_inactive()
                }
            } else {
                theme::ColorStyle::primary()
            };

            if i < self.items.len() {
                printer.with_color(color, |printer| {
                    self.draw_item(printer, i);
                });
            }
        }
    }

    fn layout_content(&mut self, size: Vec2) {
        let column_count = self.columns.len();

        // Split up all columns into sized / unsized groups
        let (mut sized, mut flexible): (Vec<&mut TableColumn<H>>, Vec<&mut TableColumn<H>>) = self
            .columns
            .iter_mut()
            .partition(|c| c.requested_width.is_some());

        // Subtract one for the separators between our columns (that's column_count - 1)
        let available_width = size.x.saturating_sub(column_count.saturating_sub(1) * 3);

        // Calculate widths for all requested columns
        let mut remaining_width = available_width;
        for column in &mut sized {
            column.width = match *column.requested_width.as_ref().unwrap() {
                TableColumnWidth::Percent(width) => cmp::min(
                    (size.x as f32 / 100.0 * width as f32).ceil() as usize,
                    remaining_width,
                ),
                TableColumnWidth::Absolute(width) => width,
            };
            remaining_width = remaining_width.saturating_sub(column.width);
        }

        // Spread the remaining width across the unsized columns.
        let remaining_columns = flexible.len();
        let base_width = if remaining_columns > 0 {
            remaining_width / remaining_columns
        } else {
            0
        };
        for column in &mut flexible {
            column.width = base_width;
        }

        self.needs_relayout = false;
    }

    fn content_required_size(&mut self, req: Vec2) -> Vec2 {
        let rows = self.rows_to_items.len();
        let separators = self.columns.len().saturating_sub(1).saturating_mul(3);

        let resolve_width = |requested: &TableColumnWidth| match *requested {
            TableColumnWidth::Percent(width) => {
                (req.x as f32 / 100.0 * width as f32).ceil() as usize
            }
            TableColumnWidth::Absolute(width) => width,
        };

        let mut width: usize = 0;
        for column in &self.columns {
            let col_width = column
                .requested_width
                .as_ref()
                .map(resolve_width)
                .unwrap_or(column.width);
            width = width.saturating_add(col_width);
        }

        let width = if width == 0 {
            req.x
        } else {
            width.saturating_add(separators)
        };

        Vec2::new(width, rows)
    }

    fn on_inner_event(&mut self, event: Event) -> EventResult {
        let last_focus = self.focus;
        match event {
            Event::Key(Key::Right) => {
                if self.selection_mode == SelectMode::Cell && !self.sortable {
                    if self.focus_col + 1 < self.columns.len() {
                        self.focus_col += 1;
                    } else {
                        return EventResult::Ignored;
                    }
                } else if self.sortable {
                    if self.column_select {
                        if !self.column_next() {
                            return EventResult::Ignored;
                        }
                    } else {
                        self.column_select = true;
                    }
                } else {
                    return EventResult::Ignored;
                }
            }
            Event::Key(Key::Left) => {
                if self.selection_mode == SelectMode::Cell && !self.sortable {
                    if self.focus_col > 0 {
                        self.focus_col -= 1;
                    } else {
                        return EventResult::Ignored;
                    }
                } else if self.sortable {
                    if self.column_select {
                        if !self.column_prev() {
                            return EventResult::Ignored;
                        }
                    } else {
                        self.column_select = true;
                    }
                } else {
                    return EventResult::Ignored;
                }
            }
            Event::Key(Key::Up) if self.focus > 0 || self.column_select => {
                if self.column_select {
                    self.column_cancel();
                } else {
                    self.focus_up(1);
                }
            }
            Event::Key(Key::Down) if self.focus + 1 < self.items.len() || self.column_select => {
                if self.column_select {
                    self.column_cancel();
                } else {
                    self.focus_down(1);
                }
            }
            Event::Key(Key::PageUp) => {
                self.column_cancel();
                self.focus_up(10);
            }
            Event::Key(Key::PageDown) => {
                self.column_cancel();
                self.focus_down(10);
            }
            Event::Key(Key::Home) => {
                self.column_cancel();
                self.focus = 0;
            }
            Event::Key(Key::End) => {
                self.column_cancel();
                self.focus = self.items.len().saturating_sub(1);
            }
            Event::Key(Key::Enter) => {
                if self.column_select && self.sortable {
                    return self.column_select();
                } else if !self.is_empty()
                    && self.selection_mode == SelectMode::Cell
                    && self.on_submit_cell.is_some()
                {
                    return self.on_submit_cell_event();
                } else if !self.is_empty() && self.on_submit.is_some() {
                    return self.on_submit_event();
                }
            }
            Event::Mouse {
                position,
                offset,
                event: MouseEvent::Press(MouseButton::Left),
            } if !self.is_empty()
                && position
                    .checked_sub(offset)
                    .map_or(false, |p| p.y == self.focus) =>
            {
                if let Some(p) = position.checked_sub(offset) {
                    if let Some(col) = self.column_for_x(p.x) {
                        self.focus_col = col;
                    }
                }
                self.column_cancel();
                if self.selection_mode == SelectMode::Cell && self.on_submit_cell.is_some() {
                    return self.on_submit_cell_event();
                }
                return self.on_submit_event();
            }
            Event::Mouse {
                position,
                offset,
                event: MouseEvent::Press(_),
            } if !self.is_empty() => match position.checked_sub(offset) {
                Some(position) if position.y < self.rows_to_items.len() => {
                    self.column_cancel();
                    if let Some(col) = self.column_for_x(position.x) {
                        self.focus_col = col;
                    }
                    self.focus = position.y;
                }
                _ => return EventResult::Ignored,
            },
            _ => return EventResult::Ignored,
        }

        let focus = self.focus;

        if self.column_select {
            EventResult::Consumed(None)
        } else if !self.is_empty() && last_focus != focus {
            self.on_focus_change()
        } else {
            EventResult::Ignored
        }
    }

    fn inner_important_area(&self, size: Vec2) -> Rect {
        Rect::from_size((0, self.focus), (size.x, 1))
    }

    fn on_submit_event(&mut self) -> EventResult {
        if let Some(cb) = &self.on_submit {
            let cb = Arc::clone(cb);
            let row = self.row().unwrap();
            let index = self.item().unwrap();
            return EventResult::Consumed(Some(Callback::from_fn(move |s| cb(s, row, index))));
        }
        EventResult::Ignored
    }

    fn on_submit_cell_event(&mut self) -> EventResult {
        if let Some(cb) = &self.on_submit_cell {
            let cb = Arc::clone(cb);
            let row = self.row().unwrap();
            let col_index = cmp::min(self.focus_col, self.columns.len().saturating_sub(1));
            if let Some(column) = self.columns.get(col_index).map(|c| c.column) {
                return EventResult::Consumed(Some(Callback::from_fn(move |s| cb(s, row, column))));
            }
        }
        EventResult::Ignored
    }
}

impl<T, H> View for TableView<T, H>
where
    T: TableViewItem<H> + Send + Sync + 'static,
    H: Eq + Hash + Copy + Clone + Send + Sync + 'static,
{
    fn required_size(&mut self, req: Vec2) -> Vec2 {
        let content = self.content_required_size(req);
        Vec2::new(content.x, content.y.saturating_add(2))
    }

    fn draw(&self, printer: &Printer) {
        self.draw_columns(printer, "╷ ", |printer, column| {
            let color = if self.enabled
                && self.sortable
                && (column.order != Ordering::Equal || column.selected)
            {
                if self.column_select && column.selected && printer.focused {
                    theme::ColorStyle::highlight()
                } else {
                    theme::ColorStyle::highlight_inactive()
                }
            } else {
                theme::ColorStyle::primary()
            };

            printer.with_color(color, |printer| {
                column.draw_header(printer, self.sortable);
            });
        });

        self.draw_columns(
            &printer.offset((0, 1)).focused(true),
            "┴─",
            |printer, column| {
                printer.print_hline((0, 0), column.width + 1, "─");
            },
        );

        // Extend the vertical bars to the end of the view.
        let available_height = printer.size.y.saturating_sub(2);
        let filled_rows = self.rows_to_items.len().min(available_height);
        for y in 2 + filled_rows..printer.size.y {
            self.draw_columns(&printer.offset((0, y)), "┆ ", |_, _| ());
        }

        let printer = &printer.offset((0, 2)).focused(true);
        scroll::draw(self, printer, Self::draw_content);
    }

    fn layout(&mut self, size: Vec2) {
        scroll::layout(
            self,
            size.saturating_sub((0, 2)),
            self.needs_relayout,
            Self::layout_content,
            Self::content_required_size,
        );
    }

    fn take_focus(&mut self, _: Direction) -> Result<EventResult, CannotFocus> {
        self.enabled.then(EventResult::consumed).ok_or(CannotFocus)
    }

    fn on_event(&mut self, event: Event) -> EventResult {
        if !self.enabled {
            return EventResult::Ignored;
        }

        match event {
            Event::Mouse {
                position,
                offset,
                event: MouseEvent::Press(MouseButton::Left),
            } if position.checked_sub(offset).map_or(false, |p| p.y == 0) => {
                if !self.sortable {
                    return EventResult::Ignored;
                }

                if let Some(position) = position.checked_sub(offset) {
                    if let Some(col) = self.column_for_x(position.x) {
                        if self.column_select && self.columns[col].selected {
                            return self.column_select();
                        } else {
                            let active = self.active_column();
                            self.columns[active].selected = false;
                            self.columns[col].selected = true;
                            self.column_select = true;
                        }
                    }
                }
                EventResult::Ignored
            }
            event => scroll::on_event(
                self,
                event.relativized((0, 2)),
                Self::on_inner_event,
                Self::inner_important_area,
            ),
        }
    }

    fn important_area(&self, size: Vec2) -> Rect {
        self.inner_important_area(size.saturating_sub((0, 2))) + (0, 2)
    }
}

/// View to display a 2D array with row and column headers.
pub struct ArrayView<T, H> {
    enabled: bool,
    scroll_core: scroll::Core,
    needs_relayout: bool,

    columns: Vec<TableColumn<H>>,
    row_header: ArrayRowHeader,
    array_name: String,

    focus: usize,
    focus_col: usize,
    items: Vec<T>,

    on_submit: Option<CellCallback<H>>,
    on_select: Option<CellCallback<H>>,
}

cursive::impl_scroller!(ArrayView < T, H > ::scroll_core);

impl<T, H> Default for ArrayView<T, H>
where
    T: ArrayViewItem<H>,
    H: Eq + Hash + Copy + Clone + Send + Sync + 'static,
{
    /// Creates a new empty `ArrayView` without any columns.
    ///
    /// See [`ArrayView::new()`].
    fn default() -> Self {
        Self::new()
    }
}

impl<T, H> ArrayView<T, H>
where
    T: ArrayViewItem<H> + PartialEq,
    H: Eq + Hash + Copy + Clone + Send + Sync + 'static,
{
    /// Sets the contained items of the array.
    ///
    /// The current selection will be preserved when possible.
    /// (But this is only available for `T: PartialEq`.)
    pub fn set_items_stable(&mut self, items: Vec<T>) {
        // Preserve selection
        let new_location = self
            .item()
            .and_then(|old_item| {
                let old_item = &self.items[old_item];
                items.iter().position(|new| new == old_item)
            })
            .unwrap_or(0);

        self.set_items_and_focus(items, new_location);
    }
}

impl<T, H> ArrayView<T, H>
where
    T: ArrayViewItem<H>,
    H: Eq + Hash + Copy + Clone + Send + Sync + 'static,
{
    /// Creates a new empty `ArrayView` without any columns.
    ///
    /// An ArrayView should be accompanied by an enum of type `H` representing
    /// the array columns.
    pub fn new() -> Self {
        Self {
            enabled: true,
            scroll_core: scroll::Core::new(),
            needs_relayout: true,

            columns: Vec::new(),
            row_header: ArrayRowHeader::new(),
            array_name: String::new(),

            focus: 0,
            focus_col: 0,
            items: Vec::new(),

            on_submit: None,
            on_select: None,
        }
    }

    /// Configures the row header column.
    ///
    /// Row header values are read from [`ArrayViewItem::to_row`].
    /// The top-left corner text is set via [`ArrayView::array_name`].
    ///
    /// Chainable variant.
    pub fn row_header<C: FnOnce(ArrayRowHeader) -> ArrayRowHeader>(mut self, callback: C) -> Self {
        self.set_row_header(callback);
        self
    }

    /// Sets the text shown in the top-left corner.
    ///
    /// Chainable variant.
    pub fn array_name<S: Into<String>>(mut self, name: S) -> Self {
        self.set_array_name(name);
        self
    }

    /// Sets the text shown in the top-left corner.
    pub fn set_array_name<S: Into<String>>(&mut self, name: S) {
        self.array_name = name.into();
    }

    /// Configures the row header column.
    ///
    /// Row header values are read from [`ArrayViewItem::to_row`].
    /// The top-left corner text is set via [`ArrayView::array_name`].
    pub fn set_row_header<C: FnOnce(ArrayRowHeader) -> ArrayRowHeader>(
        &mut self,
        callback: C,
    ) {
        self.row_header = callback(ArrayRowHeader::new());
        self.needs_relayout = true;
    }

    /// Adds a column for the specified array column from type `H` along with
    /// a title for its visual display.
    ///
    /// The provided callback can be used to further configure the
    /// created [`TableColumn`](struct.TableColumn.html).
    pub fn column<S: Into<String>, C: FnOnce(TableColumn<H>) -> TableColumn<H>>(
        mut self,
        column: H,
        title: S,
        callback: C,
    ) -> Self {
        self.add_column(column, title, callback);
        self
    }

    /// Adds a column for the specified array column from type `H` along with
    /// a title for its visual display.
    ///
    /// The provided callback can be used to further configure the
    /// created [`TableColumn`](struct.TableColumn.html).
    pub fn add_column<S: Into<String>, C: FnOnce(TableColumn<H>) -> TableColumn<H>>(
        &mut self,
        column: H,
        title: S,
        callback: C,
    ) {
        self.insert_column(self.columns.len(), column, title, callback);
    }

    /// Remove a column.
    pub fn remove_column(&mut self, i: usize) {
        self.columns.remove(i);
        if self.focus_col >= self.columns.len() {
            self.focus_col = self.columns.len().saturating_sub(1);
        }
        self.needs_relayout = true;
    }

    /// Adds a column for the specified array column from type `H` along with
    /// a title for its visual display.
    ///
    /// The provided callback can be used to further configure the
    /// created [`TableColumn`](struct.TableColumn.html).
    pub fn insert_column<S: Into<String>, C: FnOnce(TableColumn<H>) -> TableColumn<H>>(
        &mut self,
        i: usize,
        column: H,
        title: S,
        callback: C,
    ) {
        self.columns
            .insert(i, callback(TableColumn::new(column, title.into())));
        if self.focus_col >= self.columns.len() {
            self.focus_col = self.columns.len().saturating_sub(1);
        }
        self.needs_relayout = true;
    }

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

    /// 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 `<Enter>` is pressed while a cell
    /// is selected.
    ///
    /// Both the currently selected row and column will be given to the callback.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use cursive_core::Cursive;
    /// # use better_cursive_table::{ArrayView, ArrayViewItem};
    /// # #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    /// # enum ArrayColumn { X }
    /// # #[derive(Clone)]
    /// # struct Item { label: String, value: String }
    /// # impl ArrayViewItem<ArrayColumn> for Item {
    /// #     fn to_column(&self, column: ArrayColumn) -> String {
    /// #         match column { ArrayColumn::X => self.value.clone() }
    /// #     }
    /// #     fn to_row(&self) -> String {
    /// #         self.label.clone()
    /// #     }
    /// # }
    /// # let mut array = ArrayView::<Item, ArrayColumn>::new()
    /// #     .row_header(|h| h.width(6))
    /// #     .column(ArrayColumn::X, "X", |c| c);
    /// array.set_on_submit(|_siv: &mut Cursive, _row: usize, _column: ArrayColumn| {
    /// });
    /// ```
    pub fn set_on_submit<F>(&mut self, cb: F)
    where
        F: Fn(&mut Cursive, usize, H) + Send + Sync + 'static,
    {
        self.on_submit = Some(Arc::new(move |s, row, column| cb(s, row, column)));
    }

    /// Sets a callback to be used when `<Enter>` is pressed while a cell
    /// is selected.
    ///
    /// Chainable variant.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use cursive_core::Cursive;
    /// # use better_cursive_table::{ArrayView, ArrayViewItem};
    /// # #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    /// # enum ArrayColumn { X }
    /// # #[derive(Clone)]
    /// # struct Item { label: String, value: String }
    /// # impl ArrayViewItem<ArrayColumn> for Item {
    /// #     fn to_column(&self, column: ArrayColumn) -> String {
    /// #         match column { ArrayColumn::X => self.value.clone() }
    /// #     }
    /// #     fn to_row(&self) -> String {
    /// #         self.label.clone()
    /// #     }
    /// # }
    /// # let array = ArrayView::<Item, ArrayColumn>::new()
    /// #     .row_header(|h| h.width(6))
    /// #     .column(ArrayColumn::X, "X", |c| c);
    /// let _array = array.on_submit(|_siv: &mut Cursive, _row: usize, _column: ArrayColumn| {});
    /// ```
    pub fn on_submit<F>(self, cb: F) -> Self
    where
        F: Fn(&mut Cursive, usize, H) + Send + Sync + 'static,
    {
        self.with(|t| t.set_on_submit(cb))
    }

    /// Sets a callback to be used when a cell is selected.
    ///
    /// Both the currently selected row and column will be given to the callback.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use cursive_core::Cursive;
    /// # use better_cursive_table::{ArrayView, ArrayViewItem};
    /// # #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    /// # enum ArrayColumn { X }
    /// # #[derive(Clone)]
    /// # struct Item { label: String, value: String }
    /// # impl ArrayViewItem<ArrayColumn> for Item {
    /// #     fn to_column(&self, column: ArrayColumn) -> String {
    /// #         match column { ArrayColumn::X => self.value.clone() }
    /// #     }
    /// #     fn to_row(&self) -> String {
    /// #         self.label.clone()
    /// #     }
    /// # }
    /// # let mut array = ArrayView::<Item, ArrayColumn>::new()
    /// #     .row_header(|h| h.width(6))
    /// #     .column(ArrayColumn::X, "X", |c| c);
    /// array.set_on_select(|_siv: &mut Cursive, _row: usize, _column: ArrayColumn| {
    /// });
    /// ```
    pub fn set_on_select<F>(&mut self, cb: F)
    where
        F: Fn(&mut Cursive, usize, H) + Send + Sync + 'static,
    {
        self.on_select = Some(Arc::new(move |s, row, column| cb(s, row, column)));
    }

    /// Sets a callback to be used when a cell is selected.
    ///
    /// Chainable variant.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use cursive_core::Cursive;
    /// # use better_cursive_table::{ArrayView, ArrayViewItem};
    /// # #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    /// # enum ArrayColumn { X }
    /// # #[derive(Clone)]
    /// # struct Item { label: String, value: String }
    /// # impl ArrayViewItem<ArrayColumn> for Item {
    /// #     fn to_column(&self, column: ArrayColumn) -> String {
    /// #         match column { ArrayColumn::X => self.value.clone() }
    /// #     }
    /// #     fn to_row(&self) -> String {
    /// #         self.label.clone()
    /// #     }
    /// # }
    /// # let array = ArrayView::<Item, ArrayColumn>::new()
    /// #     .row_header(|h| h.width(6))
    /// #     .column(ArrayColumn::X, "X", |c| c);
    /// let _array = array.on_select(|_siv: &mut Cursive, _row: usize, _column: ArrayColumn| {});
    /// ```
    pub fn on_select<F>(self, cb: F) -> Self
    where
        F: Fn(&mut Cursive, usize, H) + Send + Sync + 'static,
    {
        self.with(|t| t.set_on_select(cb))
    }

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

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

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

    /// Returns the index of the currently selected array row.
    pub fn row(&self) -> Option<usize> {
        if self.items.is_empty() {
            None
        } else {
            Some(self.focus)
        }
    }

    /// Selects the row at the specified index.
    pub fn set_selected_row(&mut self, row_index: usize) {
        self.focus = row_index;
        self.scroll_core.scroll_to_y(self.row_y(row_index));
    }

    /// Selects the row at the specified index.
    ///
    /// Chainable variant.
    pub fn selected_row(self, row_index: usize) -> Self {
        self.with(|t| t.set_selected_row(row_index))
    }

    /// Sets the contained items of the array.
    pub fn set_items(&mut self, items: Vec<T>) {
        self.set_items_and_focus(items, 0);
    }

    fn set_items_and_focus(&mut self, items: Vec<T>, new_location: usize) {
        self.items = items;
        self.set_selected_item(new_location);
        self.needs_relayout = true;
    }

    /// Sets the contained items of the array.
    ///
    /// Chainable variant.
    pub fn items(self, items: Vec<T>) -> Self {
        self.with(|t| t.set_items(items))
    }

    /// Returns an immutable reference to the item at the specified index
    /// within the underlying storage vector.
    pub fn borrow_item(&self, index: usize) -> Option<&T> {
        self.items.get(index)
    }

    /// Returns a mutable reference to the item at the specified index within
    /// the underlying storage vector.
    pub fn borrow_item_mut(&mut self, index: usize) -> Option<&mut T> {
        self.items.get_mut(index)
    }

    /// Returns an immutable reference to the items contained within the array.
    pub fn borrow_items(&self) -> &[T] {
        &self.items
    }

    /// Returns a mutable reference to the items contained within the array.
    ///
    /// Can be used to modify the items in place.
    pub fn borrow_items_mut(&mut self) -> &mut [T] {
        self.needs_relayout = true;
        &mut self.items
    }

    /// Returns the index of the currently selected item within the underlying
    /// storage vector.
    pub fn item(&self) -> Option<usize> {
        if self.items.is_empty() {
            None
        } else {
            Some(self.focus)
        }
    }

    /// Selects the item at the specified index within the underlying storage
    /// vector.
    pub fn set_selected_item(&mut self, item_index: usize) {
        if item_index < self.items.len() {
            self.focus = item_index;
            self.scroll_core.scroll_to_y(self.row_y(item_index));
        }
    }

    /// Selects the item at the specified index within the underlying storage
    /// vector.
    ///
    /// Chainable variant.
    pub fn selected_item(self, item_index: usize) -> Self {
        self.with(|t| t.set_selected_item(item_index))
    }

    /// Inserts a new item into the array.
    ///
    /// The item will be added to the end of the array.
    pub fn insert_item(&mut self, item: T) {
        self.insert_item_at(self.items.len(), item);
    }

    /// Inserts a new item into the array.
    ///
    /// The item will be inserted at the given index.
    ///
    /// # Panics
    ///
    /// If `index > self.len()`.
    pub fn insert_item_at(&mut self, index: usize, item: T) {
        self.items.insert(index, item);
        self.needs_relayout = true;
    }

    /// Removes the item at the specified index within the underlying storage
    /// vector and returns it.
    pub fn remove_item(&mut self, item_index: usize) -> Option<T> {
        if item_index < self.items.len() {
            if let Some(selected_index) = self.item() {
                if selected_index == item_index {
                    self.focus_up(1);
                }
            }

            self.needs_relayout = true;
            Some(self.items.remove(item_index))
        } else {
            None
        }
    }

    /// Removes all items from the underlying storage and returns them.
    pub fn take_items(&mut self) -> Vec<T> {
        self.set_selected_row(0);
        self.needs_relayout = true;
        self.items.drain(0..).collect()
    }
}

impl<T, H> ArrayView<T, H>
where
    T: ArrayViewItem<H>,
    H: Eq + Hash + Copy + Clone + Send + Sync + 'static,
{
    fn row_y(&self, row_index: usize) -> usize {
        row_index.saturating_mul(2)
    }

    fn row_for_y(&self, y: usize) -> Option<usize> {
        if y % 2 == 0 {
            Some(y / 2)
        } else {
            None
        }
    }

    fn column_for_x(&self, mut x: usize) -> Option<usize> {
        x = match x.checked_sub(self.row_header.width) {
            None => return None,
            Some(x) => x,
        };
        x = x.checked_sub(3)?;

        for (i, col) in self.columns.iter().enumerate() {
            x = match x.checked_sub(col.width) {
                None => return Some(i),
                Some(x) => x.checked_sub(3)?,
            };
        }

        None
    }

    fn draw_columns<C, R>(&self, printer: &Printer, sep: &str, row_cb: R, mut col_cb: C)
    where
        C: FnMut(&Printer, &TableColumn<H>, usize),
        R: Fn(&Printer, &ArrayRowHeader),
    {
        let row_header = &self.row_header;
        let printer = &printer.offset((0, 0)).focused(true);
        row_cb(printer, row_header);

        if !self.columns.is_empty() {
            printer.print((row_header.width + 1, 0), sep);
        }

        let mut column_offset = row_header.width + 3;

        let column_count = self.columns.len();
        for (index, column) in self.columns.iter().enumerate() {
            let printer = &printer.offset((column_offset, 0)).focused(true);

            col_cb(printer, column, index);

            if 1 + index < column_count {
                printer.print((column.width + 1, 0), sep);
            }

            column_offset += column.width + 3;
        }
    }

    fn draw_item(&self, printer: &Printer, i: usize) {
        let item = &self.items[i];
        let focused_row = i == self.focus && self.enabled;
        let focused_col = self.focus_col;
        self.draw_columns(
            printer,
            "┆ ",
            |printer, row_header| {
                let value = item.to_row();
                row_header.draw_row(printer, value.as_str());
            },
            |printer, column, index| {
                let color = if focused_row && index == focused_col {
                    if printer.focused {
                        theme::ColorStyle::highlight()
                    } else {
                        theme::ColorStyle::highlight_inactive()
                    }
                } else {
                    theme::ColorStyle::primary()
                };
                let value = item.to_column(column.column);
                printer.with_color(color, |printer| {
                    column.draw_row(printer, value.as_str());
                });
            },
        );
    }

    fn on_focus_change(&self) -> EventResult {
        let row = self.row().unwrap();
        let column = match self.columns.get(self.focus_col) {
            Some(column) => column.column,
            None => return EventResult::Ignored,
        };
        EventResult::Consumed(
            self.on_select
                .clone()
                .map(|cb| Callback::from_fn(move |s| cb(s, row, column))),
        )
    }

    fn focus_up(&mut self, n: usize) {
        self.focus -= cmp::min(self.focus, n);
    }

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

    fn draw_content(&self, printer: &Printer) {
        let row_count = self.items.len();
        for i in 0..row_count {
            let row_y = self.row_y(i);
            let printer = printer.offset((0, row_y));
            self.draw_item(&printer, i);

            self.draw_columns(
                &printer.offset((0, 1)).focused(true),
                "┼─",
                |printer, row_header| {
                    printer.print_hline((0, 0), row_header.width + 1, "─");
                },
                |printer, column, _| {
                    printer.print_hline((0, 0), column.width + 1, "─");
                },
            );
        }
    }

    fn layout_content(&mut self, size: Vec2) {
        let column_count = self.columns.len() + 1;

        // Split up all columns into sized / unsized groups
        let (mut sized, mut flexible): (Vec<&mut TableColumn<H>>, Vec<&mut TableColumn<H>>) = self
            .columns
            .iter_mut()
            .partition(|c| c.requested_width.is_some());

        // Subtract one for the separators between our columns (that's column_count - 1)
        let available_width = size.x.saturating_sub(column_count.saturating_sub(1) * 3);

        // Calculate widths for all requested columns
        let mut remaining_width = available_width;
        if let Some(requested_width) = self.row_header.requested_width.as_ref() {
            self.row_header.width = match *requested_width {
                TableColumnWidth::Percent(width) => cmp::min(
                    (size.x as f32 / 100.0 * width as f32).ceil() as usize,
                    remaining_width,
                ),
                TableColumnWidth::Absolute(width) => width,
            };
            remaining_width = remaining_width.saturating_sub(self.row_header.width);
        }

        for column in &mut sized {
            column.width = match *column.requested_width.as_ref().unwrap() {
                TableColumnWidth::Percent(width) => cmp::min(
                    (size.x as f32 / 100.0 * width as f32).ceil() as usize,
                    remaining_width,
                ),
                TableColumnWidth::Absolute(width) => width,
            };
            remaining_width = remaining_width.saturating_sub(column.width);
        }

        // Spread the remaining width across the unsized columns.
        let mut remaining_columns = flexible.len();
        if self.row_header.requested_width.is_none() {
            remaining_columns += 1;
        }

        let base_width = if remaining_columns > 0 {
            remaining_width / remaining_columns
        } else {
            0
        };

        if self.row_header.requested_width.is_none() {
            self.row_header.width = base_width;
        }

        for column in &mut flexible {
            column.width = base_width;
        }

        self.needs_relayout = false;
    }

    fn content_required_size(&mut self, req: Vec2) -> Vec2 {
        let rows = self.items.len();
        let height = rows.saturating_mul(2);
        let separators = self.columns.len().saturating_mul(3);

        let resolve_width = |requested: &TableColumnWidth| match *requested {
            TableColumnWidth::Percent(width) => {
                (req.x as f32 / 100.0 * width as f32).ceil() as usize
            }
            TableColumnWidth::Absolute(width) => width,
        };

        let mut width = self
            .row_header
            .requested_width
            .as_ref()
            .map(resolve_width)
            .unwrap_or(self.row_header.width);

        for column in &self.columns {
            let col_width = column
                .requested_width
                .as_ref()
                .map(resolve_width)
                .unwrap_or(column.width);
            width = width.saturating_add(col_width);
        }

        let width = if width == 0 {
            req.x
        } else {
            width.saturating_add(separators).saturating_add(1)
        };

        Vec2::new(width, height)
    }

    fn on_inner_event(&mut self, event: Event) -> EventResult {
        let last_focus = (self.focus, self.focus_col);
        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::Left) if self.focus_col > 0 => {
                self.focus_col -= 1;
            }
            Event::Key(Key::Right) if self.focus_col + 1 < self.columns.len() => {
                self.focus_col += 1;
            }
            Event::Key(Key::PageUp) => {
                self.focus_up(10);
            }
            Event::Key(Key::PageDown) => {
                self.focus_down(10);
            }
            Event::Key(Key::Home) => {
                self.focus = 0;
            }
            Event::Key(Key::End) => {
                self.focus = self.items.len().saturating_sub(1);
            }
            Event::Key(Key::Enter) => {
                if !self.is_empty() && self.on_submit.is_some() {
                    return self.on_submit_event();
                }
            }
            Event::Mouse {
                position,
                offset,
                event: MouseEvent::Press(MouseButton::Left),
            } if !self.is_empty() => {
                if let Some(position) = position.checked_sub(offset) {
                    let row = self.row_for_y(position.y);
                    let column = self.column_for_x(position.x);
                    if let (Some(row), Some(column)) = (row, column) {
                        if row == self.focus && column == self.focus_col {
                            return self.on_submit_event();
                        }
                        if row < self.items.len() {
                            self.focus = row;
                            self.focus_col = column;
                        }
                    } else {
                        return EventResult::Ignored;
                    }
                } else {
                    return EventResult::Ignored;
                }
            }
            Event::Mouse {
                position,
                offset,
                event: MouseEvent::Press(_),
            } if !self.is_empty() => {
                if let Some(position) = position.checked_sub(offset) {
                    let row = self.row_for_y(position.y);
                    let column = self.column_for_x(position.x);
                    if let (Some(row), Some(column)) = (row, column) {
                        if row < self.items.len() {
                            self.focus = row;
                            self.focus_col = column;
                        }
                    } else {
                        return EventResult::Ignored;
                    }
                } else {
                    return EventResult::Ignored;
                }
            }
            _ => return EventResult::Ignored,
        }

        let focus = (self.focus, self.focus_col);

        if !self.is_empty() && last_focus != focus {
            self.on_focus_change()
        } else {
            EventResult::Ignored
        }
    }

    fn inner_important_area(&self, size: Vec2) -> Rect {
        Rect::from_size((0, self.row_y(self.focus)), (size.x, 1))
    }

    fn on_submit_event(&mut self) -> EventResult {
        if let Some(cb) = &self.on_submit {
            let cb = Arc::clone(cb);
            let row = self.row().unwrap();
            let column = match self.columns.get(self.focus_col) {
                Some(column) => column.column,
                None => return EventResult::Ignored,
            };
            return EventResult::Consumed(Some(Callback::from_fn(move |s| cb(s, row, column))));
        }
        EventResult::Ignored
    }
}

impl<T, H> View for ArrayView<T, H>
where
    T: ArrayViewItem<H> + Send + Sync + 'static,
    H: Eq + Hash + Copy + Clone + Send + Sync + 'static,
{
    fn required_size(&mut self, req: Vec2) -> Vec2 {
        let content = self.content_required_size(req);
        Vec2::new(content.x, content.y.saturating_add(2))
    }

    fn draw(&self, printer: &Printer) {
        self.draw_columns(
            printer,
            "╷ ",
            |printer, row_header| {
                let title = self.array_name.as_str();
                printer.with_color(theme::ColorStyle::primary(), |printer| {
                    row_header.draw_header(printer, title);
                });
            },
            |printer, column, _| {
                printer.with_color(theme::ColorStyle::primary(), |printer| {
                    column.draw_header(printer, false);
                });
            },
        );

        self.draw_columns(
            &printer.offset((0, 1)).focused(true),
            "┴─",
            |printer, row_header| {
                printer.print_hline((0, 0), row_header.width + 1, "─");
            },
            |printer, column, _| {
                printer.print_hline((0, 0), column.width + 1, "─");
            },
        );

        // Extend the vertical bars to the end of the view.
        let available_height = printer.size.y.saturating_sub(2);
        let filled_rows = self.items.len().saturating_mul(2).min(available_height);
        for y in 2 + filled_rows..printer.size.y {
            self.draw_columns(
                &printer.offset((0, y)),
                "┆ ",
                |_, _| (),
                |_, _, _| (),
            );
        }

        let printer = &printer.offset((0, 2)).focused(true);
        scroll::draw(self, printer, Self::draw_content);
    }

    fn layout(&mut self, size: Vec2) {
        scroll::layout(
            self,
            size.saturating_sub((0, 2)),
            self.needs_relayout,
            Self::layout_content,
            Self::content_required_size,
        );
    }

    fn take_focus(&mut self, _: Direction) -> Result<EventResult, CannotFocus> {
        self.enabled.then(EventResult::consumed).ok_or(CannotFocus)
    }

    fn on_event(&mut self, event: Event) -> EventResult {
        if !self.enabled {
            return EventResult::Ignored;
        }

        match event {
            Event::Mouse {
                position,
                offset,
                event: MouseEvent::Press(_),
            } if position.checked_sub(offset).map_or(false, |p| p.y < 2) => EventResult::Ignored,
            event => scroll::on_event(
                self,
                event.relativized((0, 2)),
                Self::on_inner_event,
                Self::inner_important_area,
            ),
        }
    }

    fn important_area(&self, size: Vec2) -> Rect {
        self.inner_important_area(size.saturating_sub((0, 2))) + (0, 2)
    }
}

/// A type used for the construction of the row header in an
/// [`ArrayView`](struct.ArrayView.html).
pub struct ArrayRowHeader {
    alignment: HAlign,
    width: usize,
    requested_width: Option<TableColumnWidth>,
}

impl ArrayRowHeader {
    /// Sets the horizontal text alignment of the row header.
    pub fn align(mut self, alignment: HAlign) -> Self {
        self.alignment = alignment;
        self
    }

    /// Sets how many characters of width this row header will try to occupy.
    pub fn width(mut self, width: usize) -> Self {
        self.requested_width = Some(TableColumnWidth::Absolute(width));
        self
    }

    /// Sets what percentage of the width of the entire array this row header
    /// will try to occupy.
    pub fn width_percent(mut self, width: usize) -> Self {
        self.requested_width = Some(TableColumnWidth::Percent(width));
        self
    }

    fn new() -> Self {
        Self {
            alignment: HAlign::Left,
            width: 0,
            requested_width: None,
        }
    }

    fn draw_header(&self, printer: &Printer, title: &str) {
        let header = match self.alignment {
            HAlign::Left => format!("{:<width$}", title, width = self.width),
            HAlign::Right => format!("{:>width$}", title, width = self.width),
            HAlign::Center => format!("{:^width$}", title, width = self.width),
        };

        printer.print((0, 0), header.as_str());
    }

    fn draw_row(&self, printer: &Printer, value: &str) {
        let value = match self.alignment {
            HAlign::Left => format!("{:<width$} ", value, width = self.width),
            HAlign::Right => format!("{:>width$} ", value, width = self.width),
            HAlign::Center => format!("{:^width$} ", value, width = self.width),
        };

        printer.print((0, 0), value.as_str());
    }
}

/// A type used for the construction of columns in a
/// [`TableView`](struct.TableView.html).
pub struct TableColumn<H> {
    column: H,
    title: String,
    selected: bool,
    alignment: HAlign,
    header_alignment: Option<HAlign>,
    order: Ordering,
    width: usize,
    default_order: Ordering,
    requested_width: Option<TableColumnWidth>,
}

enum TableColumnWidth {
    Percent(usize),
    Absolute(usize),
}

impl<H: Copy + Clone + 'static> TableColumn<H> {
    /// Sets the default ordering of the column.
    pub fn ordering(mut self, order: Ordering) -> Self {
        self.default_order = order;
        self
    }

    /// Sets the horizontal text alignment of the column.
    pub fn align(mut self, alignment: HAlign) -> Self {
        self.alignment = alignment;
        self
    }

    /// Sets the horizontal text alignment of the column header.
    pub fn header_align(mut self, alignment: HAlign) -> Self {
        self.header_alignment = Some(alignment);
        self
    }

    /// Sets how many characters of width this column will try to occupy.
    pub fn width(mut self, width: usize) -> Self {
        self.requested_width = Some(TableColumnWidth::Absolute(width));
        self
    }

    /// Sets what percentage of the width of the entire table this column will
    /// try to occupy.
    pub fn width_percent(mut self, width: usize) -> Self {
        self.requested_width = Some(TableColumnWidth::Percent(width));
        self
    }

    fn new(column: H, title: String) -> Self {
        Self {
            column,
            title,
            selected: false,
            alignment: HAlign::Left,
            header_alignment: None,
            order: Ordering::Equal,
            width: 0,
            default_order: Ordering::Less,
            requested_width: None,
        }
    }

    fn draw_header(&self, printer: &Printer, sortable: bool) {
        let title_width = if sortable {
            self.width.saturating_sub(4)
        } else {
            self.width
        };
        let title = self.title.as_str();

        let alignment = self.header_alignment.unwrap_or(self.alignment);
        let mut header = match alignment {
            HAlign::Left => format!("{:<width$}", title, width = title_width),
            HAlign::Right => format!("{:>width$}", title, width = title_width),
            HAlign::Center => format!("{:^width$}", title, width = title_width),
        };

        if sortable {
            let order = match self.order {
                Ordering::Less => "^",
                Ordering::Greater => "v",
                Ordering::Equal => " ",
            };
            header.push_str(" [");
            header.push_str(order);
            header.push(']');
        }

        printer.print((0, 0), header.as_str());
    }

    fn draw_row(&self, printer: &Printer, value: &str) {
        let value = match self.alignment {
            HAlign::Left => format!("{:<width$} ", value, width = self.width),
            HAlign::Right => format!("{:>width$} ", value, width = self.width),
            HAlign::Center => format!("{:^width$} ", value, width = self.width),
        };

        printer.print((0, 0), value.as_str());
    }
}

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

    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    enum SimpleColumn {
        Name,
    }

    #[allow(dead_code)]
    impl SimpleColumn {
        fn as_str(&self) -> &str {
            match *self {
                SimpleColumn::Name => "Name",
            }
        }
    }

    #[derive(Clone, Debug)]
    struct SimpleItem {
        name: String,
    }

    impl TableViewItem<SimpleColumn> for SimpleItem {
        fn to_column(&self, column: SimpleColumn) -> String {
            match column {
                SimpleColumn::Name => self.name.to_string(),
            }
        }

        fn cmp(&self, other: &Self, column: SimpleColumn) -> Ordering
        where
            Self: Sized,
        {
            match column {
                SimpleColumn::Name => self.name.cmp(&other.name),
            }
        }
    }

    fn setup_test_table() -> TableView<SimpleItem, SimpleColumn> {
        TableView::<SimpleItem, SimpleColumn>::new()
            .column(SimpleColumn::Name, "Name", |c| c.width_percent(20))
    }

    #[test]
    fn should_insert_into_existing_table() {
        let mut simple_table = setup_test_table();

        let mut simple_items = Vec::new();

        for i in 1..=10 {
            simple_items.push(SimpleItem {
                name: format!("{} - Name", i),
            });
        }

        // Insert First Batch of Items
        simple_table.set_items(simple_items);

        // Test for Additional item insertion
        simple_table.insert_item(SimpleItem {
            name: format!("{} Name", 11),
        });

        assert_eq!(simple_table.len(), 11);
    }

    #[test]
    fn should_insert_into_empty_table() {
        let mut simple_table = setup_test_table();

        // Test for First item insertion
        simple_table.insert_item(SimpleItem {
            name: format!("{} Name", 1),
        });

        assert_eq!(simple_table.len(), 1);
    }
}