use std::{
cell::Cell,
cmp::Ordering,
collections::{HashMap, HashSet},
hash::Hash,
marker::PhantomData,
sync::Arc,
};
use parking_lot::Mutex;
use super::{
checkbox::Checkbox,
empty_state::{EmptyState, EmptyStateSize},
icons,
input::{Input, InputSize},
menu::{Menu, MenuItem},
names,
number_input::NumberInput,
part_style::{FontFamily, Length},
recipe::{Case, Interaction, Name, Recipe, ResolvedPart, ResolvedRecipe, Selector},
select::Select,
shared::{fading, glyph, pressable},
skeleton::Skeleton,
theme::{Themed, current_theme},
};
mod columns;
mod export;
mod filtering;
mod filters;
mod groups;
mod heights;
mod keys;
mod range;
mod search;
mod source;
mod summary;
mod text;
pub use columns::{ColumnLayout, ColumnMenuLabels, ColumnPlace};
use columns::{ColumnMenuLink, DropSide, MenuChoice};
pub use export::{ExportFormat, ExportLabels, ExportScope, GridBarLabels, GridExport, to_csv, to_delimited, to_tsv};
pub use filtering::FilterLabels;
use filtering::{FilterLink, FilterShape, FilterState, MOST_VALUES};
pub use filters::{ColumnFilter, GridQuery, TableFilters, TextMatch};
use filters::{FilterBy, Test};
pub use groups::{GroupKey, TableGroup};
use groups::{Lines, Shown};
use heights::Heights;
use keys::{KeptIndex, RowKeys};
pub use range::{CellKey, CellRange};
use range::{RangeMark, Span, span_of};
pub use search::SearchMatches;
use search::{Found, SearchState};
pub use source::{GridPage, GridRequest, SourceRow};
use source::{RowSource, Slot};
use summary::{Said, Summary, SummaryKey, summarize, summary_content};
pub use summary::{SummaryKind, SummaryLabels, TableSummary};
pub use text::TableTextError;
use crate::{
app::{
component::Component,
ctx::{Ctx, Placement},
events::{
CopyEvent, DragEvent, EditEvent, KeyboardEvent, MouseButton, MouseButtonMask, MouseEvent, PasteEvent, ScrollEvent,
},
runtime::{DOUBLE_CLICK_DISTANCE, DOUBLE_CLICK_INTERVAL},
theme::{BorderSize, Density, IconSize, OpacityLevel, PaletteColor, RadiusSize, Theme, TypographyStyle},
},
components::{self, Column, Row, ScrollBoth},
core::{ElementRef, Signal, SignalValue},
layout::{
Alignment,
column_tracks::{ColumnTracks, TrackSpec, TrackWidth},
layout_kind::{Justify, ScrollState, Sticky},
text_style::FontWeight,
},
node::{
BackgroundColor, CursorIcon, Element, FocusGroup, FocusRows, border::Border as Line, dimension::Dimension,
outline::Outline,
},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TablePart {
Root,
Scroll,
Header,
HeaderCell,
SortIcon,
SortOrder,
FilterIcon,
FilterRow,
FilterLabel,
Resizer,
ResizeLine,
MenuTrigger,
DropLine,
GroupRow,
Chevron,
GroupLabel,
GroupCount,
Summary,
Detail,
TreeToggle,
RowNumber,
SummaryLabel,
SummaryValue,
Row,
Cell,
Select,
Editor,
Empty,
Footer,
Count,
}
names!(TablePart {
Root => "root",
Scroll => "scroll",
Header => "header",
HeaderCell => "header_cell",
SortIcon => "sort_icon",
SortOrder => "sort_order",
FilterIcon => "filter_icon",
FilterRow => "filter_row",
FilterLabel => "filter_label",
Resizer => "resizer",
ResizeLine => "resize_line",
MenuTrigger => "menu_trigger",
DropLine => "drop_line",
GroupRow => "group_row",
Chevron => "chevron",
GroupLabel => "group_label",
GroupCount => "group_count",
Summary => "summary",
Detail => "detail",
TreeToggle => "tree_toggle",
RowNumber => "row_number",
SummaryLabel => "summary_label",
SummaryValue => "summary_value",
Row => "row",
Cell => "cell",
Select => "select",
Editor => "editor",
Empty => "empty",
Footer => "footer",
Count => "count",
});
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TableState {
Selectable,
Selected,
Last,
Sortable,
Sorted,
Muted,
Mono,
Numeric,
Pinned,
Footer,
Disabled,
InRange,
RangeTop,
RangeBottom,
RangeStart,
RangeEnd,
Open,
DropBefore,
DropAfter,
}
names!(TableState {
Selectable => "selectable",
Selected => "selected",
Last => "last",
Sortable => "sortable",
Sorted => "sorted",
Muted => "muted",
Mono => "mono",
Numeric => "numeric",
Pinned => "pinned",
Footer => "footer",
Disabled => "disabled",
InRange => "in_range",
RangeTop => "range_top",
RangeBottom => "range_bottom",
RangeStart => "range_start",
RangeEnd => "range_end",
Open => "open",
DropBefore => "drop_before",
DropAfter => "drop_after",
});
pub type TableRenderer = Arc<dyn Fn(TableView) -> Element + Send + Sync>;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum SortDirection {
Ascending,
Descending,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct TableSort {
pub column: Arc<str>,
pub direction: SortDirection,
}
impl crate::app::component::DevtoolsInspectable for TableSort {}
impl TableSort {
pub fn ascending(column: &str) -> Self {
Self {
column: Arc::from(column),
direction: SortDirection::Ascending,
}
}
pub fn descending(column: &str) -> Self {
Self {
column: Arc::from(column),
direction: SortDirection::Descending,
}
}
pub fn after_press(current: &[TableSort], column: &str, adding: bool) -> Vec<TableSort> {
let held = current.iter().position(|sort| &*sort.column == column);
if !adding {
return match held.map(|at| current[at].direction) {
Some(SortDirection::Ascending) => vec![Self::descending(column)],
Some(SortDirection::Descending) => Vec::new(),
None => vec![Self::ascending(column)],
};
}
let mut next = current.to_vec();
match held {
Some(at) if next[at].direction == SortDirection::Ascending => next[at].direction = SortDirection::Descending,
Some(at) => {
next.remove(at);
}
None => next.push(Self::ascending(column)),
}
next
}
pub fn sort_rows<R: 'static>(sorts: &[TableSort], columns: &[TableColumn<R>], rows: &mut [R]) {
let compares: Vec<(CompareFn<R>, SortDirection)> = sorts
.iter()
.filter_map(|sort| Some((sort.compare(columns)?, sort.direction)))
.collect();
if compares.is_empty() {
return;
}
rows.sort_by(|a, b| {
compares
.iter()
.map(|(compare, direction)| match direction {
SortDirection::Ascending => compare(a, b),
SortDirection::Descending => compare(b, a),
})
.find(|order| order.is_ne())
.unwrap_or(Ordering::Equal)
});
}
fn compare<R: 'static>(&self, columns: &[TableColumn<R>]) -> Option<CompareFn<R>> {
let column = columns.iter().find(|column| column.id == self.column)?;
match (&column.compare, &column.content) {
(Some(compare), _) => Some(compare.clone()),
(None, Content::Text(text)) => {
let text = text.clone();
Some(Arc::new(move |a: &R, b: &R| text(a).cmp(&text(b))))
}
(None, _) => None,
}
}
pub fn sort<R: 'static>(&self, columns: &[TableColumn<R>], rows: &mut [R]) {
let Some(compare) = self.compare(columns) else {
return;
};
match self.direction {
SortDirection::Ascending => rows.sort_by(|a, b| compare(a, b)),
SortDirection::Descending => rows.sort_by(|a, b| compare(b, a)),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum ColumnAlign {
#[default]
Start,
Center,
End,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum ColumnPin {
#[default]
None,
Start,
End,
}
type CellFn<R> = Arc<dyn Fn(&R) -> Element + Send + Sync>;
type TextFn<R> = Arc<dyn Fn(&R) -> String + Send + Sync>;
type CompareFn<R> = Arc<dyn Fn(&R, &R) -> Ordering + Send + Sync>;
enum Content<R> {
Text(TextFn<R>),
Element(CellFn<R>),
Nothing,
}
impl<R> Clone for Content<R> {
fn clone(&self) -> Self {
match self {
Self::Text(text) => Self::Text(text.clone()),
Self::Element(cell) => Self::Element(cell.clone()),
Self::Nothing => Self::Nothing,
}
}
}
pub struct TableColumn<R> {
id: Arc<str>,
title: Arc<str>,
title_hidden: bool,
track: TrackSpec,
align: ColumnAlign,
sortable: bool,
pin: ColumnPin,
resizable: Option<bool>,
controls: bool,
kinds: Vec<Name>,
content: Content<R>,
compare: Option<CompareFn<R>>,
editor: Option<CellEditor<R>>,
summary: Option<Summary<R>>,
wrap: bool,
filter: Option<FilterBy<R>>,
}
impl<R> Clone for TableColumn<R> {
fn clone(&self) -> Self {
Self {
id: self.id.clone(),
title: self.title.clone(),
title_hidden: self.title_hidden,
track: self.track,
align: self.align,
sortable: self.sortable,
pin: self.pin,
resizable: self.resizable,
controls: self.controls,
kinds: self.kinds.clone(),
content: self.content.clone(),
compare: self.compare.clone(),
editor: self.editor.clone(),
summary: self.summary.clone(),
wrap: self.wrap,
filter: self.filter.clone(),
}
}
}
impl<R: 'static> TableColumn<R> {
pub fn new(id: &str, title: &str) -> Self {
Self {
id: Arc::from(id),
title: Arc::from(title),
title_hidden: false,
track: TrackSpec::share(1.0),
align: ColumnAlign::Start,
sortable: false,
pin: ColumnPin::None,
resizable: None,
controls: false,
kinds: Vec::new(),
content: Content::Nothing,
compare: None,
editor: None,
summary: None,
wrap: false,
filter: None,
}
}
pub fn actions(id: &str, cell: impl Fn(&R) -> Element + Send + Sync + 'static) -> Self {
let mut column = Self::new(id, &crate::ui::current_locale().data.actions_column)
.fit()
.align(ColumnAlign::End)
.controls(true)
.cell(cell);
column.title_hidden = true;
column
}
pub fn text(mut self, text: impl Fn(&R) -> String + Send + Sync + 'static) -> Self {
self.content = Content::Text(Arc::new(text));
self
}
pub fn cell(mut self, cell: impl Fn(&R) -> Element + Send + Sync + 'static) -> Self {
self.content = Content::Element(Arc::new(cell));
self
}
pub fn width(mut self, px: f32) -> Self {
self.track.width = TrackWidth::Px(px.max(0.0));
self
}
pub fn share(mut self, share: f32) -> Self {
self.track.width = TrackWidth::Share(share.max(0.0));
self
}
pub fn fit(mut self) -> Self {
self.track.width = TrackWidth::Content;
self
}
pub fn min_width(mut self, px: f32) -> Self {
self.track = self.track.min(px);
self
}
pub fn max_width(mut self, px: f32) -> Self {
self.track = self.track.max(px);
self
}
pub fn align(mut self, align: ColumnAlign) -> Self {
self.align = align;
self
}
pub fn numeric(mut self) -> Self {
self.align = ColumnAlign::End;
self.kind(TableState::Numeric, true)
}
pub fn wrap(mut self, wrap: bool) -> Self {
self.wrap = wrap;
self
}
pub fn filter_text(mut self, filter: bool) -> Self {
self.filter = filter.then_some(FilterBy::Text);
self
}
pub fn filter_set(mut self, filter: bool) -> Self {
self.filter = filter.then_some(FilterBy::Set);
self
}
pub fn filter_values(mut self, value: impl Fn(&R) -> String + Send + Sync + 'static) -> Self {
self.filter = Some(FilterBy::Values(Arc::new(value)));
self
}
pub fn filter_number(mut self, value: impl Fn(&R) -> f64 + Send + Sync + 'static) -> Self {
self.filter = Some(FilterBy::Number(Arc::new(value)));
self
}
pub fn filter_date(mut self, value: impl Fn(&R) -> Option<crate::core::Date> + Send + Sync + 'static) -> Self {
self.filter = Some(FilterBy::Date(Arc::new(value)));
self
}
pub fn filter_bool(mut self, value: impl Fn(&R) -> bool + Send + Sync + 'static) -> Self {
self.filter = Some(FilterBy::Bool(Arc::new(value)));
self
}
pub fn mono(self, mono: bool) -> Self {
self.kind(TableState::Mono, mono)
}
pub fn muted(self, muted: bool) -> Self {
self.kind(TableState::Muted, muted)
}
pub fn kind(mut self, state: impl Into<Name>, on: bool) -> Self {
let state = state.into();
self.kinds.retain(|held| *held != state);
if on {
self.kinds.push(state);
}
self
}
pub fn sortable(mut self, sortable: bool) -> Self {
self.sortable = sortable;
self
}
pub fn sort_by(mut self, compare: impl Fn(&R, &R) -> Ordering + Send + Sync + 'static) -> Self {
self.compare = Some(Arc::new(compare));
self.sortable = true;
self
}
pub fn sort_key<O: Ord>(self, key: impl Fn(&R) -> O + Send + Sync + 'static) -> Self {
self.sort_by(move |a, b| key(a).cmp(&key(b)))
}
pub fn pin(mut self, pin: ColumnPin) -> Self {
self.pin = pin;
self
}
pub fn resizable(mut self, resizable: bool) -> Self {
self.resizable = Some(resizable);
self
}
pub fn controls(mut self, controls: bool) -> Self {
self.controls = controls;
self
}
pub fn editor(mut self, editor: CellEditor<R>) -> Self {
self.editor = Some(editor);
self
}
pub fn summary(mut self, kind: SummaryKind) -> Self {
self.summary = Some(Summary::Kind(kind));
self
}
pub fn summary_text(mut self, text: impl Fn(&[&R]) -> String + Send + Sync + 'static) -> Self {
self.summary = Some(Summary::Text(Arc::new(text)));
self
}
pub fn id(&self) -> &str {
&self.id
}
pub fn title(&self) -> &str {
&self.title
}
}
type Told<K> = Arc<dyn Fn(&K) + Send + Sync>;
type SortFn = Arc<dyn Fn(Vec<TableSort>) + Send + Sync>;
type SortHeard = Arc<dyn Fn(&[TableSort]) + Send + Sync>;
type SelectionHeard<K> = Arc<dyn Fn(&[K]) + Send + Sync>;
type RangeWrite<K> = Arc<dyn Fn(Option<CellRange<K>>) + Send + Sync>;
type RangeHeard<K> = Arc<dyn Fn(Option<&CellRange<K>>) + Send + Sync>;
type LayoutWrite = Arc<dyn Fn(ColumnLayout) + Send + Sync>;
type LayoutHeard = Arc<dyn Fn(&ColumnLayout) + Send + Sync>;
type OpenWrite = Arc<dyn Fn(Vec<GroupKey>) + Send + Sync>;
type OpenHeard = Arc<dyn Fn(&GroupKey, bool) + Send + Sync>;
type CountFn = Arc<dyn Fn(TableCount) -> String + Send + Sync>;
type SlotsLink = (
Arc<dyn Fn(usize) -> Slot + Send + Sync>,
Arc<dyn Fn(usize) + Send + Sync>,
);
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct TableCount {
pub shown: usize,
pub total: usize,
pub selected: Option<usize>,
}
type FiltersFn = Arc<dyn Fn(TableFilters) + Send + Sync>;
type FiltersHeard = Arc<dyn Fn(&TableFilters) + Send + Sync>;
type ResizeHeard = Arc<dyn Fn(&str, f32) + Send + Sync>;
type ResizeLabelFn = Arc<dyn Fn(&str) -> String + Send + Sync>;
const LEAST_COLUMN: f32 = 48.0;
const RESIZE_STEP: f32 = 10.0;
const RESIZE_STEP_SHIFT: f32 = 50.0;
#[derive(Clone)]
struct Words {
empty: Arc<str>,
select_all: Arc<str>,
select_row: Arc<str>,
count: Option<CountFn>,
resize: Option<ResizeLabelFn>,
menu: Arc<ColumnMenuLabels>,
menu_trigger: Option<ResizeLabelFn>,
group: Option<GroupLabelFn>,
summary: Arc<SummaryLabels>,
numbers: Arc<str>,
filter: Arc<FilterLabels>,
source: Arc<SourceLabels>,
export: Arc<ExportLabels>,
bar: Arc<GridBarLabels>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct SourceLabels {
pub failed: String,
pub retry: String,
}
impl Default for SourceLabels {
fn default() -> Self {
let locale = crate::ui::current_locale();
Self {
failed: locale.data.rows_failed.to_string(),
retry: locale.common.retry.to_string(),
}
}
}
type GroupLabelFn = Arc<dyn Fn(&str, &str, usize) -> String + Send + Sync>;
impl Default for Words {
fn default() -> Self {
let locale = crate::ui::current_locale();
Self {
empty: locale.data.no_rows.clone(),
select_all: locale.common.select_all.clone(),
select_row: locale.data.select_row.clone(),
count: None,
resize: None,
menu: Arc::default(),
menu_trigger: None,
group: None,
summary: Arc::default(),
numbers: Arc::from("#"),
filter: Arc::default(),
source: Arc::default(),
export: Arc::default(),
bar: Arc::default(),
}
}
}
type KeyFn<R, K> = Arc<dyn Fn(usize, &R) -> K + Send + Sync>;
type ParentFn<R, K> = Arc<dyn Fn(&R) -> Option<K> + Send + Sync>;
type KeysWrite<K> = Arc<dyn Fn(Vec<K>) + Send + Sync>;
type KeyOpenHeard<K> = Arc<dyn Fn(&K, bool) + Send + Sync>;
type DetailFn<R> = Arc<dyn Fn(&R) -> Element + Send + Sync>;
pub struct Table<R, K = usize> {
columns: Vec<TableColumn<R>>,
rows: Arc<Vec<R>>,
key_of: KeyFn<R, K>,
sort: Vec<TableSort>,
write_sort: Option<SortFn>,
on_sort_change: Vec<SortHeard>,
filters: TableFilters,
write_filters: Option<FiltersFn>,
on_filters_change: Vec<FiltersHeard>,
filter_row: bool,
search: Arc<str>,
write_search: Option<Arc<dyn Fn(String) + Send + Sync>>,
on_search_change: Vec<Arc<dyn Fn(&str) + Send + Sync>>,
search_options: super::highlight::FindOptions,
on_matches_change: Vec<Arc<dyn Fn(SearchMatches) + Send + Sync>>,
find_bar: bool,
find_bar_with: Option<Arc<dyn Fn(super::find_bar::FindBar) -> super::find_bar::FindBar + Send + Sync>>,
export: bool,
on_export: Vec<Arc<dyn Fn(&GridExport) + Send + Sync>>,
toolbar: bool,
source: Option<Arc<dyn RowSource<R>>>,
on_query_change: Vec<Arc<dyn Fn(&GridQuery) + Send + Sync>>,
slots: Option<SlotsLink>,
selected: Vec<K>,
select: Option<Arc<dyn Fn(Vec<K>) + Send + Sync>>,
on_selection_change: Vec<SelectionHeard<K>>,
words: Words,
resizable: bool,
on_column_resize: Vec<ResizeHeard>,
on_column_resize_end: Vec<ResizeHeard>,
resized: Arc<HashMap<Arc<str>, f32>>,
grid: bool,
read_only: bool,
on_edit: Vec<EditHeard<K>>,
cell_range: Option<CellRange<K>>,
write_cell_range: Option<RangeWrite<K>>,
on_cell_selection_change: Vec<RangeHeard<K>>,
column_layout: Option<ColumnLayout>,
write_column_layout: Option<LayoutWrite>,
on_column_layout_change: Vec<LayoutHeard>,
column_menu: bool,
arranged: Option<Arc<(ColumnLayout, Vec<(Arc<str>, Arc<str>)>)>>,
group_by: Vec<Arc<str>>,
open_groups: Vec<GroupKey>,
write_open: Option<OpenWrite>,
on_open_change: Vec<OpenHeard>,
grouping: Vec<TableColumn<R>>,
tree_parent: Option<ParentFn<R, K>>,
expanded: Vec<K>,
write_expanded: Option<KeysWrite<K>>,
on_expanded_change: Vec<KeyOpenHeard<K>>,
detail: Option<DetailFn<R>>,
details_open: Vec<K>,
write_details: Option<KeysWrite<K>>,
on_detail_change: Vec<KeyOpenHeard<K>>,
row_numbers: bool,
checkboxes: bool,
on_row_click: Vec<Told<K>>,
on_row_activate: Vec<Told<K>>,
reveal: Option<(K, u64)>,
density: Option<Density>,
height: Option<Length>,
max_height: Option<Length>,
empty: Option<Element>,
loading: bool,
loading_rows: usize,
pagination: Option<Element>,
count: bool,
total: Option<usize>,
label: Option<Arc<str>>,
disabled: bool,
states: Vec<Name>,
rules: Recipe,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl<R, K: Clone> Clone for Table<R, K> {
fn clone(&self) -> Self {
Self {
columns: self.columns.clone(),
rows: self.rows.clone(),
key_of: self.key_of.clone(),
sort: self.sort.clone(),
write_sort: self.write_sort.clone(),
on_sort_change: self.on_sort_change.clone(),
filters: self.filters.clone(),
write_filters: self.write_filters.clone(),
on_filters_change: self.on_filters_change.clone(),
filter_row: self.filter_row,
search: self.search.clone(),
write_search: self.write_search.clone(),
on_search_change: self.on_search_change.clone(),
search_options: self.search_options,
on_matches_change: self.on_matches_change.clone(),
find_bar: self.find_bar,
find_bar_with: self.find_bar_with.clone(),
export: self.export,
on_export: self.on_export.clone(),
toolbar: self.toolbar,
source: self.source.clone(),
on_query_change: self.on_query_change.clone(),
slots: self.slots.clone(),
selected: self.selected.clone(),
select: self.select.clone(),
on_selection_change: self.on_selection_change.clone(),
words: self.words.clone(),
resizable: self.resizable,
on_column_resize: self.on_column_resize.clone(),
on_column_resize_end: self.on_column_resize_end.clone(),
resized: self.resized.clone(),
grid: self.grid,
read_only: self.read_only,
on_edit: self.on_edit.clone(),
cell_range: self.cell_range.clone(),
write_cell_range: self.write_cell_range.clone(),
on_cell_selection_change: self.on_cell_selection_change.clone(),
column_layout: self.column_layout.clone(),
write_column_layout: self.write_column_layout.clone(),
on_column_layout_change: self.on_column_layout_change.clone(),
column_menu: self.column_menu,
arranged: self.arranged.clone(),
group_by: self.group_by.clone(),
open_groups: self.open_groups.clone(),
write_open: self.write_open.clone(),
on_open_change: self.on_open_change.clone(),
tree_parent: self.tree_parent.clone(),
expanded: self.expanded.clone(),
write_expanded: self.write_expanded.clone(),
on_expanded_change: self.on_expanded_change.clone(),
detail: self.detail.clone(),
details_open: self.details_open.clone(),
write_details: self.write_details.clone(),
on_detail_change: self.on_detail_change.clone(),
grouping: self.grouping.clone(),
row_numbers: self.row_numbers,
checkboxes: self.checkboxes,
on_row_click: self.on_row_click.clone(),
on_row_activate: self.on_row_activate.clone(),
reveal: self.reveal.clone(),
density: self.density.clone(),
height: self.height,
max_height: self.max_height,
empty: self.empty.clone(),
loading: self.loading,
loading_rows: self.loading_rows,
pagination: self.pagination.clone(),
count: self.count,
total: self.total,
label: self.label.clone(),
disabled: self.disabled,
states: self.states.clone(),
rules: self.rules.clone(),
forced: self.forced,
id: self.id.clone(),
key: self.key.clone(),
}
}
}
impl<R: Send + Sync + 'static> Table<R, usize> {
pub fn new(columns: impl IntoIterator<Item = TableColumn<R>>, rows: impl IntoIterator<Item = R>) -> Self {
Self::new_shared(columns, Arc::new(rows.into_iter().collect()))
}
pub fn new_shared(columns: impl IntoIterator<Item = TableColumn<R>>, rows: Arc<Vec<R>>) -> Self {
Self {
columns: columns.into_iter().collect(),
rows,
key_of: Arc::new(|index, _| index),
sort: Vec::new(),
write_sort: None,
filters: TableFilters::default(),
write_filters: None,
on_filters_change: Vec::new(),
filter_row: false,
on_sort_change: Vec::new(),
search: Arc::from(""),
write_search: None,
on_search_change: Vec::new(),
search_options: super::highlight::FindOptions::default(),
on_matches_change: Vec::new(),
find_bar: false,
find_bar_with: None,
export: true,
on_export: Vec::new(),
toolbar: false,
source: None,
on_query_change: Vec::new(),
slots: None,
selected: Vec::new(),
select: None,
on_selection_change: Vec::new(),
words: Words::default(),
resizable: false,
on_column_resize: Vec::new(),
on_column_resize_end: Vec::new(),
resized: Arc::default(),
grid: false,
read_only: false,
on_edit: Vec::new(),
cell_range: None,
write_cell_range: None,
on_cell_selection_change: Vec::new(),
column_layout: None,
write_column_layout: None,
on_column_layout_change: Vec::new(),
column_menu: false,
arranged: None,
group_by: Vec::new(),
open_groups: Vec::new(),
write_open: None,
on_open_change: Vec::new(),
tree_parent: None,
expanded: Vec::new(),
write_expanded: None,
on_expanded_change: Vec::new(),
detail: None,
details_open: Vec::new(),
write_details: None,
on_detail_change: Vec::new(),
grouping: Vec::new(),
row_numbers: false,
checkboxes: true,
on_row_click: Vec::new(),
on_row_activate: Vec::new(),
reveal: None,
density: None,
height: None,
max_height: None,
empty: None,
loading: false,
loading_rows: 4,
pagination: None,
count: false,
total: None,
label: None,
disabled: false,
states: Vec::new(),
rules: Recipe::new(),
forced: None,
id: None,
key: None,
}
}
pub fn row_key<K: Clone + Eq + Hash + Send + Sync + 'static>(
self,
key: impl Fn(&R) -> K + Send + Sync + 'static,
) -> Table<R, K> {
Table {
columns: self.columns,
rows: self.rows,
key_of: Arc::new(move |_, row| key(row)),
sort: self.sort,
write_sort: self.write_sort,
on_sort_change: self.on_sort_change,
filters: self.filters,
write_filters: self.write_filters,
on_filters_change: self.on_filters_change,
filter_row: self.filter_row,
search: self.search,
write_search: self.write_search,
on_search_change: self.on_search_change,
search_options: self.search_options,
on_matches_change: self.on_matches_change,
find_bar: self.find_bar,
find_bar_with: self.find_bar_with,
export: self.export,
on_export: self.on_export,
toolbar: self.toolbar,
source: self.source,
on_query_change: self.on_query_change,
slots: self.slots,
selected: Vec::new(),
select: None,
on_selection_change: Vec::new(),
words: self.words,
resizable: self.resizable,
on_column_resize: self.on_column_resize,
on_column_resize_end: self.on_column_resize_end,
resized: self.resized,
grid: self.grid,
read_only: self.read_only,
on_edit: Vec::new(),
cell_range: None,
write_cell_range: None,
on_cell_selection_change: Vec::new(),
column_layout: self.column_layout,
write_column_layout: self.write_column_layout,
on_column_layout_change: self.on_column_layout_change,
column_menu: self.column_menu,
arranged: None,
group_by: self.group_by,
open_groups: self.open_groups,
write_open: self.write_open,
on_open_change: self.on_open_change,
tree_parent: None,
expanded: Vec::new(),
write_expanded: None,
on_expanded_change: Vec::new(),
detail: self.detail,
details_open: Vec::new(),
write_details: None,
on_detail_change: Vec::new(),
grouping: self.grouping,
row_numbers: self.row_numbers,
checkboxes: self.checkboxes,
on_row_click: Vec::new(),
on_row_activate: Vec::new(),
reveal: None,
density: self.density,
height: self.height,
max_height: self.max_height,
empty: self.empty,
loading: self.loading,
loading_rows: self.loading_rows,
pagination: self.pagination,
count: self.count,
total: self.total,
label: self.label,
disabled: self.disabled,
states: self.states,
rules: self.rules,
forced: self.forced,
id: self.id,
key: self.key,
}
}
}
impl<R: Send + Sync + 'static, K: Clone + Eq + Hash + Send + Sync + 'static> Table<R, K> {
pub fn sort(mut self, sort: Signal<Vec<TableSort>>) -> Self
where
Vec<TableSort>: SignalValue,
{
self.sort = sort.get();
self.write_sort = Some(Arc::new(move |next| sort.set(next)));
self
}
pub fn sort_controlled(
mut self,
sort: Vec<TableSort>,
on_change: impl Fn(Vec<TableSort>) + Send + Sync + 'static,
) -> Self {
self.sort = sort;
self.write_sort = Some(Arc::new(on_change));
self
}
pub fn on_sort_change(mut self, handler: impl Fn(&[TableSort]) + Send + Sync + 'static) -> Self {
self.on_sort_change.push(Arc::new(handler));
self
}
pub fn filters(mut self, filters: Signal<TableFilters>) -> Self
where
TableFilters: SignalValue,
{
self.filters = filters.get();
self.write_filters = Some(Arc::new(move |next| filters.set(next)));
self
}
pub fn filters_controlled(
mut self,
filters: TableFilters,
on_change: impl Fn(TableFilters) + Send + Sync + 'static,
) -> Self {
self.filters = filters;
self.write_filters = Some(Arc::new(on_change));
self
}
pub fn on_filters_change(mut self, handler: impl Fn(&TableFilters) + Send + Sync + 'static) -> Self {
self.on_filters_change.push(Arc::new(handler));
self
}
pub fn filter_row(mut self, filter_row: bool) -> Self {
self.filter_row = filter_row;
self
}
pub fn search(mut self, query: Signal<String>) -> Self
where
String: SignalValue,
{
self.search = Arc::from(query.get().as_str());
self.write_search = Some(Arc::new(move |next| query.set(next)));
self
}
pub fn search_controlled(mut self, query: &str, on_change: impl Fn(String) + Send + Sync + 'static) -> Self {
self.search = Arc::from(query);
self.write_search = Some(Arc::new(on_change));
self
}
pub fn on_search_change(mut self, handler: impl Fn(&str) + Send + Sync + 'static) -> Self {
self.on_search_change.push(Arc::new(handler));
self
}
pub fn search_options(mut self, options: super::highlight::FindOptions) -> Self {
self.search_options = options;
self
}
pub fn on_matches_change(mut self, handler: impl Fn(SearchMatches) + Send + Sync + 'static) -> Self {
self.on_matches_change.push(Arc::new(handler));
self
}
pub fn find_bar(mut self, find_bar: bool) -> Self {
self.find_bar = find_bar;
self
}
pub fn find_bar_with(
mut self,
with: impl Fn(super::find_bar::FindBar) -> super::find_bar::FindBar + Send + Sync + 'static,
) -> Self {
self.find_bar_with = Some(Arc::new(with));
self
}
pub fn on_query_change(mut self, handler: impl Fn(&GridQuery) + Send + Sync + 'static) -> Self {
self.on_query_change.push(Arc::new(handler));
self
}
pub fn source_labels(mut self, labels: SourceLabels) -> Self {
self.words.source = Arc::new(labels);
self
}
pub fn export(mut self, export: bool) -> Self {
self.export = export;
self
}
pub fn on_export(mut self, handler: impl Fn(&GridExport) + Send + Sync + 'static) -> Self {
self.on_export.push(Arc::new(handler));
self
}
pub fn export_labels(mut self, labels: ExportLabels) -> Self {
self.words.export = Arc::new(labels);
self
}
pub(super) fn set_toolbar(mut self, toolbar: bool) -> Self {
self.toolbar = toolbar;
self
}
pub(super) fn set_toolbar_labels(mut self, labels: GridBarLabels) -> Self {
self.words.bar = Arc::new(labels);
self
}
pub fn filter_labels(mut self, labels: FilterLabels) -> Self {
self.words.filter = Arc::new(labels);
self
}
fn values_of(&self, host: &HostState, column: &TableColumn<R>) -> Arc<Vec<String>> {
let seen = Arc::as_ptr(&self.rows) as *const () as usize;
if let Some((rows, values)) = host.filters.values.lock().get(&column.id)
&& *rows == seen
{
return values.clone();
}
let value: Box<dyn Fn(&R) -> String> = match (&column.filter, &column.content) {
(Some(FilterBy::Values(values)), _) => {
let values = values.clone();
Box::new(move |row| values(row))
}
(_, Content::Text(text)) => {
let text = text.clone();
Box::new(move |row| text(row))
}
_ => return Arc::default(),
};
let mut values: Vec<String> = self
.rows
.iter()
.map(value)
.collect::<std::collections::BTreeSet<_>>()
.into_iter()
.take(MOST_VALUES)
.collect();
values.shrink_to_fit();
let values = Arc::new(values);
host
.filters
.values
.lock()
.insert(column.id.clone(), (seen, values.clone()));
values
}
fn filter_changer(&self) -> Option<Arc<dyn Fn(TableFilters) + Send + Sync>> {
if self.write_filters.is_none() && self.on_filters_change.is_empty() {
return None;
}
let (now, write, heard) = (
self.filters.clone(),
self.write_filters.clone(),
self.on_filters_change.clone(),
);
Some(Arc::new(move |next: TableFilters| {
if next == now {
return;
}
if let Some(write) = &write {
write(next.clone());
}
for handler in &heard {
handler(&next);
}
}))
}
pub fn selected(mut self, selected: Signal<Vec<K>>) -> Self
where
Vec<K>: SignalValue,
{
self.selected = selected.get();
self.select = Some(Arc::new(move |next| selected.set(next)));
self
}
pub fn selected_controlled(
mut self,
selected: impl IntoIterator<Item = K>,
on_change: impl Fn(Vec<K>) + Send + Sync + 'static,
) -> Self {
self.selected = selected.into_iter().collect();
self.select = Some(Arc::new(on_change));
self
}
pub fn on_selection_change(mut self, handler: impl Fn(&[K]) + Send + Sync + 'static) -> Self {
self.on_selection_change.push(Arc::new(handler));
self
}
pub fn checkboxes(mut self, checkboxes: bool) -> Self {
self.checkboxes = checkboxes;
self
}
pub fn on_row_click(mut self, handler: impl Fn(&K) + Send + Sync + 'static) -> Self {
self.on_row_click.push(Arc::new(handler));
self
}
pub fn on_row_activate(mut self, handler: impl Fn(&K) + Send + Sync + 'static) -> Self {
self.on_row_activate.push(Arc::new(handler));
self
}
pub fn reveal(mut self, key: K, request: u64) -> Self {
self.reveal = Some((key, request));
self
}
pub fn density(mut self, density: impl Into<Density>) -> Self {
self.density = Some(density.into());
self
}
pub fn height(mut self, height: impl Into<Length>) -> Self {
self.height = Some(height.into());
self
}
pub fn max_height(mut self, height: impl Into<Length>) -> Self {
self.max_height = Some(height.into());
self
}
pub fn empty_text(mut self, text: &str) -> Self {
self.words.empty = Arc::from(text);
self
}
pub fn select_all_label(mut self, label: &str) -> Self {
self.words.select_all = Arc::from(label);
self
}
pub fn select_row_label(mut self, label: &str) -> Self {
self.words.select_row = Arc::from(label);
self
}
pub fn count_text(mut self, text: impl Fn(TableCount) -> String + Send + Sync + 'static) -> Self {
self.words.count = Some(Arc::new(text));
self
}
pub fn resizable(mut self, resizable: bool) -> Self {
self.resizable = resizable;
self
}
pub fn on_column_resize(mut self, handler: impl Fn(&str, f32) + Send + Sync + 'static) -> Self {
self.on_column_resize.push(Arc::new(handler));
self
}
pub fn on_column_resize_end(mut self, handler: impl Fn(&str, f32) + Send + Sync + 'static) -> Self {
self.on_column_resize_end.push(Arc::new(handler));
self
}
pub fn resize_label(mut self, label: impl Fn(&str) -> String + Send + Sync + 'static) -> Self {
self.words.resize = Some(Arc::new(label));
self
}
pub fn empty(mut self, empty: impl Into<Element>) -> Self {
self.empty = Some(empty.into());
self
}
pub fn loading(mut self, loading: bool) -> Self {
self.loading = loading;
self
}
pub fn loading_rows(mut self, rows: usize) -> Self {
self.loading_rows = rows.max(1);
self
}
pub fn pagination(mut self, pagination: impl Into<Element>) -> Self {
self.pagination = Some(pagination.into());
self.count = true;
self
}
pub fn count(mut self, count: bool) -> Self {
self.count = count;
self
}
pub fn total(mut self, total: usize) -> Self {
self.total = Some(total);
self
}
pub fn label(mut self, label: &str) -> Self {
self.label = Some(Arc::from(label));
self
}
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = disabled;
self
}
pub fn state(mut self, state: impl Into<Name>, on: bool) -> Self {
let state = state.into();
self.states.retain(|held| *held != state);
if on {
self.states.push(state);
}
self
}
pub fn style(mut self, part: impl Into<Name>, style: impl FnOnce(super::PartStyle) -> super::PartStyle) -> Self {
self.rules = self.rules.base(part, style);
self
}
pub fn rules(mut self, rules: &Recipe) -> Self {
self.rules = self.rules.extend(rules);
self
}
pub fn force(mut self, interaction: Option<Interaction>) -> Self {
self.forced = interaction;
self
}
pub fn id(mut self, id: impl Into<Arc<str>>) -> Self {
self.id = Some(id.into());
self
}
pub fn key(mut self, key: impl Into<Arc<str>>) -> Self {
self.key = Some(key.into());
self
}
pub fn build(mut self, theme: &Theme) -> Element {
self.find_grouping();
let tracks = ColumnTracks::new(self.track_specs(theme));
let view = self.view(theme, tracks, None);
match theme.renderer::<Table<R, K>>() {
Some(renderer) => renderer(view),
None => view.render(),
}
}
pub fn mount(self, ctx: &mut Ctx) -> Element {
let key = self.key.clone();
let props = TableProps {
table: Arc::new(Mutex::new(self)),
};
match key {
Some(key) => ctx.mount_keyed::<TableHost<R, K>>(&key, props),
None => ctx.mount::<TableHost<R, K>>(props),
}
}
fn selectable(&self) -> bool {
self.select.is_some()
}
pub(super) fn as_grid(mut self) -> Self {
self.grid = true;
self.resizable = true;
self.column_menu = true;
self
}
pub(super) fn column_layout(mut self, layout: Option<ColumnLayout>, write: LayoutWrite) -> Self {
self.column_layout = layout;
self.write_column_layout = Some(write);
self
}
pub(super) fn add_on_column_layout_change(mut self, handler: impl Fn(&ColumnLayout) + Send + Sync + 'static) -> Self {
self.on_column_layout_change.push(Arc::new(handler));
self
}
pub(super) fn set_group_by(mut self, columns: Vec<Arc<str>>) -> Self {
self.group_by = columns;
self
}
pub(super) fn set_open_groups(mut self, open: Vec<GroupKey>, write: OpenWrite) -> Self {
self.open_groups = open;
self.write_open = Some(write);
self
}
pub(super) fn add_on_open_change(mut self, handler: impl Fn(&GroupKey, bool) + Send + Sync + 'static) -> Self {
self.on_open_change.push(Arc::new(handler));
self
}
pub(super) fn set_tree(mut self, parent: impl Fn(&R) -> Option<K> + Send + Sync + 'static) -> Self {
self.tree_parent = Some(Arc::new(parent));
self
}
pub(super) fn set_expanded(mut self, open: Vec<K>, write: KeysWrite<K>) -> Self {
self.expanded = open;
self.write_expanded = Some(write);
self
}
pub(super) fn add_on_expanded_change(mut self, handler: impl Fn(&K, bool) + Send + Sync + 'static) -> Self {
self.on_expanded_change.push(Arc::new(handler));
self
}
pub(super) fn set_detail(mut self, detail: impl Fn(&R) -> Element + Send + Sync + 'static) -> Self {
self.detail = Some(Arc::new(detail));
self
}
pub(super) fn set_details_open(mut self, open: Vec<K>, write: KeysWrite<K>) -> Self {
self.details_open = open;
self.write_details = Some(write);
self
}
pub(super) fn add_on_detail_change(mut self, handler: impl Fn(&K, bool) + Send + Sync + 'static) -> Self {
self.on_detail_change.push(Arc::new(handler));
self
}
fn key_toggle(
now: &[K],
write: &Option<KeysWrite<K>>,
heard: &[KeyOpenHeard<K>],
) -> Arc<dyn Fn(&K, bool) + Send + Sync> {
let (now, write, heard) = (now.to_vec(), write.clone(), heard.to_vec());
Arc::new(move |key: &K, open: bool| {
if now.contains(key) == open {
return;
}
let mut next: Vec<K> = now.iter().filter(|held| *held != key).cloned().collect();
if open {
next.push(key.clone());
}
if let Some(write) = &write {
write(next);
}
for handler in &heard {
handler(key, open);
}
})
}
fn tree_lines(&self, parent_of: &ParentFn<R, K>, filtered: Option<Vec<usize>>) -> Lines {
let count = self.rows.len();
let keys: Vec<K> = self
.rows
.iter()
.enumerate()
.map(|(index, row)| (self.key_of)(index, row))
.collect();
let index_of: HashMap<&K, usize> = keys.iter().enumerate().map(|(index, key)| (key, index)).collect();
let parent: Vec<Option<usize>> = self
.rows
.iter()
.enumerate()
.map(|(index, row)| {
parent_of(row)
.and_then(|key| index_of.get(&key).copied())
.filter(|at| *at != index)
})
.collect();
let mut shown = vec![filtered.is_none(); count];
if let Some(kept) = &filtered {
for &index in kept {
let mut at = Some(index);
while let Some(index) = at.filter(|index| !shown[*index]) {
shown[index] = true;
at = parent[index];
}
}
}
let mut children: Vec<Vec<usize>> = vec![Vec::new(); count];
let mut tops = Vec::new();
for index in (0..count).filter(|index| shown[*index]) {
match parent[index] {
Some(above) if shown[above] => children[above].push(index),
_ => tops.push(index),
}
}
let open: HashSet<&K> = self.expanded.iter().collect();
let mut order = Vec::new();
let mut tree = groups::Tree::default();
let mut seen = vec![false; count];
let mut stack: Vec<(usize, u32, Option<usize>)> = tops.iter().rev().map(|index| (*index, 0, None)).collect();
while let Some((index, level, above)) = stack.pop() {
if std::mem::replace(&mut seen[index], true) {
continue;
}
let rank = order.len();
order.push(index);
let branch = !children[index].is_empty();
let is_open = branch && open.contains(&keys[index]);
tree.level.push(level);
tree.parent.push(above);
tree.branch.push(branch);
tree.open.push(is_open);
if is_open {
stack.extend(
children[index]
.iter()
.rev()
.map(|child| (*child, level + 1, Some(rank))),
);
}
}
Lines::tree(order, tree)
}
fn find_grouping(&mut self) {
self.grouping = self
.group_by
.iter()
.filter_map(|id| self.columns.iter().find(|column| &column.id == id).cloned())
.collect();
}
fn tall(&self) -> bool {
self.detail.is_some() || self.columns.iter().any(|column| column.wrap)
}
fn filtered(&self) -> Option<Vec<usize>> {
if self.source.is_some() {
return None;
}
let tests: Vec<Test<R>> = self
.filters
.iter()
.filter_map(|(id, filter)| {
let column = self.columns.iter().find(|column| &*column.id == id)?;
let text = match &column.content {
Content::Text(text) => Some(text.clone()),
_ => None,
};
Test::new(column.filter.as_ref()?, text, filter)
})
.collect();
if tests.is_empty() {
return None;
}
Some(
self
.rows
.iter()
.enumerate()
.filter(|(_, row)| tests.iter().all(|test| test.passes(row)))
.map(|(index, _)| index)
.collect(),
)
}
fn lines(&self) -> Lines {
let passed = self.filtered().map(Arc::new);
let mut lines = self.laid_out(passed.as_deref().cloned());
lines.passed = passed;
if self.detail.is_some() && !self.details_open.is_empty() {
let open: HashSet<&K> = self.details_open.iter().collect();
let opened: Vec<bool> = (0..lines.ranks())
.map(|rank| {
lines
.row_of_rank(rank)
.is_some_and(|index| open.contains(&(self.key_of)(index, &self.rows[index])))
})
.collect();
lines = lines.with_details(|rank| opened[rank]);
}
lines
}
fn laid_out(&self, filtered: Option<Vec<usize>>) -> Lines {
if let Some(parent) = self.tree_parent.as_ref().filter(|_| self.grouping.is_empty()) {
return self.tree_lines(parent, filtered);
}
if self.grouping.is_empty() {
return match filtered {
Some(order) => Lines::rows(Arc::new(order)),
None => Lines::flat(self.rows.len()),
};
}
let ids: Vec<Arc<str>> = self.grouping.iter().map(|column| column.id.clone()).collect();
let open: HashSet<&GroupKey> = self.open_groups.iter().collect();
Lines::grouped(
filtered.unwrap_or_else(|| (0..self.rows.len()).collect()),
&ids,
self.summarized(),
&|row, level| column_text(&self.grouping[level], &self.rows[row]),
&|key| open.contains(key),
)
}
fn summarized(&self) -> bool {
self.grid && self.columns.iter().any(|column| column.summary.is_some())
}
fn group_toggle(&self) -> Arc<dyn Fn(&GroupKey, bool) + Send + Sync> {
let (now, write, heard) = (
self.open_groups.clone(),
self.write_open.clone(),
self.on_open_change.clone(),
);
Arc::new(move |key: &GroupKey, open: bool| {
if now.contains(key) == open {
return;
}
let mut next: Vec<GroupKey> = now.iter().filter(|held| *held != key).cloned().collect();
if open {
next.push(key.clone());
}
if let Some(write) = &write {
write(next);
}
for handler in &heard {
handler(key, open);
}
})
}
pub(super) fn set_column_menu(mut self, menu: bool) -> Self {
self.column_menu = menu;
self
}
fn layout_changer(&self) -> Option<LayoutWrite> {
let (now, _) = &**self.arranged.as_ref()?;
let now = now.clone();
let (write, heard) = (self.write_column_layout.clone(), self.on_column_layout_change.clone());
Some(Arc::new(move |next: ColumnLayout| {
if next == now {
return;
}
if let Some(write) = &write {
write(next.clone());
}
for handler in &heard {
handler(&next);
}
}))
}
pub(super) fn set_read_only(mut self, read_only: bool) -> Self {
self.read_only = read_only;
self
}
pub(super) fn add_on_edit(mut self, handler: impl Fn(&CellEdit<K>) -> bool + Send + Sync + 'static) -> Self {
self.on_edit.push(Arc::new(handler));
self
}
pub(super) fn cell_selection(mut self, range: Option<CellRange<K>>, write: RangeWrite<K>) -> Self {
self.cell_range = range;
self.write_cell_range = Some(write);
self
}
pub(super) fn add_on_cell_selection_change(
mut self,
handler: impl Fn(Option<&CellRange<K>>) + Send + Sync + 'static,
) -> Self {
self.on_cell_selection_change.push(Arc::new(handler));
self
}
fn with_checkboxes(&self) -> bool {
self.selectable() && self.checkboxes
}
pub(super) fn set_column_menu_labels(mut self, labels: ColumnMenuLabels) -> Self {
self.words.menu = Arc::new(labels);
self
}
pub(super) fn set_menu_trigger_label(mut self, label: impl Fn(&str) -> String + Send + Sync + 'static) -> Self {
self.words.menu_trigger = Some(Arc::new(label));
self
}
pub(super) fn set_group_label(mut self, label: impl Fn(&str, &str, usize) -> String + Send + Sync + 'static) -> Self {
self.words.group = Some(Arc::new(label));
self
}
pub(super) fn set_summary_labels(mut self, labels: SummaryLabels) -> Self {
self.words.summary = Arc::new(labels);
self
}
pub(super) fn set_row_numbers_label(mut self, label: &str) -> Self {
self.words.numbers = Arc::from(label);
self
}
pub(super) fn set_row_numbers(mut self, numbers: bool) -> Self {
self.row_numbers = numbers;
self
}
fn numbered(&self) -> bool {
self.grid && self.row_numbers
}
fn number_track(&self, geometry: Geometry) -> f32 {
if !self.numbered() {
return 0.0;
}
let digits = self.rows.len().max(1).to_string().len().max(2);
geometry.padding_start + digits as f32 * 8.0 + geometry.gap
}
fn lead_tracks(&self) -> usize {
usize::from(self.numbered()) + usize::from(self.with_checkboxes())
}
fn case(&self) -> Case {
let mut case = Case::new()
.breakpoint(super::current_breakpoint())
.state(TableState::Selectable, self.with_checkboxes())
.state(TableState::Footer, self.count || self.pagination.is_some())
.state(TableState::Disabled, self.disabled);
case.states.extend(self.states.iter().copied());
if let Some(density) = &self.density {
case = case.density(density.clone());
}
case
}
fn resolve(&self, theme: &Theme, case: &Case) -> ResolvedRecipe {
theme.resolve::<Table<R, K>>(case, Some(&self.rules))
}
fn track_specs(&self, theme: &Theme) -> Vec<TrackSpec> {
let geometry = Geometry::of(&self.resolve(theme, &self.case()));
let count = self.columns.len();
let mut specs = Vec::with_capacity(count + 2);
let numbered = self.numbered();
if numbered {
specs.push(TrackSpec::px(self.number_track(geometry)));
}
if self.with_checkboxes() {
let lead = if self.pins().0 > 0 && !numbered {
geometry.padding_start
} else {
0.0
};
specs.push(TrackSpec::px(geometry.select + geometry.gap + lead));
}
for (index, column) in self.columns.iter().enumerate() {
let mut extra = if index + 1 < count { geometry.gap } else { 0.0 };
let (start, end) = self.pins();
if index == 0 && start > 0 && !self.with_checkboxes() && !numbered {
extra += geometry.padding_start;
}
if index + 1 == count && end > 0 {
extra += geometry.padding_end;
}
let mut spec = column.track;
if let Some(width) = self.resized.get(&column.id) {
spec.width = TrackWidth::Px(*width);
}
if let TrackWidth::Px(px) = spec.width {
spec.width = TrackWidth::Px(px + extra);
}
if spec.min > 0.0 {
spec.min += extra;
}
if spec.max.is_finite() {
spec.max += extra;
}
specs.push(spec);
}
specs
}
fn pins(&self) -> (usize, usize) {
let start = self
.columns
.iter()
.take_while(|column| column.pin == ColumnPin::Start)
.count();
let end = self.columns[start..]
.iter()
.rev()
.take_while(|column| column.pin == ColumnPin::End)
.count();
(start, end)
}
fn view(&self, theme: &Theme, tracks: ColumnTracks, window: Option<Window>) -> TableView {
let case = self.case();
let recipe = self.resolve(theme, &case).owned_by(self.id.as_ref());
let geometry = Geometry::of(&recipe);
let selectable = self.selectable();
let checkboxes = self.with_checkboxes();
let (start_pins, end_pins) = self.pins();
let numbered = self.numbered();
let sticky = start_pins > 0 || numbered;
let number_lead = self.number_track(geometry);
let footer = self.count || self.pagination.is_some();
let count = self.rows.len();
let mut row_recipes: HashMap<(bool, bool), ResolvedRecipe> = HashMap::new();
let mut row_recipe = |selected: bool, last: bool| {
row_recipes
.entry((selected, last))
.or_insert_with(|| {
let case = case
.clone()
.state(TableState::Selected, selected)
.state(TableState::Last, last)
.state(TableState::Pinned, sticky);
self.resolve(theme, &case).owned_like(&recipe)
})
.clone()
};
let mut cell_recipes: HashMap<(usize, bool, Option<RangeMark>), ResolvedRecipe> = HashMap::new();
let mut cell_recipe = |column: usize, selected: bool, mark: Option<RangeMark>| {
cell_recipes
.entry((column, selected, mark))
.or_insert_with(|| {
let pinned = column < start_pins || column + end_pins >= self.columns.len();
let marked = |side: fn(&RangeMark) -> bool| mark.as_ref().is_some_and(side);
let mut case = case
.clone()
.state(TableState::Selected, selected)
.state(TableState::Pinned, pinned)
.state(TableState::InRange, marked(|mark| mark.fill))
.state(TableState::RangeTop, marked(|mark| mark.top))
.state(TableState::RangeBottom, marked(|mark| mark.bottom))
.state(TableState::RangeStart, marked(|mark| mark.start))
.state(TableState::RangeEnd, marked(|mark| mark.end));
case.states.extend(self.columns[column].kinds.iter().copied());
self.resolve(theme, &case).owned_like(&recipe)
})
.clone()
};
let lines: Arc<Lines> = match window.as_ref() {
Some(window) => window.lines.clone(),
None => Arc::new(self.lines()),
};
let key_index = match window.as_ref().and_then(|window| window.host.as_ref()) {
Some(host) => host.state.key_index.lock().for_rows::<R, K>(&self.rows),
None => Arc::default(),
};
let keys = {
let (rows, key_of) = (self.rows.clone(), self.key_of.clone());
RowKeys::new(
Arc::new(move |index: usize| key_of(index, &rows[index])),
self.rows.len(),
lines.clone(),
key_index,
)
};
if let Some((key, request)) = &self.reveal
&& let Some(host) = window.as_ref().and_then(|window| window.host.as_ref())
&& *host.state.revealed.lock() != Some(*request)
&& host.state.metrics.lock().row_height > 0.0
{
*host.state.revealed.lock() = Some(*request);
if let Some(position) = keys.rank_of(key).and_then(|rank| lines.position_of(rank)) {
host.state.reveal(position);
}
}
let grouped = !lines.groups.is_empty() || !self.grouping.is_empty() || lines.tree.is_some();
let ranked = keys.clone();
let model = Arc::new(Model {
keys: keys.clone(),
selected: self.selected.clone(),
select: self.select.clone(),
on_selection_change: self.on_selection_change.clone(),
on_row_click: self.on_row_click.clone(),
on_row_activate: self.on_row_activate.clone(),
});
let lead_inset = number_lead
+ if checkboxes {
geometry.select + geometry.gap + if numbered { 0.0 } else { geometry.padding_start }
} else {
0.0
};
let track_widths = tracks.widths(None, 0.0);
let lead_tracks = self.lead_tracks();
let width_of = |column: usize| track_widths.get(column + lead_tracks).copied().unwrap_or(0.0);
let columns_count = self.columns.len();
let sticky_of = |column: usize| -> Option<Sticky> {
if column < start_pins {
Some(Sticky::left(lead_inset + (0..column).map(width_of).sum::<f32>()))
} else if column + end_pins >= columns_count {
Some(Sticky::right((column + 1..columns_count).map(width_of).sum::<f32>()))
} else {
None
}
};
let trail_of = |column: usize| {
if column + 1 == columns_count && end_pins > 0 {
geometry.padding_end
} else {
0.0
}
};
let table_fill = recipe.part(TablePart::Root).rest().background;
let header_fill = recipe.part(TablePart::Header).rest().background;
let cell_ends = |column: usize| column + 1 == self.columns.len();
let columns_built = window.as_ref().and_then(|window| window.columns.clone());
let built = |column: usize| {
columns_built
.as_ref()
.is_none_or(|built| built.get(column).copied().unwrap_or(true))
};
let grid_host = window
.as_ref()
.filter(|_| self.grid)
.and_then(|window| window.host.as_ref())
.map(|host| host.state.clone());
let ids: Vec<Arc<str>> = self.columns.iter().map(|column| column.id.clone()).collect();
let span = grid_host
.as_ref()
.and(self.cell_range.as_ref())
.and_then(|range| span_of(range, &ranked, &ids));
let grid_model: Option<Arc<dyn GridCells>> = grid_host.as_ref().map(|host| {
Arc::new(GridModel {
host: host.clone(),
span,
range: self.cell_range.clone(),
write_range: self.write_cell_range.clone(),
on_range: self.on_cell_selection_change.clone(),
texts: Arc::new(
self
.columns
.iter()
.map(|column| match &column.content {
Content::Text(text) => Some(text.clone()),
_ => None,
})
.collect(),
),
titles: Arc::new(self.columns.iter().map(|column| column.title.clone()).collect()),
rows: self.rows.clone(),
keys: ranked.clone(),
lines: lines.clone(),
editors: Arc::new(
self
.columns
.iter()
.map(|column| (column.id.clone(), column.editor.clone()))
.collect(),
),
on_edit: self.on_edit.clone(),
model: model.clone(),
read_only: self.read_only,
}) as Arc<dyn GridCells>
});
let editing = grid_host.as_ref().and_then(|host| *host.editing.lock());
let focused_column = grid_host
.as_ref()
.and_then(|host| *host.focused_column.lock())
.unwrap_or(0);
let held_now: HashSet<&K> = self.selected.iter().collect();
let shown: Vec<usize> = match &window {
_ if self.loading => Vec::new(),
Some(window) => window.indices.clone(),
None => (0..lines.len()).collect(),
};
let entry = window
.as_ref()
.and_then(|window| window.focused.filter(|position| shown.contains(position)))
.or_else(|| {
shown.iter().copied().find(|position| {
lines
.rank_at(*position)
.and_then(|rank| keys.get(rank))
.is_some_and(|key| held_now.contains(&key))
})
})
.or_else(|| shown.first().copied());
let line_count = lines.len();
let id_of = |what: &str| self.id.as_ref().map(|id| Arc::<str>::from(format!("{id}-{what}")));
let toggle = self.group_toggle();
if let Some(host) = window.as_ref().and_then(|window| window.host.as_ref()) {
let (toggle, lines) = (toggle.clone(), lines.clone());
*host.state.group_toggle.lock() = Some(Arc::new(move |group: usize, open: bool| {
if let Some(line) = lines.groups.get(group) {
toggle(&line.key, open);
}
}));
}
let group_recipe = row_recipe(false, false);
let indent = geometry.padding_start;
let groups: Vec<TableGroup> = shown
.iter()
.filter_map(|&position| {
let Some(Shown::Group(group)) = lines.line(position) else {
return None;
};
let line = &lines.groups[group];
let title = self
.grouping
.iter()
.find(|column| column.id == line.column)
.map_or_else(|| line.column.clone(), |column| column.title.clone());
let (toggle, key) = (toggle.clone(), line.key.clone());
let id = id_of(&format!("group-{position}"));
Some(TableGroup {
position,
key: line.key.clone(),
title: title.clone(),
count: line.count,
open: line.open,
entry: entry == Some(position),
recipe: group_recipe.item(id.as_ref(), TablePart::GroupRow),
toggle: Arc::new(move |open| toggle(&key, open)),
element: window
.as_ref()
.and_then(|window| window.refs.get(&position).cloned())
.unwrap_or_default(),
grid: grid_model.is_some(),
indent: indent + (line.key.level() - 1) as f32 * 20.0,
name: {
let value = line.key.values.last().map_or("", String::as_str);
match &self.words.group {
Some(label) => label(&title, value, line.count),
None => {
let locale = crate::ui::current_locale();
format!("{title}: {value}, {}", locale.count(&locale.data.rows, line.count))
}
}
},
id,
})
})
.collect();
let summary_recipe = row_recipe(false, false);
let summary_fill = summary_recipe.part(TablePart::Summary).rest().background;
let summary_host = window
.as_ref()
.and_then(|window| window.host.as_ref())
.map(|host| host.state.clone());
let mut held: HashMap<SummaryKey, Arc<Vec<Said>>> = summary_host
.as_ref()
.map(|host| std::mem::take(&mut *host.summaries.lock()))
.unwrap_or_default();
let mut kept: HashMap<SummaryKey, Arc<Vec<Said>>> = HashMap::new();
let summary_columns: Vec<(Arc<str>, Option<SummaryKind>)> = self
.columns
.iter()
.filter_map(|column| {
let kind = match column.summary.as_ref()? {
Summary::Kind(kind) => Some(*kind),
Summary::Text(_) => None,
};
Some((column.id.clone(), kind))
})
.collect();
let grouping_ids: Vec<Arc<str>> = self.grouping.iter().map(|column| column.id.clone()).collect();
let rows_seen = (Arc::as_ptr(&self.rows) as *const () as usize, self.rows.len());
let filters_seen = self.filters.to_text();
let mut values_of = |group: Option<&GroupKey>, places: Option<&[usize]>| -> Arc<Vec<Said>> {
let key = SummaryKey {
rows: rows_seen,
columns: summary_columns.clone(),
grouping: grouping_ids.clone(),
group: group.map(|group| group.values.clone()),
filters: filters_seen.clone(),
};
let values = held
.remove(&key)
.or_else(|| kept.get(&key).cloned())
.unwrap_or_else(|| {
let rows: Vec<&R> = match places {
Some(places) => places.iter().map(|index| &self.rows[*index]).collect(),
None => match &lines.passed {
Some(passed) => passed.iter().map(|index| &self.rows[*index]).collect(),
None => self.rows.iter().collect(),
},
};
Arc::new(self.columns.iter().map(|column| summarize(column, &rows)).collect())
});
kept.insert(key, values.clone());
values
};
let summary_of = |values: &[Said], id: Option<Arc<str>>, position: Option<usize>| {
let summary_recipe = summary_recipe.item(id.as_ref(), TablePart::Summary);
TableSummary {
position,
cells: self
.columns
.iter()
.enumerate()
.filter(|(column_index, _)| built(*column_index))
.map(|(column_index, column)| TableCell {
column: column_index,
content: summary_content(&summary_recipe, &values[column_index], &self.words.summary),
grid: None,
part: summary_recipe.part(TablePart::Cell).keyed(&column.id),
align: column.align,
pinned: sticky_of(column_index),
fill: sticky_of(column_index).and(summary_fill.clone()),
controls: false,
last: cell_ends(column_index),
gap: geometry.gap,
lead: if column_index == 0 && sticky && !checkboxes && !numbered {
geometry.padding_start
} else {
0.0
},
trail: trail_of(column_index),
})
.collect(),
recipe: summary_recipe.clone(),
tracks: tracks.clone(),
columns_built: columns_built.clone(),
geometry,
checkbox: checkboxes,
number_lead,
pinned_start: sticky,
pinned_end: end_pins > 0,
fill: summary_fill.clone(),
name: self.words.summary.row.clone(),
id,
}
};
if self.summarized() {
for line in lines.groups.iter().filter(|line| line.open) {
values_of(Some(&line.key), Some(&line.rows));
}
}
let summaries: Vec<TableSummary> = shown
.iter()
.filter_map(|&position| {
let Some(Shown::Summary(group)) = lines.line(position) else {
return None;
};
let line = &lines.groups[group];
let values = values_of(Some(&line.key), Some(&line.rows));
Some(summary_of(
&values,
id_of(&format!("summary-{position}")),
Some(position),
))
})
.collect();
let summary = (self.summarized() && count > 0 && !self.loading).then(|| {
let values = values_of(None, None);
summary_of(&values, id_of("summary"), None)
});
drop(values_of);
if let Some(host) = &summary_host {
*host.summaries.lock() = kept;
}
let tall = self.tall();
let searched = window.as_ref().and_then(|window| window.search.clone());
let marked = |rank: usize, column: usize, text: components::Text, shown: &str| -> components::Text {
let Some((found, current)) = &searched else {
return text;
};
let (ranges, now) = SearchState::in_cell(found, *current, rank, column);
if ranges.is_empty() {
return text;
}
text.highlights(
super::highlight::Highlight::new(shown)
.marks(ranges)
.current(now)
.fills_in(theme),
)
};
let by_rank = |toggle: Arc<dyn Fn(&K, bool) + Send + Sync>| {
let keys = keys.clone();
Arc::new(move |rank: usize, open: bool| {
if let Some(key) = keys.get(rank) {
toggle(&key, open);
}
}) as Arc<dyn Fn(usize, bool) + Send + Sync>
};
let tree_toggle = lines.tree.as_ref().map(|_| {
by_rank(Self::key_toggle(
&self.expanded,
&self.write_expanded,
&self.on_expanded_change,
))
});
let detail_toggle = self.detail.as_ref().map(|_| {
by_rank(Self::key_toggle(
&self.details_open,
&self.write_details,
&self.on_detail_change,
))
});
if let Some(host) = window.as_ref().and_then(|window| window.host.as_ref()) {
*host.state.tree_toggle.lock() = tree_toggle.clone();
*host.state.detail_toggle.lock() = detail_toggle.clone();
}
let details_now: HashSet<&K> = self.details_open.iter().collect();
let opener = |rank: usize, index: usize| -> Option<(u32, Option<bool>, Arc<dyn Fn(usize, bool) + Send + Sync>)> {
match (&lines.tree, &tree_toggle, &detail_toggle) {
(Some(tree), Some(toggle), _) => Some((
tree.level.get(rank).copied().unwrap_or(0),
tree.branch.get(rank).copied().unwrap_or(false).then(|| tree.open[rank]),
toggle.clone(),
)),
(None, _, Some(toggle)) => Some((0, Some(details_now.contains(&keys.at(index))), toggle.clone())),
_ => None,
}
};
let toggle_part = recipe.part(TablePart::TreeToggle).forced(self.forced);
let rows = shown
.iter()
.filter_map(|&position| {
let rank = lines.rank_at(position)?;
Some((position, rank, lines.row_of_rank(rank)?))
})
.map(|(position, rank, index)| {
let row = &self.rows[index];
let slot = self.slots.as_ref().map(|(slots, _)| slots(index));
let first_built = (0..self.columns.len()).find(|column| built(*column));
let selected = selectable && held_now.contains(&keys.at(index));
let last = position + 1 == line_count && !footer;
let row_id = id_of(&format!("row-{index}"));
let recipe = row_recipe(selected, last).item(row_id.as_ref(), TablePart::Row);
let stuck_fill: BackgroundColor = recipe
.part(TablePart::Row)
.rest()
.background
.or_else(|| table_fill.clone())
.unwrap_or_else(|| PaletteColor::Background.into());
let cells = self
.columns
.iter()
.enumerate()
.filter(|(column_index, _)| built(*column_index))
.map(|(column_index, column)| {
let mark = span.and_then(|span| span.mark(rank, column_index));
let part = cell_recipe(column_index, selected, mark)
.part(TablePart::Cell)
.keyed(format!("{index}-{column_index}"))
.forced(self.forced);
let content = match (&column.content, column.editor.as_ref().map(|editor| &editor.kind)) {
(Content::Text(text), _) if column.wrap => marked(rank, column_index, part.text(&text(row)), &text(row))
.flex_full(1.0, 1.0, Some(0.0))
.min_width(Dimension::Px(0.0))
.into(),
(Content::Text(text), _) => marked(rank, column_index, part.text(&text(row)), &text(row))
.nowrap()
.text_overflow(crate::node::node_kind::TextOverflow::Elipsis)
.flex_full(0.0, 1.0, None)
.min_width(Dimension::Px(0.0))
.into(),
(Content::Element(cell), _) => cell(row),
(Content::Nothing, Some(EditorKind::Checkbox(checked))) => Row::new()
.inert(true)
.child(
Checkbox::new(&column.title)
.label_hidden(true)
.checked(checked(row))
.build(theme),
)
.into(),
(Content::Nothing, _) => Row::new().into(),
};
let content = match slot {
Some(Slot::Pending) => Skeleton::block(Length::Fill, 12.0).build(theme),
Some(Slot::Failed) if Some(column_index) == first_built => {
let retry = self.slots.as_ref().map(|(_, retry)| retry.clone());
let mut said = Row::new()
.spacing(8.0)
.align_items(Alignment::Center)
.child(part.text(&self.words.source.failed).nowrap());
if let Some(retry) = retry {
said = said.child(
super::button::Button::new(&self.words.source.retry)
.variant(super::button::ButtonVariant::Ghost)
.size(super::button::ButtonSize::Sm)
.on_click(move |_| retry(index))
.build(theme),
);
}
said.into()
}
Some(Slot::Failed) => Row::new().into(),
_ => content,
};
let content = match opener(rank, index).filter(|_| column_index == 0) {
Some((level, open, toggle)) => tree_cell(
&toggle_part.clone().keyed(index),
level,
open,
rank,
toggle,
content,
column.wrap,
),
None => content,
};
let grid = grid_model.as_ref().map(|grid| {
let editable = !self.read_only && !self.disabled && column.editor.is_some();
let being_edited = editing.filter(|editing| (editing.row, editing.column) == (rank, column_index));
let editor = being_edited.and_then(|editing| {
let host = grid_host.as_ref()?;
let editor = column.editor.as_ref()?;
let ref_ = window.as_ref()?.editor_ref.clone();
let part = recipe.part(TablePart::Editor);
let built: Element = match &editor.kind {
EditorKind::Text(_) => Input::new(host.draft_text.clone())
.id(id_of("editor").unwrap_or_else(|| Arc::from("editor")))
.size(InputSize::Sm)
.full_width(true)
.invalid(editing.refused)
.label(&column.title)
.build(theme),
EditorKind::Number(_) => NumberInput::optional(host.draft_number.clone())
.id(id_of("editor").unwrap_or_else(|| Arc::from("editor")))
.size(InputSize::Sm)
.full_width(true)
.invalid(editing.refused)
.label(&column.title)
.build(theme),
EditorKind::Choice(choices, _) => {
let committing = grid.clone();
Select::new(
host.draft_choice.clone(),
choices
.iter()
.enumerate()
.map(|(place, choice)| crate::components::SelectOption::new(place, choice.clone())),
)
.id(id_of("editor").unwrap_or_else(|| Arc::from("editor")))
.size(InputSize::Sm)
.full_width(true)
.invalid(editing.refused)
.label(&column.title)
.on_change(move |_: &usize| committing.commit(GridStep::Stay))
.build(theme)
}
EditorKind::Checkbox(_) => return None,
};
let choice = matches!(editor.kind, EditorKind::Choice(..));
Some(editor_in(&part, built, choice, grid.clone(), ref_).into())
});
GridCell {
row: rank,
position,
editable,
selected: span.is_some_and(|span| span.anchor != span.extent && span.contains(rank, column_index)),
editor,
entry: entry == Some(position)
&& column_index == focused_column.min(self.columns.len().saturating_sub(1)),
column_index: column_index + 1 + lead_tracks,
checkbox: column.editor.as_ref().is_some_and(CellEditor::is_checkbox),
element: window
.as_ref()
.and_then(|window| window.cell_refs.get(&(rank, column_index)).cloned())
.unwrap_or_default(),
grid: grid.clone(),
id: id_of(&format!("cell-{index}-{column_index}")),
}
});
TableCell {
column: column_index,
content,
grid,
part,
align: column.align,
pinned: sticky_of(column_index),
fill: sticky_of(column_index)
.filter(|_| !mark.is_some_and(|mark| mark.fill))
.map(|_| stuck_fill.clone()),
controls: column.controls,
last: cell_ends(column_index),
gap: geometry.gap,
lead: if column_index == 0 && sticky && !checkboxes && !numbered {
geometry.padding_start
} else {
0.0
},
trail: trail_of(column_index),
}
})
.collect();
let name = self.columns.first().and_then(|column| match &column.content {
Content::Text(text) => Some(Arc::<str>::from(text(row))),
_ => None,
});
TableRow {
index,
position,
tree: lines.tree.as_ref().map(|tree| {
(
tree.level.get(rank).copied().unwrap_or(0) + 1,
tree.branch.get(rank).copied().unwrap_or(false).then(|| tree.open[rank]),
)
}),
number: numbered.then_some(rank + 1),
number_lead,
selected,
disabled: self.disabled,
name,
cells,
checkbox: checkboxes,
pinned_start: sticky,
pinned_end: end_pins > 0,
lead_fill: sticky.then(|| stuck_fill.clone()),
entry: entry == Some(position),
grows: tall,
recipe,
forced: self.forced,
tracks: tracks.clone(),
columns_built: columns_built.clone(),
grid: grid_model.is_some(),
geometry,
actions: (!self.disabled).then(|| model.actions(index)),
select_label: self.words.select_row.clone(),
host: window.as_ref().and_then(|window| window.host.clone()),
element: window
.as_ref()
.and_then(|window| window.refs.get(&position).cloned())
.unwrap_or_default(),
id: row_id,
}
})
.collect();
let view_width = window
.as_ref()
.and_then(|window| window.host.as_ref())
.map_or(0.0, |host| host.state.scroll.viewport_width());
let detail_part = recipe.part(TablePart::Detail).forced(self.forced);
let details: Vec<(usize, Element)> = match &self.detail {
Some(detail) => shown
.iter()
.filter_map(|&position| {
let Some(Shown::Detail(rank)) = lines.line(position) else {
return None;
};
let index = lines.row_of_rank(rank)?;
let mut line = Row::new()
.part(&detail_part)
.align_items(Alignment::Start)
.focus_group(FocusGroup::none())
.key(format!("detail-{index}"))
.child(detail(&self.rows[index]));
if let Some(element) = window.as_ref().and_then(|window| window.refs.get(&position)) {
line = line.ref_element(element.clone());
}
if view_width > 0.0 {
line = line.width(Dimension::Px(view_width)).sticky(Sticky::left(0.0));
}
if let Some(id) = id_of(&format!("detail-{index}")) {
line = line.id(id);
}
Some((position, line.into()))
})
.collect(),
None => Vec::new(),
};
let menu_host = grid_host.as_ref().filter(|_| self.column_menu && !self.disabled);
let change_layout = menu_host.and_then(|_| self.layout_changer());
let open_menu = menu_host.and_then(|host| host.menu_open.lock().clone());
let shown_ids: Arc<Vec<Arc<str>>> = Arc::new(self.columns.iter().map(|column| column.id.clone()).collect());
let header_drop = menu_host.and_then(|host| *host.header_drop.lock());
let drop_of = |column: usize| match header_drop {
Some((from, to)) if to != Some(from) && to != Some(from + 1) => match to {
Some(to) if to == column => Some(DropSide::Before),
None if column + 1 == columns_count && from + 1 != columns_count => Some(DropSide::After),
_ => None,
},
_ => None,
};
let mut header_refs: HashMap<usize, ElementRef> = HashMap::new();
let change_filters = self.filter_changer();
let headers = self
.columns
.iter()
.enumerate()
.filter(|(column_index, _)| built(*column_index))
.map(|(column_index, column)| {
let sort_place = self.sort.iter().position(|sort| sort.column == column.id);
let sorted = sort_place.map(|at| self.sort[at].direction);
let sort_rank = sort_place.filter(|_| self.sort.len() > 1).map(|at| at + 1);
let sortable = column.sortable && !self.disabled;
let open = open_menu.as_deref() == Some(&*column.id);
let drop = drop_of(column_index);
let header_case = case
.clone()
.state(TableState::Sortable, sortable)
.state(TableState::Sorted, sorted.is_some())
.state(TableState::Pinned, sticky_of(column_index).is_some())
.state(TableState::Open, open)
.state(TableState::DropBefore, drop == Some(DropSide::Before))
.state(TableState::DropAfter, drop == Some(DropSide::After));
let sorts = self.write_sort.is_some() || !self.on_sort_change.is_empty();
let filter = grid_host
.clone()
.zip(change_filters.clone())
.and_then(|(host, change)| {
let by = column.filter.as_ref()?;
let open = host.filter_open.get() && host.filters.column.lock().as_deref() == Some(&*column.id);
let shape = match by {
FilterBy::Text => FilterShape::Text,
FilterBy::Set | FilterBy::Values(_) => FilterShape::Set(if open || self.filter_row {
self.values_of(&host, column)
} else {
Arc::default()
}),
FilterBy::Number(_) => FilterShape::Number,
FilterBy::Date(_) => FilterShape::Date,
FilterBy::Bool(_) => FilterShape::Bool,
};
let (now, id) = (self.filters.clone(), column.id.clone());
Some(Arc::new(FilterLink {
id: column.id.clone(),
title: column.title.clone(),
shape,
current: self.filters.get(&column.id).cloned(),
change: Arc::new(move |next: Option<ColumnFilter>| {
change(match next {
Some(filter) => now.clone().with(&id, filter),
None => now.clone().without(&id),
})
}),
open,
host,
labels: self.words.filter.clone(),
}))
});
let export_now: Option<Arc<dyn Fn(ExportScope, ExportFormat) + Send + Sync>> =
grid_model.as_ref().filter(|_| self.export).map(|grid| {
let (grid, handlers, window) = (grid.clone(), self.on_export.clone(), super::theme::current_window());
Arc::new(move |scope: ExportScope, format: ExportFormat| {
let (text, rows) = grid.export(scope, format);
if handlers.is_empty() {
if let Some(window) = &window {
window.request_copy(text);
}
return;
}
let export = GridExport {
format,
scope,
text,
rows,
};
for handler in &handlers {
handler(&export);
}
}) as Arc<dyn Fn(ExportScope, ExportFormat) + Send + Sync>
});
let export_link = export_now
.as_ref()
.zip(grid_model.as_ref())
.map(|(_, grid)| export::ExportLink {
selected: grid.has_selection(),
labels: self.words.export.clone(),
});
if let Some(host) = &grid_host {
*host.export_now.lock() = export_now.clone();
*host.export_selected.lock() = export_link.as_ref().is_some_and(|link| link.selected);
}
let menu = menu_host.zip(change_layout.clone()).map(|(host, change)| {
let element = ElementRef::new();
header_refs.insert(column_index, element);
let (layout, titles) = &**self
.arranged
.as_ref()
.expect("a grid with a layout changer is arranged");
let id = column.id.clone();
let choose: Arc<dyn Fn(MenuChoice) + Send + Sync> = {
let (id, layout, change) = (id.clone(), layout.clone(), change.clone());
let (write_sort, sort_heard, now) =
(self.write_sort.clone(), self.on_sort_change.clone(), self.sort.clone());
let (filter_host, filter_change, filters_now) =
(host.clone(), change_filters.clone(), self.filters.clone());
let export = export_now.clone();
Arc::new(move |choice: MenuChoice| match choice {
MenuChoice::Sort(direction) => {
let next: Vec<TableSort> = match direction {
Some(direction) => vec![TableSort {
column: id.clone(),
direction,
}],
None => now.iter().filter(|sort| sort.column != id).cloned().collect(),
};
if let Some(write) = &write_sort {
write(next.clone());
}
for handler in &sort_heard {
handler(&next);
}
}
MenuChoice::Pin(pin) => change(layout.clone().with_pin(&id, pin)),
MenuChoice::Fit => change(layout.clone().with_fit(&id)),
MenuChoice::Hide => change(layout.clone().with_hidden(&id, true)),
MenuChoice::Toggle(other) => {
let hidden = layout.place(&other).is_some_and(|place| place.hidden);
change(layout.clone().with_hidden(&other, !hidden));
}
MenuChoice::ShowAll => change(layout.clone().with_all_shown()),
MenuChoice::Filter => {
*filter_host.filters.column.lock() = Some(id.clone());
filter_host.filter_open.set(true);
filter_host.rebuild();
}
MenuChoice::ClearFilter => {
if let Some(change) = &filter_change {
change(filters_now.clone().without(&id));
}
}
MenuChoice::ClearAllFilters => {
if let Some(change) = &filter_change {
change(TableFilters::new());
}
}
MenuChoice::Export(scope, format) => {
if let Some(export) = &export {
export(scope, format);
}
}
})
};
let set_open: Arc<dyn Fn(bool) + Send + Sync> = {
let (host, id) = (host.clone(), id.clone());
Arc::new(move |open: bool| {
let mut held = host.menu_open.lock();
if open {
*held = Some(id.clone());
} else if held.as_deref() == Some(&*id) {
*held = None;
}
std::mem::drop(held);
host.rebuild();
})
};
let move_to: Arc<dyn Fn(Option<usize>) + Send + Sync> = {
let (id, layout, change, shown) = (id.clone(), layout.clone(), change.clone(), shown_ids.clone());
Arc::new(move |before: Option<usize>| {
let before = before.and_then(|place| shown.get(place)).map(|id| &**id);
change(layout.clone().with_moved(&id, before));
})
};
let move_by: Arc<dyn Fn(isize) + Send + Sync> = {
let move_to = move_to.clone();
let count = shown_ids.len();
Arc::new(move |by: isize| {
let to = (column_index as isize + by).clamp(0, count as isize - 1) as usize;
if to == column_index {
return;
}
move_to(if to < column_index {
Some(to)
} else {
(to + 1 < count).then_some(to + 1)
});
})
};
Arc::new(ColumnMenuLink {
id: id.clone(),
title: column.title.clone(),
sortable: column.sortable && sorts,
sorted,
pin: column.pin,
can_hide: self.columns.len() > 1,
columns: titles
.iter()
.map(|(id, title)| {
let hidden = layout.place(id).is_some_and(|place| place.hidden);
(id.clone(), title.clone(), !hidden)
})
.collect(),
open,
host: host.clone(),
choose,
set_open,
move_by,
move_to,
place: column_index,
labels: self.words.menu.clone(),
filtering: (column.filter.is_some() && change_filters.is_some())
.then(|| (self.filters.get(&column.id).is_some(), !self.filters.is_empty())),
filter_labels: self.words.filter.clone(),
export: export_link.clone(),
trigger_label: self.words.menu_trigger.as_ref().map_or_else(
|| {
crate::core::fill(
&crate::ui::current_locale().data.column_menu,
&[("column", &column.title)],
)
},
|label| label(&column.title),
),
})
});
let press = (sortable && (self.write_sort.is_some() || !self.on_sort_change.is_empty())).then(|| {
let (write, handlers, now, id) = (
self.write_sort.clone(),
self.on_sort_change.clone(),
self.sort.clone(),
column.id.clone(),
);
Arc::new(move |adding: bool| {
let next = TableSort::after_press(&now, &id, adding);
if let Some(write) = &write {
write(next.clone());
}
for handler in &handlers {
handler(&next);
}
}) as Arc<dyn Fn(bool) + Send + Sync>
});
let resizable = column.resizable.unwrap_or(self.resizable) && !self.disabled;
let resize = window
.as_ref()
.and_then(|window| window.host.clone())
.filter(|_| resizable)
.map(|host| {
let floor = column.track.min.max(LEAST_COLUMN);
Arc::new(ResizeLink {
layout: change_layout.clone().and_then(|change| {
let (layout, _) = &**self.arranged.as_ref()?;
let layout = layout.clone();
Some(
Arc::new(move |id: &str, width: f32| change(layout.clone().with_width(id, width)))
as Arc<dyn Fn(&str, f32) + Send + Sync>,
)
}),
host,
column: column_index,
id: column.id.clone(),
least: floor,
most: column.track.max,
extra: geometry.gap * f32::from(u8::from(column_index + 1 < columns_count))
+ if column_index == 0 && sticky && !checkboxes && !numbered {
geometry.padding_start
} else {
0.0
}
+ trail_of(column_index),
start: Mutex::new(0.0),
on_resize: self.on_column_resize.clone(),
on_resize_end: self.on_column_resize_end.clone(),
label: self.words.resize.as_ref().map_or_else(
|| {
crate::core::fill(
&crate::ui::current_locale().data.resize_column,
&[("column", &column.title)],
)
},
|label| label(&column.title),
),
})
});
TableHeader {
column: column_index,
title: column.title.clone(),
title_hidden: column.title_hidden,
align: column.align,
sortable,
sorted,
sort_rank,
filtered: self.filters.get(&column.id).is_some(),
filter,
pinned: sticky_of(column_index),
last: cell_ends(column_index),
fill: sticky_of(column_index).and(header_fill.clone()),
gap: geometry.gap,
lead: if column_index == 0 && sticky && !checkboxes && !numbered {
geometry.padding_start
} else {
0.0
},
trail: trail_of(column_index),
recipe: self
.resolve(theme, &header_case)
.owned_like(&recipe)
.item(id_of(&format!("header-{}", column.id)).as_ref(), TablePart::HeaderCell),
press,
resize,
element: header_refs.get(&column_index).cloned(),
key: column.id.clone(),
menu,
drop,
id: id_of(&format!("header-{}", column.id)),
}
})
.collect();
if let Some(host) = menu_host {
*host.header_refs.lock() = header_refs;
}
let held: HashSet<&K> = self.selected.iter().collect();
let held_shown = if held.is_empty() {
0
} else {
keys.shown_among(held.iter().copied())
};
let all = keys.len() > 0 && held_shown >= keys.len();
let some = held_shown > 0;
let select_all = (checkboxes && !self.disabled).then(|| {
let model = model.clone();
Arc::new(move || model.select_shown(!all)) as Arc<dyn Fn() + Send + Sync>
});
let total = self.total.unwrap_or(count);
let selected_count = self.selected.len();
let shown_count = lines.passed.as_ref().map_or(total, |passed| passed.len());
let count_text = match &self.words.count {
Some(text) => text(TableCount {
shown: shown_count,
total,
selected: selectable.then_some(selected_count),
}),
None => {
let locale = crate::ui::current_locale();
let words = &locale.data;
let fill = crate::core::fill;
let shown = || {
fill(
locale.form(&words.shown_rows, total),
&[("shown", &shown_count.to_string()), ("count", &total.to_string())],
)
};
if shown_count != total && selectable {
format!(
"{} · {}",
shown(),
locale.count(&locale.common.selected, selected_count)
)
} else if shown_count != total {
shown()
} else if selectable {
fill(
locale.form(&words.selected_rows, total),
&[("selected", &selected_count.to_string()), ("count", &total.to_string())],
)
} else {
locale.count(&words.rows, total)
}
}
};
let body_window = window.as_ref().map(|window| BodyWindow {
row_height: window.row_height,
count: line_count,
heights: window.host.as_ref().map(|host| host.state.heights.clone()),
});
let empty = (count == 0 && !self.loading).then(|| {
self.empty.clone().unwrap_or_else(|| {
EmptyState::new(&self.words.empty)
.icon(icons::INBOX)
.size(EmptyStateSize::Sm)
.build(theme)
})
});
TableView {
filter_row: self.filter_row && grid_host.is_some(),
headers,
rows,
groups,
grouped,
details,
summaries,
summary,
numbered,
number_lead,
numbers_label: self.words.numbers.clone(),
select_rows: (selectable && !self.disabled && numbered).then(|| {
let model = model.clone();
Arc::new(move || model.select_shown(!all)) as Arc<dyn Fn() + Send + Sync>
}),
selectable,
checkboxes,
grid: grid_model.is_some(),
pinned_start: sticky,
pinned_end: end_pins > 0,
lead_inset,
selection: match (all, some) {
(true, _) => Some(true),
(false, true) => None,
(false, false) => Some(false),
},
select_all,
select_all_label: self.words.select_all.clone(),
loading: self.loading,
loading_rows: self.loading_rows,
empty,
footer: footer.then_some(count_text),
pagination: self.pagination.clone(),
label: self.label.clone(),
total,
height: self.height,
max_height: self.max_height,
disabled: self.disabled,
last_row: row_recipe(false, !footer),
recipe,
geometry,
tracks,
columns_built,
window: body_window,
scroll: window.as_ref().map(|window| window.scroll.clone()),
on_scroll: window.as_ref().and_then(|window| window.on_scroll.clone()),
focus_rows: window.as_ref().map(|window| window.rows.clone()),
scroll_ref: window
.as_ref()
.and_then(|window| window.host.as_ref())
.map(|host| host.state.scroll_ref.clone()),
id: self.id.clone(),
key: self.key.clone(),
}
}
}
impl<R: Send + Sync + 'static, K: Clone + Eq + Hash + Send + Sync + 'static> From<Table<R, K>> for Element {
fn from(table: Table<R, K>) -> Self {
table.build(¤t_theme())
}
}
fn column_text<R>(column: &TableColumn<R>, row: &R) -> String {
if let Content::Text(text) = &column.content {
return text(row);
}
match column.editor.as_ref().map(|editor| &editor.kind) {
Some(EditorKind::Text(text)) => text(row),
Some(EditorKind::Number(number)) => number(row).to_string(),
Some(EditorKind::Choice(choices, chosen)) => choices
.get(chosen(row))
.map(|choice| choice.to_string())
.unwrap_or_default(),
Some(EditorKind::Checkbox(checked)) => checked(row).to_string(),
None => String::new(),
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct Geometry {
pub gap: f32,
pub padding_start: f32,
pub padding_end: f32,
pub select: f32,
}
impl Geometry {
fn of(recipe: &ResolvedRecipe) -> Self {
let theme = recipe.theme();
let spacing =
|value: Option<crate::node::SpacingValue>| value.map(|value| value.resolve(&theme.spacing(), 0.0)).unwrap_or(0.0);
let row = recipe.part(TablePart::Row).rest();
let select = recipe.part(TablePart::Select).rest();
Self {
gap: spacing(row.gap),
padding_start: spacing(row.padding_start.or(row.padding_x)),
padding_end: spacing(row.padding_end.or(row.padding_x)),
select: px(select.width, theme).unwrap_or(16.0),
}
}
}
fn px(length: Option<Length>, theme: &Theme) -> Option<f32> {
match length?.resolve(theme)? {
Dimension::Px(px) => Some(px),
_ => None,
}
}
struct Model<K> {
keys: RowKeys<K>,
selected: Vec<K>,
select: Option<Arc<dyn Fn(Vec<K>) + Send + Sync>>,
on_selection_change: Vec<SelectionHeard<K>>,
on_row_click: Vec<Told<K>>,
on_row_activate: Vec<Told<K>>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Pick {
Only,
Toggle,
Range,
}
impl<K: Clone + Eq + Hash + Send + Sync + 'static> Model<K> {
fn actions(self: &Arc<Self>, index: usize) -> Arc<RowActions> {
let (pick, click, activate, all) = (self.clone(), self.clone(), self.clone(), self.clone());
Arc::new(RowActions {
pick: Arc::new(move |how| pick.pick(index, how)),
click: Arc::new(move || {
for handler in &click.on_row_click {
handler(&click.keys.at(index));
}
}),
activate: Arc::new(move || {
for handler in &activate.on_row_activate {
handler(&activate.keys.at(index));
}
}),
select_all: Arc::new(move || all.select_shown(true)),
selectable: self.select.is_some(),
})
}
fn pick(&self, index: usize, pick: Pick) {
let key = &self.keys.at(index);
let next = match pick {
Pick::Only => vec![key.clone()],
Pick::Toggle => {
let mut next = self.selected.clone();
match next.iter().position(|held| held == key) {
Some(at) => {
next.remove(at);
}
None => next.push(key.clone()),
}
next
}
Pick::Range => {
let Some(rank) = self.keys.rank_of(key) else {
return;
};
let anchor = self
.selected
.last()
.and_then(|last| self.keys.rank_of(last))
.unwrap_or(rank);
let (start, end) = (anchor.min(rank), anchor.max(rank));
let span = self.keys.ranked(start, end);
let range: HashSet<&K> = span.iter().collect();
let mut next: Vec<K> = self
.selected
.iter()
.filter(|held| !range.contains(held))
.cloned()
.collect();
let anchor_key = self.keys.get(anchor);
next.extend(span.iter().filter(|at| Some(*at) != anchor_key.as_ref()).cloned());
next.extend(anchor_key);
next
}
};
self.write(next);
}
fn select_shown(&self, all: bool) {
let mut next: Vec<K> = self
.selected
.iter()
.filter(|held| self.keys.rank_of(held).is_none())
.cloned()
.collect();
if all {
next.extend((0..self.keys.len()).filter_map(|rank| self.keys.get(rank)));
}
self.write(next);
}
fn write(&self, next: Vec<K>) {
if let Some(select) = &self.select
&& next != self.selected
{
select(next.clone());
for handler in &self.on_selection_change {
handler(&next);
}
}
}
}
struct RowActions {
pick: Arc<dyn Fn(Pick) + Send + Sync>,
click: Arc<dyn Fn() + Send + Sync>,
activate: Arc<dyn Fn() + Send + Sync>,
select_all: Arc<dyn Fn() + Send + Sync>,
selectable: bool,
}
#[derive(Clone)]
struct Window {
indices: Vec<usize>,
focused: Option<usize>,
row_height: f32,
scroll: ScrollState,
refs: HashMap<usize, ElementRef>,
columns: Option<Arc<Vec<bool>>>,
cell_refs: HashMap<(usize, usize), ElementRef>,
editor_ref: ElementRef,
host: Option<Arc<HostLink>>,
rows: Arc<dyn FocusRows>,
lines: Arc<Lines>,
on_scroll: Option<Arc<dyn Fn(ScrollEvent) + Send + Sync>>,
search: Option<(Arc<Vec<Found>>, usize)>,
}
#[derive(Clone, Debug)]
pub struct BodyWindow {
pub row_height: f32,
pub count: usize,
heights: Option<Arc<Mutex<Heights>>>,
}
impl BodyWindow {
pub fn room(&self, from: usize, to: usize) -> f32 {
match &self.heights {
Some(heights) => {
let heights = heights.lock();
heights.top(to) - heights.top(from)
}
None => to.saturating_sub(from) as f32 * self.row_height,
}
}
}
pub struct TableView {
pub headers: Vec<TableHeader>,
pub rows: Vec<TableRow>,
pub groups: Vec<TableGroup>,
pub grouped: bool,
details: Vec<(usize, Element)>,
pub summaries: Vec<TableSummary>,
pub summary: Option<TableSummary>,
pub numbered: bool,
filter_row: bool,
pub number_lead: f32,
select_rows: Option<Arc<dyn Fn() + Send + Sync>>,
numbers_label: Arc<str>,
pub selectable: bool,
pub checkboxes: bool,
pub grid: bool,
pub pinned_start: bool,
pub pinned_end: bool,
pub lead_inset: f32,
pub selection: Option<bool>,
select_all: Option<Arc<dyn Fn() + Send + Sync>>,
select_all_label: Arc<str>,
pub loading: bool,
pub loading_rows: usize,
pub empty: Option<Element>,
pub footer: Option<String>,
pub pagination: Option<Element>,
pub label: Option<Arc<str>>,
pub total: usize,
pub height: Option<Length>,
pub max_height: Option<Length>,
pub disabled: bool,
pub recipe: ResolvedRecipe,
pub last_row: ResolvedRecipe,
pub geometry: Geometry,
pub tracks: ColumnTracks,
pub columns_built: Option<Arc<Vec<bool>>>,
pub window: Option<BodyWindow>,
scroll: Option<ScrollState>,
on_scroll: Option<Arc<dyn Fn(ScrollEvent) + Send + Sync>>,
focus_rows: Option<Arc<dyn FocusRows>>,
scroll_ref: Option<ElementRef>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl TableView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part)
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
pub fn root(&self) -> Column {
let columns = self.tracks.len();
let mut root = Column::new()
.align_items(Alignment::Stretch)
.part(&self.part(TablePart::Root))
.describe("a11y_role", if self.selectable || self.grid { "grid" } else { "table" })
.describe("a11y_rowcount", (self.total + 1).to_string())
.describe("a11y_colcount", columns.to_string());
if let Some(label) = &self.label {
root = root.describe("a11y_name", label.clone());
}
if self.selectable {
root = root.describe("a11y_multiselectable", "true");
}
if self.loading {
root = root.describe("a11y_busy", "true");
}
if let Some(height) = self.height.and_then(|height| height.resolve(self.theme())) {
root = root.height(height);
}
if let Some(height) = self.max_height.and_then(|height| height.resolve(self.theme())) {
root = root.max_height(height);
}
if let Some(id) = &self.id {
root = root.id(id.clone());
}
if let Some(key) = &self.key {
root = root.key(key.clone());
}
root
}
pub fn header(&mut self) -> Row {
let part = self.part(TablePart::Header);
let mut header = Row::new()
.part(&part)
.spacing(0.0)
.align_items(Alignment::Stretch)
.column_tracks(&self.tracks)
.sticky(Sticky::top(0.0))
.focus_group(FocusGroup::horizontal().one_stop(true).wrap(false))
.describe("a11y_role", "row")
.describe("a11y_rowindex", "1");
if self.pinned_start {
header = header.padding_left(0.0);
}
if self.pinned_end {
header = header.padding_right(0.0);
}
if self.numbered {
header = header.child(self.number_header());
}
if self.checkboxes {
header = header.child(self.select_all());
}
let headers = std::mem::take(&mut self.headers);
let placed = headers.into_iter().map(|header| (header.column, header.render()));
header.with_children(in_tracks(
self.columns_built.as_ref().map(|built| built.as_slice()),
placed,
))
}
pub fn select_all(&self) -> Element {
let part = self.part(TablePart::Select);
let mut checkbox = Checkbox::new(&self.select_all_label)
.label_hidden(true)
.checked(self.selection == Some(true))
.indeterminate(self.selection.is_none())
.disabled(self.disabled);
if let Some(press) = self.select_all.clone() {
checkbox = checkbox.on_change(move |_| press());
}
if let Some(id) = &self.id {
checkbox = checkbox.id(format!("{id}-select-all"));
}
let mut cell =
lead_cell(&part, self.geometry, self.pinned_start && !self.numbered).child(checkbox.build(self.theme()));
if self.pinned_start {
cell = cell.sticky(Sticky::left(self.number_lead));
if let Some(fill) = self.part(TablePart::Header).rest().background {
cell = cell.background(fill);
}
}
cell.into()
}
pub fn number_header(&self) -> Element {
let part = self.part(TablePart::RowNumber);
let mut cell = Row::new()
.part(&part)
.align_items(Alignment::Center)
.justify(Justify::End)
.padding_left(self.geometry.padding_start)
.padding_right(self.geometry.gap)
.sticky(Sticky::left(0.0))
.describe("a11y_role", "columnheader")
.describe("a11y_name", self.select_all_label.clone())
.child(part.text(&self.numbers_label).nowrap());
if let Some(fill) = self.part(TablePart::Header).rest().background {
cell = cell.background(fill);
}
if let Some(press) = self.select_rows.clone() {
cell = cell.on_click(move |event: MouseEvent| {
event.stop_propagation();
press();
});
}
if let Some(id) = &self.id {
cell = cell.id(format!("{id}-numbers"));
}
cell.into()
}
pub fn body(&mut self) -> Column {
let mut lines: Vec<(usize, Element)> = std::mem::take(&mut self.rows)
.into_iter()
.map(|row| (row.position, row.render()))
.chain(
std::mem::take(&mut self.groups)
.into_iter()
.map(|group| (group.position, group.render())),
)
.chain(
std::mem::take(&mut self.summaries)
.into_iter()
.map(|summary| (summary.position.unwrap_or(0), summary.render())),
)
.chain(std::mem::take(&mut self.details))
.collect();
lines.sort_by_key(|(position, _)| *position);
let group = FocusGroup::vertical().one_stop(true).wrap(false).nested(self.grouped);
let mut body = Column::new()
.align_items(Alignment::Stretch)
.describe("a11y_role", "rowgroup");
let (Some(window), Some(focus_rows)) = (self.window.clone(), self.focus_rows.clone()) else {
return body
.focus_group(group.pages(true))
.with_children(lines.into_iter().map(|(_, line)| line));
};
body = body.focus_group(group).focus_rows(focus_rows);
let spacer = |from: usize, to: usize| Row::new().height(window.room(from, to)).key(format!("before-{to}"));
let mut next = 0;
for (position, line) in lines {
if position > next {
body = body.child(spacer(next, position));
}
next = position + 1;
body = body.child(line);
}
if window.count > next {
body = body.child(spacer(next, window.count));
}
body
}
pub fn skeletons(&self) -> Column {
const FIRST: [f32; 4] = [0.85, 1.0, 0.68, 0.965];
const OTHER: f32 = 0.78;
let part = self.part(TablePart::Row);
let cell = self.part(TablePart::Cell);
let columns = self.tracks.len() - usize::from(self.checkboxes) - usize::from(self.numbered);
Column::new()
.align_items(Alignment::Stretch)
.with_children((0..self.loading_rows).map(|index| {
let row_part = if self.loading_rows == index + 1 && self.footer.is_none() {
self.last_row.part(TablePart::Row)
} else {
part.clone()
};
let mut row = Row::new()
.part(&row_part)
.spacing(0.0)
.align_items(Alignment::Stretch)
.column_tracks(&self.tracks)
.describe("a11y_hidden", "true");
if self.numbered {
row = row.child(Row::new());
}
if self.checkboxes {
row = row.child(Row::new());
}
row.with_children((0..columns).map(|column| {
let share = if column == 0 { FIRST[index % FIRST.len()] } else { OTHER };
let line = Row::new()
.width(Dimension::Pct(share * 100.0))
.child(Skeleton::line().width(Length::Fill).build(self.theme()));
let mut wrapper = Row::new().part(&cell).align_items(Alignment::Center).child(line);
if column + 1 < columns {
wrapper = wrapper.padding_right(self.geometry.gap);
}
wrapper
}))
}))
}
pub fn empty(&mut self) -> Option<Row> {
let empty = self.empty.take()?;
Some(
Row::new()
.justify(Justify::Center)
.part(&self.part(TablePart::Empty))
.child(empty),
)
}
pub fn footer(&mut self) -> Option<Row> {
let text = self.footer.take()?;
let count = self.part(TablePart::Count);
let mut footer = Row::new()
.wrap()
.align_items(Alignment::Center)
.justify(Justify::SpaceBetween)
.part(&self.part(TablePart::Footer))
.child(Row::new().part(&count).child(count.text(&text).nowrap()));
if let Some(pagination) = self.pagination.take() {
footer = footer.child(pagination);
}
Some(footer)
}
pub fn render(mut self) -> Element {
let mut content = Column::new()
.align_items(Alignment::Stretch)
.measures_column_tracks(&self.tracks);
let filters = self.filter_row();
content = content.child(self.header());
if let Some(filters) = filters {
content = content.child(filters);
}
let empty = if self.loading { None } else { self.empty() };
if self.loading {
content = content.child(self.skeletons());
} else if empty.is_none() {
content = content.child(self.body());
if let Some(summary) = self.summary.take() {
content = content.child(summary.render());
}
}
let mut scroll = ScrollBoth::new(content)
.fill_width(true)
.scrollbars_clear_of_sticky(true)
.reserve_bar_across(true)
.part(&self.part(TablePart::Scroll));
if let Some(empty) = empty {
let mut root = self.root().child(scroll.flex_full(0.0, 1.0, None));
let mut empty = Column::new().align_items(Alignment::Stretch).child(empty);
if self.height.is_some() {
empty = empty.flex(1.0).justify(Justify::Center);
}
root = root.child(empty);
if let Some(footer) = self.footer() {
root = root.child(footer);
}
return root.into();
}
if self.height.is_some() {
scroll = scroll.flex_full(1.0, 1.0, None);
} else {
scroll = scroll.flex_full(0.0, 1.0, None);
}
if let Some(state) = self.scroll.clone() {
scroll = scroll.with_scroll_state(state);
}
if let Some(element) = self.scroll_ref.clone() {
scroll = scroll.ref_element(element);
}
if let Some(on_scroll) = self.on_scroll.clone() {
scroll = scroll.on_scroll(move |event: ScrollEvent| on_scroll(event));
}
let mut root = self.root().child(scroll);
if let Some(footer) = self.footer() {
root = root.child(footer);
}
root.into()
}
}
pub fn in_tracks(built: Option<&[bool]>, cells: impl IntoIterator<Item = (usize, Element)>) -> Vec<Element> {
let mut placed = Vec::new();
let mut next = 0;
let room = |from: usize, to: usize, placed: &mut Vec<Element>| {
if to > from {
placed.push(Row::new().track_span(to - from).key(format!("columns-{from}")).into());
}
};
for (column, cell) in cells {
room(next, column, &mut placed);
placed.push(cell);
next = column + 1;
}
if let Some(built) = built {
room(next, built.len(), &mut placed);
}
placed
}
fn lead_cell(part: &ResolvedPart, geometry: Geometry, sticky: bool) -> Row {
let mut cell = Row::new()
.align_items(Alignment::Center)
.part(part)
.width(Dimension::Auto)
.padding_right(geometry.gap);
if sticky {
cell = cell.padding_left(geometry.padding_start);
}
cell
}
pub struct TableHeader {
pub column: usize,
pub title: Arc<str>,
pub title_hidden: bool,
pub align: ColumnAlign,
pub sortable: bool,
pub sorted: Option<SortDirection>,
pub sort_rank: Option<usize>,
pub filtered: bool,
filter: Option<Arc<FilterLink>>,
pub pinned: Option<Sticky>,
pub last: bool,
pub fill: Option<BackgroundColor>,
gap: f32,
lead: f32,
trail: f32,
pub recipe: ResolvedRecipe,
press: Option<Arc<dyn Fn(bool) + Send + Sync>>,
resize: Option<Arc<ResizeLink>>,
element: Option<ElementRef>,
key: Arc<str>,
menu: Option<Arc<ColumnMenuLink>>,
drop: Option<DropSide>,
id: Option<Arc<str>>,
}
impl TableHeader {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part)
}
pub fn cell(&self) -> Row {
let mut cell = Row::new()
.part(&self.part(TablePart::DropLine))
.align_items(Alignment::Center)
.justify(justify(self.align))
.describe("a11y_role", "columnheader")
.describe("a11y_name", self.title.clone())
.key(format!("header-{}", self.key));
if self.sortable || self.sorted.is_some() {
let sort = match self.sorted {
Some(SortDirection::Ascending) => "ascending",
Some(SortDirection::Descending) => "descending",
None => "none",
};
cell = cell.describe("a11y_sort", sort);
}
if !self.last {
cell = cell.padding_right(self.gap);
}
if self.trail > 0.0 {
cell = cell.padding_right(self.trail);
}
if self.lead > 0.0 {
cell = cell.padding_left(self.lead);
}
if let Some(pinned) = self.pinned {
cell = cell.sticky(pinned);
}
if let Some(fill) = self.fill.clone() {
cell = cell.background(fill);
}
if let Some(element) = &self.element {
cell = cell.ref_element(element.clone());
}
if self.menu.is_some() {
cell = cell.interaction_group(true);
}
cell
}
pub fn menu_trigger(&self) -> Option<Element> {
let link = self.menu.clone()?;
let part = self.part(TablePart::MenuTrigger);
let toggle = link.clone();
let mut trigger = pressable(&part, false)
.focusable(false)
.align_items(Alignment::Center)
.describe("a11y_name", link.trigger_label.clone())
.describe("a11y_haspopup", "menu")
.describe("a11y_expanded", if link.open { "true" } else { "false" })
.on_click(move |event: MouseEvent| {
event.stop_propagation();
(toggle.set_open)(!toggle.open);
})
.child(glyph(
&self.part(TablePart::SortIcon),
Name::new(icons::MORE_VERTICAL),
false,
));
if let Some(id) = &self.id {
trigger = trigger.id(format!("{id}-menu"));
}
if link.open {
trigger = trigger.ref_element(link.host.menu_anchor.clone());
} else if let Some(anchor) = self.filter_anchor() {
trigger = trigger.ref_element(anchor);
}
Some(trigger.into())
}
pub fn menu(&self) -> Option<Element> {
let link = self.menu.clone().filter(|link| link.open)?;
let choose = |choice: MenuChoice| {
let choose = link.choose.clone();
move || choose(choice.clone())
};
let set_open = link.set_open.clone();
let mut menu = Menu::controlled(true, link.host.menu_anchor.clone(), move |open| set_open(open))
.label(&link.trigger_label)
.placement(Placement::BottomEnd);
if let Some(id) = &self.id {
menu = menu.id(format!("{id}-menu-panel"));
}
if link.sortable {
menu = menu
.item(
MenuItem::new(&link.labels.sort_ascending)
.icon(icons::ARROW_UP)
.checked(link.sorted == Some(SortDirection::Ascending))
.on_select(choose(MenuChoice::Sort(Some(SortDirection::Ascending)))),
)
.item(
MenuItem::new(&link.labels.sort_descending)
.icon(icons::ARROW_DOWN)
.checked(link.sorted == Some(SortDirection::Descending))
.on_select(choose(MenuChoice::Sort(Some(SortDirection::Descending)))),
)
.item(
MenuItem::new(&link.labels.clear_sort)
.icon(icons::CHEVRONS_VERTICAL)
.disabled(link.sorted.is_none())
.on_select(choose(MenuChoice::Sort(None))),
)
.separator();
}
if let Some((filtered, any)) = link.filtering {
let words = &link.filter_labels;
menu = menu
.item(
MenuItem::new(&words.filter)
.icon(icons::FILTER)
.checked(filtered)
.on_select(choose(MenuChoice::Filter)),
)
.item(
MenuItem::new(&words.clear_filter)
.icon(icons::CLOSE)
.disabled(!filtered)
.on_select(choose(MenuChoice::ClearFilter)),
)
.item(
MenuItem::new(&words.clear_all)
.disabled(!any)
.on_select(choose(MenuChoice::ClearAllFilters)),
)
.separator();
}
let hidden = link.columns.iter().any(|(_, _, shown)| !shown);
let shown = link.columns.iter().filter(|(_, _, shown)| *shown).count();
let columns = Menu::new(link.host.submenu_open.clone(), link.host.submenu_anchor.clone())
.label(&crate::ui::current_locale().data.columns)
.items(link.columns.iter().map(|(id, title, on)| {
MenuItem::new(title)
.checked(*on)
.disabled(*on && shown == 1)
.on_select(choose(MenuChoice::Toggle(id.clone())))
}))
.separator()
.item(
MenuItem::new(&link.labels.show_all)
.disabled(!hidden)
.on_select(choose(MenuChoice::ShowAll)),
);
let export = link.export.as_ref().map(|export| {
let words = &export.labels;
Menu::new(link.host.export_open.clone(), link.host.export_anchor.clone())
.label(&words.export)
.item(
MenuItem::new(&words.shown_csv).on_select(choose(MenuChoice::Export(ExportScope::Shown, ExportFormat::Csv))),
)
.item(
MenuItem::new(&words.shown_tsv).on_select(choose(MenuChoice::Export(ExportScope::Shown, ExportFormat::Tsv))),
)
.item(
MenuItem::new(&words.selected_csv)
.disabled(!export.selected)
.on_select(choose(MenuChoice::Export(ExportScope::Selected, ExportFormat::Csv))),
)
.item(
MenuItem::new(&words.selected_tsv)
.disabled(!export.selected)
.on_select(choose(MenuChoice::Export(ExportScope::Selected, ExportFormat::Tsv))),
)
});
let mut menu = menu
.item(
MenuItem::new(&link.labels.pin_start)
.icon(icons::PIN)
.checked(link.pin == ColumnPin::Start)
.on_select(choose(MenuChoice::Pin(ColumnPin::Start))),
)
.item(
MenuItem::new(&link.labels.pin_end)
.icon(icons::PIN)
.checked(link.pin == ColumnPin::End)
.on_select(choose(MenuChoice::Pin(ColumnPin::End))),
)
.item(
MenuItem::new(&link.labels.unpin)
.icon(icons::CLOSE)
.disabled(link.pin == ColumnPin::None)
.on_select(choose(MenuChoice::Pin(ColumnPin::None))),
)
.separator()
.item(
MenuItem::new(&link.labels.size_to_fit)
.icon(icons::RESIZE_HORIZONTAL)
.on_select(choose(MenuChoice::Fit)),
)
.item(
MenuItem::new(&link.labels.hide)
.icon(icons::EYE_OFF)
.disabled(!link.can_hide)
.on_select(choose(MenuChoice::Hide)),
)
.item(MenuItem::new(&link.labels.columns).icon(icons::EYE).submenu(columns));
if let Some(export) = export {
let label = link.export.as_ref().map_or("", |export| export.labels.export.as_str());
menu = menu
.separator()
.item(MenuItem::new(label).icon(icons::DOWNLOAD).submenu(export));
}
Some(menu.build(self.recipe.theme()))
}
pub fn sort_icon(&self) -> Option<Element> {
let name = match self.sorted {
Some(SortDirection::Ascending) => icons::ARROW_UP,
Some(SortDirection::Descending) => icons::ARROW_DOWN,
None if self.sortable => icons::CHEVRONS_VERTICAL,
None => return None,
};
Some(glyph(&self.part(TablePart::SortIcon), Name::new(name), false))
}
pub fn sort_order(&self) -> Option<Element> {
let rank = self.sort_rank?;
let part = self.part(TablePart::SortOrder);
Some(part.text(&rank.to_string()).part(&part).nowrap().into())
}
pub fn resizer(&self) -> Option<Row> {
let link = self.resize.clone()?;
let width = link.width();
let (start, moved, end) = (link.clone(), link.clone(), link.clone());
Some(
Row::new()
.part(&self.part(TablePart::Resizer))
.justify(Justify::Center)
.align_items(Alignment::Stretch)
.height(Dimension::Pct(100.0))
.interaction_group(true)
.describe("a11y_role", "separator")
.describe("a11y_orientation", "vertical")
.describe("a11y_name", link.label.clone())
.describe("a11y_valuenow", format!("{}", width.round()))
.start_drag_buttons(MouseButtonMask::LEFT)
.on_drag_start(move |_: DragEvent| start.begin())
.on_drag_move(move |event: DragEvent| moved.drag(event.total_delta_x))
.on_drag_end(move |_: DragEvent| end.finish())
.on_click(|event: MouseEvent| event.stop_propagation())
.child(Row::new().part(&self.part(TablePart::ResizeLine))),
)
}
pub fn render(self) -> Element {
let part = self.part(TablePart::HeaderCell);
let title = if self.title_hidden {
None
} else {
Some(
part
.text(&self.title)
.nowrap()
.text_overflow(crate::node::node_kind::TextOverflow::Elipsis)
.flex_full(0.0, 1.0, None)
.min_width(Dimension::Px(0.0)),
)
};
let resizer = self.resizer();
let mut cell = self.cell();
let label: Element = match self.press.clone().filter(|_| self.sortable) {
None => {
let mut label = Row::new()
.align_items(Alignment::Center)
.flex_full(0.0, 1.0, None)
.min_width(Dimension::Px(0.0))
.part(&part);
if let Some(title) = title {
label = label.child(title);
}
if let Some(icon) = self.sort_icon() {
label = label.child(icon);
}
if let Some(order) = self.sort_order() {
label = label.child(order);
}
if let Some(mark) = self.filter_mark() {
label = label.child(mark);
}
if self.resize.is_some() || self.menu.is_some() {
label = label.tab_index(0).describe("a11y_name", self.title.clone());
if let Some(id) = &self.id {
label = label.id(id.clone());
}
}
label.into()
}
Some(press) => {
let mut button = pressable(&part, false)
.align_items(Alignment::Center)
.flex_full(0.0, 1.0, None)
.min_width(Dimension::Px(0.0))
.describe(
"a11y_name",
crate::core::fill(&crate::ui::current_locale().data.sort_by, &[("column", &self.title)]),
)
.on_click(move |event: MouseEvent| press(event.shift));
if let Some(title) = title {
button = button.child(title);
}
if let Some(icon) = self.sort_icon() {
button = button.child(icon);
}
if let Some(order) = self.sort_order() {
button = button.child(order);
}
if let Some(mark) = self.filter_mark() {
button = button.child(mark);
}
if let Some(id) = &self.id {
button = button.id(id.clone());
}
button.into()
}
};
let label = match &self.menu {
Some(link) => {
let (start, moved, end) = (link.clone(), link.clone(), link.clone());
Row::new()
.flex_full(0.0, 1.0, None)
.min_width(Dimension::Px(0.0))
.align_items(Alignment::Center)
.start_drag_buttons(MouseButtonMask::LEFT)
.on_drag_start(move |_: DragEvent| {
*start.host.header_drop.lock() = Some((start.place, Some(start.place)));
})
.on_drag_move(move |event: DragEvent| {
let to = moved.host.drop_place(event.x);
let mut held = moved.host.header_drop.lock();
if held.is_some_and(|(_, at)| at != to) {
*held = Some((moved.place, to));
drop(held);
moved.host.rebuild();
}
})
.on_drag_end(move |_: DragEvent| {
let held = end.host.header_drop.lock().take();
end.host.rebuild();
if let Some((from, to)) = held
&& to != Some(from)
&& to != Some(from + 1)
{
(end.move_to)(to);
}
})
.child(label)
.into()
}
None => label,
};
let trigger = self.menu_trigger();
let menu = self.menu();
let (resize_link, menu_link) = (self.resize.clone(), self.menu.clone());
if resize_link.is_some() || menu_link.is_some() {
cell = cell.on_key_down(move |event: KeyboardEvent| {
if !event.focus_within {
return;
}
let command = event.ctrl || event.meta;
if let Some(link) = &menu_link {
let key = event.key.as_str();
if (event.alt && !command && key == "ArrowDown") || key == "ContextMenu" || (event.shift && key == "F10") {
event.prevent_default();
(link.set_open)(true);
return;
}
if command && event.shift && !event.alt && matches!(key, "PageUp" | "PageDown") {
event.prevent_default();
(link.move_by)(if key == "PageUp" { -1 } else { 1 });
return;
}
}
let Some(link) = &resize_link else {
return;
};
if !command || event.alt {
return;
}
let step = if event.shift { RESIZE_STEP_SHIFT } else { RESIZE_STEP };
let by = match event.key.as_str() {
"ArrowLeft" => -step,
"ArrowRight" => step,
_ => return,
};
event.prevent_default();
link.step(by);
});
}
if resizer.is_none() && trigger.is_none() {
return cell.child(label).into();
}
if resizer.is_some() {
let half = px(self.part(TablePart::Resizer).rest().width, self.recipe.theme()).unwrap_or(8.0) / 2.0;
let after = if self.last { self.trail } else { self.gap };
cell = cell.padding_right((after / 2.0 - half).max(0.0));
}
let titled = Row::new()
.flex_full(1.0, 1.0, Some(0.0))
.min_width(Dimension::Px(0.0))
.justify(justify(self.align))
.align_items(Alignment::Center)
.child(label);
match trigger {
Some(trigger) => {
cell = cell.child(
Row::new()
.flex_full(1.0, 1.0, Some(0.0))
.min_width(Dimension::Px(0.0))
.align_items(Alignment::Center)
.spacing(4.0)
.child(titled)
.child(trigger),
);
}
None => cell = cell.child(titled),
}
if let Some(resizer) = resizer {
cell = cell.child(resizer);
}
if let Some(menu) = menu {
cell = cell.child(menu);
}
if let Some(panel) = self.filter_panel() {
cell = cell.child(panel);
}
cell.into()
}
}
struct ResizeLink {
layout: Option<Arc<dyn Fn(&str, f32) + Send + Sync>>,
host: Arc<HostLink>,
column: usize,
id: Arc<str>,
least: f32,
most: f32,
extra: f32,
start: Mutex<f32>,
on_resize: Vec<ResizeHeard>,
on_resize_end: Vec<ResizeHeard>,
label: String,
}
impl ResizeLink {
fn width(&self) -> f32 {
(self.host.track_width(self.column) - self.extra).max(0.0)
}
fn begin(&self) {
*self.start.lock() = self.width();
}
fn drag(&self, by: f32) {
let start = *self.start.lock();
self.set(start + by);
}
fn finish(&self) {
let width = self.width();
if (width - *self.start.lock()).abs() > 0.01 {
self.keep(width);
for handler in &self.on_resize_end {
handler(&self.id, width);
}
}
}
fn keep(&self, width: f32) {
if let Some(layout) = &self.layout {
layout(&self.id, width);
self.host.state.resized.lock().remove(&self.id);
}
}
fn step(&self, by: f32) {
let before = self.width();
let after = self.set(before + by);
if (after - before).abs() > 0.01 {
self.keep(after);
for handler in &self.on_resize_end {
handler(&self.id, after);
}
}
}
fn set(&self, width: f32) -> f32 {
let width = width.clamp(self.least, self.most.max(self.least));
if (width - self.width()).abs() > 0.01 && self.host.resize(&self.id, width) {
for handler in &self.on_resize {
handler(&self.id, width);
}
}
width
}
}
fn justify(align: ColumnAlign) -> Justify {
match align {
ColumnAlign::Start => Justify::Start,
ColumnAlign::Center => Justify::Center,
ColumnAlign::End => Justify::End,
}
}
pub struct TableCell {
pub column: usize,
pub content: Element,
pub grid: Option<GridCell>,
pub part: ResolvedPart,
pub align: ColumnAlign,
pub pinned: Option<Sticky>,
pub controls: bool,
pub last: bool,
pub fill: Option<BackgroundColor>,
gap: f32,
lead: f32,
trail: f32,
}
impl TableCell {
pub fn render(mut self) -> Element {
let mut cell = Row::new()
.align_items(Alignment::Center)
.justify(justify(self.align))
.part(&self.part)
.key(format!("cell-{}", self.column));
match self.grid.take() {
Some(mut grid) => {
let editor = grid.editor.take();
cell = grid
.dress(self.column, cell, editor.is_some())
.child(editor.unwrap_or(self.content));
}
None => {
cell = cell
.describe("a11y_role", "cell")
.focus_group(FocusGroup::none())
.child(self.content)
}
}
if !self.last {
cell = cell.padding_right(self.gap);
}
if self.trail > 0.0 {
cell = cell.padding_right(self.trail);
}
if self.lead > 0.0 {
cell = cell.padding_left(self.lead);
}
if let Some(pinned) = self.pinned {
cell = cell.sticky(pinned);
}
if let Some(fill) = self.fill {
cell = cell.background(fill);
}
if self.controls {
cell = cell.on_click(|event: MouseEvent| event.stop_propagation());
}
cell.into()
}
}
fn tree_cell(
part: &ResolvedPart,
level: u32,
open: Option<bool>,
rank: usize,
toggle: Arc<dyn Fn(usize, bool) + Send + Sync>,
content: Element,
wraps: bool,
) -> Element {
let side = part.rest().width.unwrap_or(Length::Icon(IconSize::Sm));
let chevron: Element = match open {
Some(open) => Row::new()
.part(part)
.align_items(Alignment::Center)
.justify(Justify::Center)
.child(
super::Icon::new(Name::new(if open {
icons::CHEVRON_DOWN
} else {
icons::CHEVRON_RIGHT
}))
.size(side)
.build(part.theme()),
)
.on_click(move |event: MouseEvent| {
event.stop_propagation();
toggle(rank, !open);
})
.into(),
None => Row::new().part(part).into(),
};
let mut cell = Row::new()
.align_items(Alignment::Center)
.spacing(6.0)
.padding_left(18.0 * level as f32)
.child(chevron)
.child(content);
cell = if wraps {
cell.flex_full(1.0, 1.0, Some(0.0)).min_width(Dimension::Px(0.0))
} else {
cell.flex_full(0.0, 1.0, None).min_width(Dimension::Px(0.0))
};
cell.into()
}
pub struct TableRow {
pub index: usize,
pub tree: Option<(u32, Option<bool>)>,
pub position: usize,
pub number: Option<usize>,
number_lead: f32,
pub selected: bool,
pub disabled: bool,
pub name: Option<Arc<str>>,
pub cells: Vec<TableCell>,
pub checkbox: bool,
pub pinned_start: bool,
pub pinned_end: bool,
pub lead_fill: Option<BackgroundColor>,
pub entry: bool,
pub grows: bool,
pub recipe: ResolvedRecipe,
forced: Option<Interaction>,
tracks: ColumnTracks,
columns_built: Option<Arc<Vec<bool>>>,
grid: bool,
geometry: Geometry,
actions: Option<Arc<RowActions>>,
select_label: Arc<str>,
host: Option<Arc<HostLink>>,
element: ElementRef,
id: Option<Arc<str>>,
}
impl TableRow {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part).forced(self.forced)
}
pub fn button(&self) -> components::Button {
let mut row = pressable(&self.part(TablePart::Row), self.disabled)
.justify(Justify::Start)
.align_items(Alignment::Stretch)
.spacing(0.0)
.column_tracks(&self.tracks)
.interaction_group(true)
.stops_inside(true)
.ref_element(self.element.clone())
.describe("a11y_role", "row")
.describe("a11y_rowindex", (self.position + 2).to_string())
.key(format!("row-{}", self.index));
if let Some((level, open)) = self.tree {
row = row.describe("a11y_level", level.to_string());
if let Some(open) = open {
row = row.describe("a11y_expanded", if open { "true" } else { "false" });
}
}
if self.grows {
let least = px(self.part(TablePart::Row).rest().height, self.recipe.theme()).unwrap_or(0.0);
row = row.height(Dimension::Auto).min_height(least);
}
if self.grid {
row = row.focusable(false).focus_group(FocusGroup::horizontal().wrap(false));
} else {
row = row.focus_entry(self.entry);
if self.host.is_some() {
row = row.focus_row(self.position);
}
}
if self.pinned_start {
row = row.padding_left(0.0);
}
if self.pinned_end {
row = row.padding_right(0.0);
}
if let Some(name) = &self.name {
row = row.describe("a11y_name", name.clone()).focus_label(name.clone());
}
if let Some(actions) = &self.actions
&& actions.selectable
{
row = row.describe("a11y_selected", if self.selected { "true" } else { "false" });
}
if let Some(actions) = self.actions.clone() {
let press = actions.clone();
let index = self.index;
let touch = super::touch_form();
row = row.on_click(move |event: MouseEvent| {
let tapped = touch && event.pointer_kind != crate::app::events::PointerKind::Mouse && !event.from_keyboard;
if tapped {
if press.selectable {
(press.pick)(Pick::Only);
}
(press.activate)();
return;
}
if second_press(index, &event) {
(press.activate)();
return;
}
if press.selectable {
let pick = if event.shift {
Pick::Range
} else if event.ctrl || event.meta || event.from_keyboard {
Pick::Toggle
} else {
Pick::Only
};
(press.pick)(pick);
}
(press.click)();
});
let element = self.element.clone();
if actions.selectable {
let (element, select_all) = (element.clone(), actions.select_all.clone());
row = row.on_select_all(move |event: EditEvent| {
if element.focused() {
select_all();
} else {
event.pass_on();
}
});
}
row = row.on_key_down(move |event: KeyboardEvent| {
if !element.focused() || event.composing || event.alt {
return;
}
let command = event.ctrl || event.meta;
if event.key == "Enter" && !command && !event.shift {
event.prevent_default();
(actions.activate)();
}
});
if let Some(host) = &self.host {
let (host, position) = (host.clone(), self.position);
row = row.on_focus(move || host.focused(position));
}
}
if let Some(id) = &self.id {
row = row.id(id.clone());
}
row
}
pub fn checkbox(&self) -> Element {
let part = self.part(TablePart::Select);
let checkbox = Checkbox::new(&self.select_label)
.rules(&self.recipe.lend("checkbox"))
.label_hidden(true)
.checked(self.selected)
.disabled(self.disabled)
.build(self.recipe.theme());
let numbered = self.number.is_some();
let mut cell =
lead_cell(&part, self.geometry, self.pinned_start && !numbered).child(Row::new().inert(true).child(checkbox));
if self.pinned_start {
cell = cell.sticky(Sticky::left(self.number_lead));
}
if let Some(fill) = self.lead_fill.clone() {
cell = cell.background(fill);
}
if let Some(actions) = self.actions.clone() {
cell = cell.on_click(move |event: MouseEvent| {
event.stop_propagation();
(actions.pick)(if event.shift { Pick::Range } else { Pick::Toggle });
});
}
cell.into()
}
pub fn number(&self) -> Option<Element> {
let number = self.number?;
let part = self.part(TablePart::RowNumber);
let mut cell = Row::new()
.part(&part)
.align_items(Alignment::Center)
.justify(Justify::End)
.padding_left(self.geometry.padding_start)
.padding_right(self.geometry.gap)
.sticky(Sticky::left(0.0))
.describe("a11y_role", "rowheader")
.describe("a11y_name", number.to_string())
.child(part.text(&number.to_string()).nowrap());
if let Some(fill) = self.lead_fill.clone() {
cell = cell.background(fill);
}
if let Some(actions) = self.actions.clone().filter(|actions| actions.selectable) {
cell = cell.on_click(move |event: MouseEvent| {
event.stop_propagation();
(actions.pick)(if event.shift {
Pick::Range
} else if event.ctrl || event.meta {
Pick::Toggle
} else {
Pick::Only
});
});
}
if let Some(id) = &self.id {
cell = cell.id(format!("{id}-number"));
}
Some(cell.into())
}
pub fn render(mut self) -> Element {
let mut row = self.button();
if let Some(number) = self.number() {
row = row.child(number);
}
if self.checkbox {
row = row.child(self.checkbox());
}
let cells = std::mem::take(&mut self.cells);
let placed = cells.into_iter().map(|cell| (cell.column, cell.render()));
row
.with_children(in_tracks(
self.columns_built.as_ref().map(|built| built.as_slice()),
placed,
))
.into()
}
}
thread_local! {
static LAST_PRESS: Cell<Option<(usize, crate::time::Instant, (f32, f32))>> = const { Cell::new(None) };
}
fn second_press(index: usize, event: &MouseEvent) -> bool {
let plain = !(event.from_keyboard || event.shift || event.ctrl || event.meta || event.alt);
let now = event.time;
let near = |(x, y): (f32, f32)| (x - event.x).powi(2) + (y - event.y).powi(2) <= DOUBLE_CLICK_DISTANCE.powi(2);
LAST_PRESS.with(|last| {
let second = plain
&& last
.get()
.is_some_and(|(row, at, place)| row == index && now.duration_since(at) <= DOUBLE_CLICK_INTERVAL && near(place));
last.set((plain && !second).then_some((index, now, (event.x, event.y))));
second
})
}
#[derive(Clone, Debug, PartialEq)]
pub enum CellValue {
Text(String),
Number(f64),
Choice(usize),
Checked(bool),
Empty,
}
#[derive(Clone, Debug)]
pub struct CellEdit<'a, K> {
pub row: &'a K,
pub column: &'a str,
pub value: CellValue,
}
type EditHeard<K> = Arc<dyn Fn(&CellEdit<K>) -> bool + Send + Sync>;
pub struct CellEditor<R> {
kind: EditorKind<R>,
}
enum EditorKind<R> {
Text(TextFn<R>),
Number(Arc<dyn Fn(&R) -> f64 + Send + Sync>),
Choice(Arc<Vec<Arc<str>>>, Arc<dyn Fn(&R) -> usize + Send + Sync>),
Checkbox(Arc<dyn Fn(&R) -> bool + Send + Sync>),
}
impl<R> Clone for CellEditor<R> {
fn clone(&self) -> Self {
Self {
kind: match &self.kind {
EditorKind::Text(text) => EditorKind::Text(text.clone()),
EditorKind::Number(number) => EditorKind::Number(number.clone()),
EditorKind::Choice(choices, chosen) => EditorKind::Choice(choices.clone(), chosen.clone()),
EditorKind::Checkbox(checked) => EditorKind::Checkbox(checked.clone()),
},
}
}
}
impl<R> CellEditor<R> {
pub fn text(value: impl Fn(&R) -> String + Send + Sync + 'static) -> Self {
Self {
kind: EditorKind::Text(Arc::new(value)),
}
}
pub fn number(value: impl Fn(&R) -> f64 + Send + Sync + 'static) -> Self {
Self {
kind: EditorKind::Number(Arc::new(value)),
}
}
pub fn choice<S: AsRef<str>>(
choices: impl IntoIterator<Item = S>,
chosen: impl Fn(&R) -> usize + Send + Sync + 'static,
) -> Self {
Self {
kind: EditorKind::Choice(
Arc::new(choices.into_iter().map(|choice| Arc::from(choice.as_ref())).collect()),
Arc::new(chosen),
),
}
}
pub fn checkbox(checked: impl Fn(&R) -> bool + Send + Sync + 'static) -> Self {
Self {
kind: EditorKind::Checkbox(Arc::new(checked)),
}
}
fn is_checkbox(&self) -> bool {
matches!(self.kind, EditorKind::Checkbox(_))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum GridStep {
Stay,
Down,
On,
Back,
}
#[derive(Clone, Copy, Debug, PartialEq)]
struct Editing {
row: usize,
column: usize,
refused: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum FocusAim {
Cell(usize, usize),
Editor,
}
trait GridCells: Send + Sync {
fn focused(&self, row: usize, column: usize);
fn start(&self, row: usize, column: usize, typed: Option<String>);
fn toggle(&self, row: usize, column: usize);
fn commit(&self, step: GridStep);
fn cancel(&self);
fn move_to(&self, row: usize, column: usize) -> bool;
fn select(&self, row: usize, pick: Pick);
fn activate(&self, row: usize);
fn size(&self) -> (usize, usize);
fn click(&self, row: usize);
fn extent(&self) -> Option<(usize, usize)>;
fn extend(&self, from: Option<(usize, usize)>, to: (usize, usize));
fn clear_range(&self) -> bool;
fn select_cells(&self);
fn copy(&self, at: (usize, usize), cut: bool) -> String;
fn paste(&self, at: (usize, usize), text: &str);
fn clear(&self, at: (usize, usize));
fn drag_start(&self, at: (usize, usize));
fn drag_to(&self, x: f32, y: f32);
fn page(&self) -> usize;
fn export(&self, scope: ExportScope, format: ExportFormat) -> (String, usize);
fn has_selection(&self) -> bool;
fn opener(&self, row: usize) -> Option<(Option<bool>, Option<usize>)>;
fn open_row(&self, row: usize, open: bool);
}
struct GridModel<R, K> {
host: Arc<HostState>,
span: Option<Span>,
range: Option<CellRange<K>>,
write_range: Option<RangeWrite<K>>,
on_range: Vec<RangeHeard<K>>,
texts: Arc<Vec<Option<TextFn<R>>>>,
titles: Arc<Vec<Arc<str>>>,
rows: Arc<Vec<R>>,
keys: RowKeys<K>,
lines: Arc<Lines>,
editors: Arc<Vec<(Arc<str>, Option<CellEditor<R>>)>>,
on_edit: Vec<EditHeard<K>>,
model: Arc<Model<K>>,
read_only: bool,
}
impl<R: Send + Sync + 'static, K: Clone + Eq + Hash + Send + Sync + 'static> GridModel<R, K> {
fn editor(&self, column: usize) -> Option<&CellEditor<R>> {
if self.read_only {
return None;
}
self.editors.get(column).and_then(|(_, editor)| editor.as_ref())
}
fn tell(&self, row: usize, column: usize, value: CellValue) -> bool {
let (Some(key), Some((id, _))) = (self.keys.get(row), self.editors.get(column)) else {
return false;
};
let edit = CellEdit {
row: &key,
column: id,
value,
};
self.on_edit.iter().fold(true, |taken, handler| handler(&edit) && taken)
}
fn drafted(&self, column: usize) -> Option<CellValue> {
Some(match &self.editor(column)?.kind {
EditorKind::Text(_) => CellValue::Text(self.host.draft_text.get()),
EditorKind::Number(_) => CellValue::Number(self.host.draft_number.get()?),
EditorKind::Choice(..) => CellValue::Choice(self.host.draft_choice.get()),
EditorKind::Checkbox(_) => return None,
})
}
fn aim(&self, aim: FocusAim) {
*self.host.pending_focus.lock() = Some(aim);
if let FocusAim::Cell(row, column) = aim {
*self.host.focused.lock() = Some(self.position(row));
*self.host.focused_column.lock() = Some(column);
}
self.host.rebuild();
}
fn row(&self, rank: usize) -> Option<&R> {
self.rows.get(self.lines.row_of_rank(rank)?)
}
fn position(&self, rank: usize) -> usize {
self.lines.position_of(rank).unwrap_or(rank)
}
fn focused_cell(&self) -> Option<(usize, usize)> {
let position = (*self.host.focused.lock())?;
Some((self.lines.rank_at(position)?, (*self.host.focused_column.lock())?))
}
}
impl<R: Send + Sync + 'static, K: Clone + Eq + Hash + Send + Sync + 'static> GridCells for GridModel<R, K> {
fn focused(&self, row: usize, column: usize) {
let position = self.position(row);
let before = (*self.host.focused.lock(), *self.host.focused_column.lock());
*self.host.focused.lock() = Some(position);
*self.host.focused_column.lock() = Some(column);
if before != (Some(position), Some(column)) {
self.write_span(None);
}
let editing = *self.host.editing.lock();
if let Some(editing) = editing
&& (editing.row, editing.column) != (row, column)
{
if let Some(value) = self.drafted(editing.column) {
self.tell(editing.row, editing.column, value);
}
*self.host.editing.lock() = None;
self.host.rebuild();
}
}
fn start(&self, row: usize, column: usize, typed: Option<String>) {
let (Some(editor), Some(values)) = (self.editor(column), self.row(row)) else {
return;
};
match &editor.kind {
EditorKind::Text(text) => self.host.draft_text.set(typed.unwrap_or_else(|| text(values))),
EditorKind::Number(number) => self.host.draft_number.set(
typed
.and_then(|typed| typed.parse::<f64>().ok())
.or(Some(number(values))),
),
EditorKind::Choice(_, chosen) => self.host.draft_choice.set(chosen(values)),
EditorKind::Checkbox(_) => {
self.toggle(row, column);
return;
}
}
*self.host.editing.lock() = Some(Editing {
row,
column,
refused: false,
});
self.aim(FocusAim::Editor);
}
fn toggle(&self, row: usize, column: usize) {
let (Some(editor), Some(values)) = (self.editor(column), self.row(row)) else {
return;
};
if let EditorKind::Checkbox(checked) = &editor.kind {
self.tell(row, column, CellValue::Checked(!checked(values)));
}
}
fn commit(&self, step: GridStep) {
let Some(editing) = *self.host.editing.lock() else {
return;
};
let Some(value) = self.drafted(editing.column) else {
return;
};
if !self.tell(editing.row, editing.column, value) {
*self.host.editing.lock() = Some(Editing {
refused: true,
..editing
});
self.aim(FocusAim::Editor);
return;
}
*self.host.editing.lock() = None;
let (row, column) = (editing.row, editing.column);
let columns = self.editors.len();
let target = match step {
GridStep::Stay => (row, column),
GridStep::Down if row + 1 < self.keys.len() => (row + 1, column),
GridStep::On if column + 1 < columns => (row, column + 1),
GridStep::Back if column > 0 => (row, column - 1),
_ => (row, column),
};
self.aim(FocusAim::Cell(target.0, target.1));
}
fn cancel(&self) {
let Some(editing) = self.host.editing.lock().take() else {
return;
};
self.aim(FocusAim::Cell(editing.row, editing.column));
}
fn move_to(&self, row: usize, column: usize) -> bool {
if row >= self.keys.len() || column >= self.editors.len() {
return false;
}
self.aim(FocusAim::Cell(row, column));
true
}
fn select(&self, row: usize, pick: Pick) {
if let Some(index) = self.lines.row_of_rank(row) {
self.model.pick(index, pick);
}
}
fn activate(&self, row: usize) {
if let Some(key) = self.keys.get(row) {
for handler in &self.model.on_row_activate {
handler(&key);
}
}
}
fn size(&self) -> (usize, usize) {
(self.keys.len(), self.editors.len())
}
fn click(&self, row: usize) {
if let Some(key) = self.keys.get(row) {
for handler in &self.model.on_row_click {
handler(&key);
}
}
}
fn extent(&self) -> Option<(usize, usize)> {
self.span.map(|span| span.extent)
}
fn extend(&self, from: Option<(usize, usize)>, to: (usize, usize)) {
let anchor = self
.span
.map(|span| span.anchor)
.or(from)
.or_else(|| self.focused_cell())
.unwrap_or(to);
let span = Span { anchor, extent: to };
self.write_span((anchor != to).then_some(span));
self.host.reveal_cell(self.position(to.0), to.1);
}
fn clear_range(&self) -> bool {
let had = self.span.is_some();
self.write_span(None);
had
}
fn select_cells(&self) {
let (rows, columns) = self.size();
if rows == 0 || columns == 0 {
return;
}
let anchor = self.focused_cell().unwrap_or((0, 0));
let extent = (
if anchor.0 == 0 { rows - 1 } else { 0 },
if anchor.1 == 0 { columns - 1 } else { 0 },
);
let span = if anchor.0 == 0 || anchor.0 == rows - 1 {
Span { anchor, extent }
} else {
Span {
anchor: (0, 0),
extent: (rows - 1, columns - 1),
}
};
self.write_span(Some(span));
}
fn copy(&self, at: (usize, usize), cut: bool) -> String {
self.copy_cells(at, cut)
}
fn export(&self, scope: ExportScope, format: ExportFormat) -> (String, usize) {
self.export_rows(scope, format)
}
fn opener(&self, row: usize) -> Option<(Option<bool>, Option<usize>)> {
if let Some(tree) = &self.lines.tree {
let open = tree.branch.get(row).copied().unwrap_or(false).then(|| tree.open[row]);
return Some((open, tree.parent.get(row).copied().flatten()));
}
self.host.detail_toggle.lock().as_ref()?;
let position = self.lines.position_of(row)?;
Some((Some(self.lines.line(position + 1) == Some(Shown::Detail(row))), None))
}
fn open_row(&self, row: usize, open: bool) {
let toggle = if self.lines.tree.is_some() {
self.host.tree_toggle.lock().clone()
} else {
self.host.detail_toggle.lock().clone()
};
if let Some(toggle) = toggle {
toggle(row, open);
}
}
fn has_selection(&self) -> bool {
self.span.is_some() || self.model.selected.iter().any(|key| self.keys.rank_of(key).is_some())
}
fn paste(&self, at: (usize, usize), text: &str) {
self.paste_cells(at, text);
}
fn clear(&self, at: (usize, usize)) {
self.clear_cells(at);
}
fn drag_start(&self, at: (usize, usize)) {
*self.host.drag_anchor.lock() = Some(at);
*self.host.drag_last.lock() = Some(at);
self.aim(FocusAim::Cell(at.0, at.1));
}
fn drag_to(&self, x: f32, y: f32) {
self.host.scroll_toward(x, y);
let Some(anchor) = *self.host.drag_anchor.lock() else {
return;
};
let Some(cell) = self.host.cell_at(x, y) else {
return;
};
if self.host.drag_last.lock().replace(cell) == Some(cell) {
return;
}
self.write_span_now((anchor != cell).then_some(Span { anchor, extent: cell }));
}
fn page(&self) -> usize {
FocusRows::page(&*self.host)
}
}
pub struct GridCell {
pub row: usize,
pub position: usize,
pub editable: bool,
pub selected: bool,
pub editor: Option<Element>,
pub entry: bool,
pub column_index: usize,
checkbox: bool,
element: ElementRef,
grid: Arc<dyn GridCells>,
id: Option<Arc<str>>,
}
thread_local! {
static LAST_CELL_PRESS: Cell<Option<((usize, usize), crate::time::Instant, (f32, f32))>> = const { Cell::new(None) };
}
fn second_cell_press(cell: (usize, usize), event: &MouseEvent) -> bool {
let plain = !(event.from_keyboard || event.shift || event.ctrl || event.meta || event.alt);
let now = event.time;
let near = |(x, y): (f32, f32)| (x - event.x).powi(2) + (y - event.y).powi(2) <= DOUBLE_CLICK_DISTANCE.powi(2);
LAST_CELL_PRESS.with(|last| {
let second = plain
&& last.get().is_some_and(|(at, when, place)| {
at == cell && now.duration_since(when) <= DOUBLE_CLICK_INTERVAL && near(place)
});
last.set((plain && !second).then_some((cell, now, (event.x, event.y))));
second
})
}
impl GridCell {
fn dress(&self, column: usize, cell: Row, editing: bool) -> Row {
let (row, grid, element) = (self.row, self.grid.clone(), self.element.clone());
let editable = self.editable;
let checkbox = self.checkbox;
let mut cell = cell
.tab_index(0)
.focus_row(self.position)
.focus_column(column)
.focus_entry(self.entry)
.ref_element(self.element.clone())
.describe("a11y_role", "gridcell")
.describe("a11y_colindex", self.column_index.to_string())
.describe("a11y_readonly", if editable { "false" } else { "true" })
.describe("a11y_rowindex", (self.position + 2).to_string())
.on_focus({
let grid = grid.clone();
move || grid.focused(row, column)
})
.on_click({
let grid = grid.clone();
move |event: MouseEvent| {
event.stop_propagation();
if event.shift {
event.prevent_default();
return;
}
if event.ctrl || event.meta || event.alt {
return;
}
if checkbox && editable {
if !second_cell_press((row, column), &event) {
grid.toggle(row, column);
}
return;
}
if second_cell_press((row, column), &event) {
if editable {
grid.start(row, column, None);
} else {
grid.activate(row);
}
return;
}
grid.click(row);
}
});
if self.selected {
cell = cell.describe("a11y_selected", "true");
}
if let Some(id) = &self.id {
cell = cell.id(id.clone());
}
if editing {
return cell;
}
cell = cell
.on_mouse_down({
let grid = grid.clone();
move |event: MouseEvent| {
if event.button != MouseButton::Left {
return;
}
if event.shift {
event.prevent_default();
grid.extend(None, (row, column));
} else {
grid.clear_range();
}
}
})
.start_drag_buttons(MouseButtonMask::LEFT)
.on_drag_start({
let grid = grid.clone();
move |_: DragEvent| grid.drag_start((row, column))
})
.on_drag_move({
let grid = grid.clone();
move |event: DragEvent| grid.drag_to(event.x, event.y)
})
.on_copy({
let grid = grid.clone();
move |event: CopyEvent| event.set_text(grid.copy((row, column), event.is_cut()))
})
.on_paste({
let grid = grid.clone();
move |event: PasteEvent| {
if let Some(text) = event.text() {
grid.paste((row, column), text);
}
}
})
.on_select_all({
let (grid, element) = (grid.clone(), element.clone());
move |event: EditEvent| {
if element.focused() {
grid.select_cells();
} else {
event.pass_on();
}
}
});
cell.on_key_down(move |event: KeyboardEvent| {
if !element.focused() || event.composing || event.alt {
return;
}
let command = event.ctrl || event.meta;
let (rows, columns) = grid.size();
let (last_row, last_column) = (rows.saturating_sub(1), columns.saturating_sub(1));
let (at_row, at_column) = grid.extent().unwrap_or((row, column));
let reach = match event.key.as_str() {
_ if !event.shift => None,
"ArrowUp" if !command => Some((at_row.saturating_sub(1), at_column)),
"ArrowDown" if !command => Some(((at_row + 1).min(last_row), at_column)),
"ArrowLeft" if !command => Some((at_row, at_column.saturating_sub(1))),
"ArrowRight" if !command => Some((at_row, (at_column + 1).min(last_column))),
"PageUp" if !command => Some((at_row.saturating_sub(grid.page()), at_column)),
"PageDown" if !command => Some(((at_row + grid.page()).min(last_row), at_column)),
"Home" if command => Some((0, 0)),
"End" if command => Some((last_row, last_column)),
"Home" => Some((at_row, 0)),
"End" => Some((at_row, last_column)),
_ => None,
};
if let Some(to) = reach {
event.prevent_default();
grid.extend(Some((row, column)), to);
return;
}
if column == 0
&& !command
&& !event.shift
&& let Some((open, parent)) = grid.opener(row)
{
match (event.key.as_str(), open, parent) {
("ArrowRight", Some(false), _) => {
event.prevent_default();
grid.open_row(row, true);
return;
}
("ArrowLeft", Some(true), _) => {
event.prevent_default();
grid.open_row(row, false);
return;
}
("ArrowLeft", _, Some(parent)) => {
event.prevent_default();
grid.move_to(parent, 0);
return;
}
_ => {}
}
}
match event.key.as_str() {
"Enter" | "F2" if !command && editable && !checkbox => {
event.prevent_default();
grid.start(row, column, None);
}
"Enter" if !command => {
event.prevent_default();
grid.activate(row);
}
" " if !command && checkbox && editable => {
event.prevent_default();
grid.toggle(row, column);
}
" " if !command => {
event.prevent_default();
grid.select(row, if event.shift { Pick::Range } else { Pick::Toggle });
}
"Tab" if !command => {
let to = if event.shift {
column.checked_sub(1)
} else {
Some(column + 1)
};
if to.is_some_and(|to| grid.move_to(row, to)) {
event.prevent_default();
}
}
"Home" | "End" => {
event.prevent_default();
let end = event.key == "End";
let to_row = match (command, end) {
(true, true) => last_row,
(true, false) => 0,
(false, _) => row,
};
grid.move_to(to_row, if end { last_column } else { 0 });
}
"Delete" | "Backspace" if !command && !event.shift => {
event.prevent_default();
grid.clear((row, column));
}
"Escape" if !command => {
if grid.clear_range() {
event.prevent_default();
}
}
key if !command && editable && !checkbox && key.chars().count() == 1 && !key.trim().is_empty() => {
event.prevent_default();
grid.start(row, column, Some(key.to_owned()));
}
_ => {}
}
})
}
}
fn editor_in(part: &ResolvedPart, editor: Element, choice: bool, grid: Arc<dyn GridCells>, element: ElementRef) -> Row {
Row::new()
.part(part)
.align_items(Alignment::Center)
.width(Dimension::Pct(100.0))
.flex_full(1.0, 1.0, Some(0.0))
.min_width(Dimension::Px(0.0))
.ref_element(element)
.on_key_down(move |event: KeyboardEvent| {
if !event.focus_within || event.composing {
return;
}
match event.key.as_str() {
"Enter" if !choice && !event.shift && !event.alt => {
event.prevent_default();
grid.commit(GridStep::Down);
}
"Tab" if !event.alt => {
event.prevent_default();
grid.commit(if event.shift { GridStep::Back } else { GridStep::On });
}
"Escape" => {
event.prevent_default();
grid.cancel();
}
_ => {}
}
})
.child(editor)
}
struct HostLink {
state: Arc<HostState>,
}
impl HostLink {
fn focused(&self, index: usize) {
*self.state.focused.lock() = Some(index);
}
fn track_width(&self, column: usize) -> f32 {
let metrics = *self.state.metrics.lock();
let Some(tracks) = self.state.tracks.lock().as_ref().map(|(_, tracks)| tracks.clone()) else {
return 0.0;
};
let viewport = self.state.scroll.viewport_width();
let available = (viewport > 0.0).then(|| (viewport - metrics.padding_start - metrics.padding_end).max(0.0));
tracks
.widths(available, 0.0)
.get(column + metrics.lead_tracks)
.copied()
.unwrap_or(0.0)
}
fn resize(&self, id: &Arc<str>, width: f32) -> bool {
let mut resized = self.state.resized.lock();
if resized.get(id).is_some_and(|held| (held - width).abs() < 0.01) {
return false;
}
resized.insert(id.clone(), width);
drop(resized);
self.state.rebuild();
true
}
}
impl FocusRows for HostState {
fn count(&self) -> usize {
self.metrics.lock().count
}
fn label(&self, _row: usize) -> Option<String> {
None
}
fn enabled(&self, row: usize) -> bool {
!self.metrics.lock().disabled && !matches!(self.lines.lock().line(row), Some(Shown::Summary(_) | Shown::Detail(_)))
}
fn level(&self, row: usize) -> u32 {
self.lines.lock().level(row)
}
fn expanded(&self, row: usize) -> Option<bool> {
let lines = self.lines.lock();
match lines.line(row)? {
Shown::Group(group) => Some(lines.groups[group].open),
Shown::Row(rank) => {
let tree = lines.tree.as_ref()?;
tree.branch.get(rank).copied().unwrap_or(false).then(|| tree.open[rank])
}
Shown::Summary(_) | Shown::Detail(_) => None,
}
}
fn set_expanded(&self, row: usize, open: bool) {
let group = match self.lines.lock().line(row) {
Some(Shown::Group(group)) => group,
Some(Shown::Row(rank)) => {
let toggle = self.tree_toggle.lock().clone();
if let Some(toggle) = toggle {
toggle(rank, open);
}
return;
}
_ => return,
};
let toggle = self.group_toggle.lock().clone();
if let Some(toggle) = toggle {
toggle(group, open);
}
}
fn page(&self) -> usize {
let metrics = *self.metrics.lock();
if metrics.row_height <= 0.0 {
return 1;
}
((self.scroll.viewport_height() - metrics.header_height) / metrics.row_height)
.floor()
.max(2.0) as usize
- 1
}
fn reveal(&self, row: usize) {
let metrics = *self.metrics.lock();
if row >= metrics.count || metrics.row_height <= 0.0 {
return;
}
let (top, height) = {
let heights = self.heights.lock();
(heights.top(row), heights.height(row))
};
let room = (self.scroll.viewport_height() - metrics.header_height).max(height);
let scroll_y = self.scroll.scroll_y();
let y = if top < scroll_y {
top
} else if top + height > scroll_y + room {
top + height - room
} else {
scroll_y
};
self.scroll.set_scroll(self.scroll.scroll_x(), y.max(0.0));
*self.focused.lock() = Some(row);
self.rebuild();
}
}
#[derive(Clone, Copy, Debug, Default)]
struct Metrics {
row_height: f32,
header_height: f32,
count: usize,
disabled: bool,
padding_start: f32,
padding_end: f32,
lead_tracks: usize,
pins: (usize, usize),
}
type KeptLines = (
Arc<dyn std::any::Any + Send + Sync>,
(Vec<Arc<str>>, Vec<GroupKey>, bool, TableFilters, u64),
Arc<Lines>,
);
const OVERSCAN: usize = 8;
const OVERSCAN_COLUMNS: usize = 2;
const FIRST_ROWS: usize = 40;
const FIRST_WIDTH: f32 = 1920.0;
struct HostState {
scroll: ScrollState,
tracks: Mutex<Option<(Vec<TrackSpec>, ColumnTracks)>>,
built: Mutex<Vec<usize>>,
columns_built: Mutex<Option<Arc<Vec<bool>>>>,
focused_column: Mutex<Option<usize>>,
resized: Mutex<HashMap<Arc<str>, f32>>,
draft_text: Signal<String>,
draft_number: Signal<Option<f64>>,
draft_choice: Signal<usize>,
editing: Mutex<Option<Editing>>,
pending_focus: Mutex<Option<FocusAim>>,
cell_refs: Mutex<HashMap<(usize, usize), ElementRef>>,
scroll_ref: ElementRef,
drag_anchor: Mutex<Option<(usize, usize)>>,
drag_last: Mutex<Option<(usize, usize)>>,
menu_open: Mutex<Option<Arc<str>>>,
menu_anchor: ElementRef,
submenu_open: Signal<bool>,
submenu_anchor: ElementRef,
export_open: Signal<bool>,
export_anchor: ElementRef,
bar_query: Signal<String>,
bar_density: Signal<u8>,
bar_filter: (Signal<bool>, ElementRef),
bar_columns: (Signal<bool>, ElementRef),
bar_export: (Signal<bool>, ElementRef),
export_now: Mutex<Option<Arc<dyn Fn(ExportScope, ExportFormat) + Send + Sync>>>,
export_selected: Mutex<bool>,
own_search: Mutex<String>,
bar_chose: Mutex<bool>,
header_refs: Mutex<HashMap<usize, ElementRef>>,
summaries: Mutex<HashMap<SummaryKey, Arc<Vec<Said>>>>,
header_drop: Mutex<Option<(usize, Option<usize>)>>,
lines: Mutex<Arc<Lines>>,
key_index: Mutex<KeptIndex>,
kept_lines: Mutex<Option<KeptLines>>,
heights: Arc<Mutex<Heights>>,
filter_open: Signal<bool>,
filter_anchor: ElementRef,
filters: FilterState,
search: Mutex<SearchState>,
find_open: Signal<bool>,
find_query: Signal<String>,
find_case: Signal<bool>,
find_word: Signal<bool>,
find_regex: Signal<bool>,
own_id: Arc<str>,
source: Mutex<Option<Box<dyn std::any::Any + Send>>>,
source_query: Mutex<Option<(GridQuery, Vec<Arc<dyn Fn(&GridQuery) + Send + Sync>>)>>,
group_toggle: Mutex<Option<Arc<dyn Fn(usize, bool) + Send + Sync>>>,
tree_toggle: Mutex<Option<Arc<dyn Fn(usize, bool) + Send + Sync>>>,
detail_toggle: Mutex<Option<Arc<dyn Fn(usize, bool) + Send + Sync>>>,
metrics: Mutex<Metrics>,
focused: Mutex<Option<usize>>,
revealed: Mutex<Option<u64>>,
revision: Signal<u64>,
}
impl HostState {
fn range(&self, margin: usize) -> Option<(usize, usize)> {
self.range_at(self.scroll.scroll_y(), margin)
}
fn range_at(&self, scroll_y: f32, margin: usize) -> Option<(usize, usize)> {
let metrics = *self.metrics.lock();
let viewport = self.scroll.viewport_height();
if metrics.row_height <= 0.0 || viewport <= 0.0 || metrics.count == 0 {
return None;
}
let heights = self.heights.lock();
let first = heights.position_at(scroll_y.max(0.0));
let last = heights.position_at(scroll_y.max(0.0) + viewport) + 1;
Some((first.saturating_sub(margin), (last + margin).min(metrics.count)))
}
fn measured(&self, position: usize, height: f32) -> bool {
let scroll_y = self.scroll.scroll_y();
let change = {
let mut heights = self.heights.lock();
let anchor = heights.position_at(scroll_y);
let change = heights.measure(position, height);
if position >= anchor { 0.0 } else { change }
};
if change != 0.0 {
self
.scroll
.set_scroll(self.scroll.scroll_x(), (scroll_y + change).max(0.0));
}
change != 0.0
}
fn needs_rows(&self) -> bool {
let (Some((first, last)), Some((far_first, far_last))) = (self.range(OVERSCAN / 2), self.range(OVERSCAN * 2))
else {
return false;
};
let focused = *self.focused.lock();
let built = self.built.lock();
(first..last).any(|index| !built.contains(&index))
|| built
.iter()
.any(|index| (*index < far_first || *index >= far_last) && Some(*index) != focused)
}
fn rebuild(&self) {
self.revision.update(|revision| *revision = revision.wrapping_add(1));
}
fn columns_at(&self, scroll_x: f32) -> Option<Vec<bool>> {
let metrics = *self.metrics.lock();
let tracks = self.tracks.lock().as_ref()?.1.clone();
let viewport = match self.scroll.viewport_width() {
width if width > 0.0 => width,
_ => FIRST_WIDTH,
};
let available = (viewport - metrics.padding_start - metrics.padding_end).max(0.0);
let widths = tracks.widths(Some(available), 0.0);
let columns = widths.len().saturating_sub(metrics.lead_tracks);
let mut x = metrics.padding_start;
let mut seen = vec![false; columns];
for (track, width) in widths.iter().enumerate() {
if let Some(column) = track.checked_sub(metrics.lead_tracks) {
seen[column] = x + width >= scroll_x && x <= scroll_x + viewport;
}
x += width;
}
if seen.iter().all(|seen| *seen) {
return None;
}
let mut built = seen.clone();
for (column, seen) in seen.iter().enumerate() {
if *seen {
let (from, to) = (
column.saturating_sub(OVERSCAN_COLUMNS),
(column + OVERSCAN_COLUMNS + 1).min(columns),
);
built[from..to].iter_mut().for_each(|built| *built = true);
}
}
let (start, end) = metrics.pins;
built[..start.min(columns)].iter_mut().for_each(|built| *built = true);
built[columns.saturating_sub(end)..]
.iter_mut()
.for_each(|built| *built = true);
if let Some(column) = *self.focused_column.lock()
&& column < columns
{
built[column] = true;
}
Some(built)
}
fn needs_columns(&self, scroll_x: f32) -> bool {
let wanted = self.columns_at(scroll_x);
let built = self.columns_built.lock().clone();
match (wanted, built) {
(None, None) => false,
(None, Some(built)) => built.iter().any(|built| !built),
(Some(_), None) => false,
(Some(wanted), Some(built)) => {
wanted
.iter()
.zip(built.iter())
.enumerate()
.any(|(column, (wanted, built))| *wanted && !built && self.seen_at(column, scroll_x))
}
}
}
fn seen_at(&self, column: usize, scroll_x: f32) -> bool {
let metrics = *self.metrics.lock();
let Some(tracks) = self.tracks.lock().as_ref().map(|(_, tracks)| tracks.clone()) else {
return true;
};
let viewport = self.scroll.viewport_width();
let available = (viewport - metrics.padding_start - metrics.padding_end).max(0.0);
let widths = tracks.widths(Some(available), 0.0);
let track = column + metrics.lead_tracks;
let x = metrics.padding_start + widths[..track.min(widths.len())].iter().sum::<f32>();
let width = widths.get(track).copied().unwrap_or(0.0);
x + width >= scroll_x && x <= scroll_x + viewport
}
}
struct TableProps<R, K> {
table: Arc<Mutex<Table<R, K>>>,
}
impl<R, K> PartialEq for TableProps<R, K> {
fn eq(&self, _: &Self) -> bool {
false
}
}
impl<R, K> crate::app::component::DevtoolsInspectable for TableProps<R, K> {}
struct TableHost<R, K> {
state: Arc<HostState>,
own_range: Arc<Mutex<Option<CellRange<K>>>>,
own_layout: Arc<Mutex<Option<ColumnLayout>>>,
own_open: Arc<Mutex<Vec<GroupKey>>>,
own_expanded: Arc<Mutex<Vec<K>>>,
own_details: Arc<Mutex<Vec<K>>>,
_marker: PhantomData<fn() -> R>,
}
impl<R: Send + Sync + 'static, K: Clone + Eq + Hash + Send + Sync + 'static> TableHost<R, K> {
fn started(self, ctx: &mut Ctx) -> Self {
let source = ctx.props::<TableProps<R, K>>().table.lock().source.clone();
if let Some(source) = source {
source.start(ctx, &mut self.state.source.lock());
}
self
}
fn grid_bar(&self, ctx: &mut Ctx, table: &Table<R, K>) -> Element {
use super::{
Choice, InputSize, SearchField, SearchFieldPart, Tag, TagPart, TagVariant, ToggleGroup, ToggleGroupPart, Toolbar,
ToolbarItem, ToolbarPart,
button::{Button, ButtonPart, ButtonSize, ButtonVariant},
};
let state = &self.state;
let words = table.words.bar.clone();
if state.bar_query.get_untracked() != *table.search {
state.bar_query.set(table.search.to_string());
}
let (write, heard) = (table.write_search.clone(), table.on_search_change.clone());
let id_of = |what: &str| table.id.as_ref().map(|id| format!("{id}-{what}"));
let mut search = SearchField::new(state.bar_query.clone())
.placeholder(&words.search)
.label(&words.search)
.size(InputSize::Sm)
.clearable(false)
.style(SearchFieldPart::Root, |s| s.width(220.0))
.on_input(move |event| {
if let Some(write) = &write {
write(event.new_value.clone());
}
for handler in &heard {
handler(&event.new_value);
}
});
if let Some(id) = id_of("bar-search") {
search = search.id(id);
}
let mut bar = Toolbar::new()
.label(&words.bar)
.overflow(true)
.style(ToolbarPart::Root, |s| {
s.width(Length::Fill)
.height(52.0)
.padding_x(12.0)
.gap(8.0)
.radius(RadiusSize::Lg)
})
.item(ToolbarItem::element(search).stays(true));
let change_filters = table.filter_changer();
let titles: HashMap<Arc<str>, Arc<str>> = table
.arranged
.as_ref()
.map(|arranged| arranged.1.iter().cloned().collect())
.unwrap_or_default();
for (id, filter) in table.filters.iter() {
let title = titles.get(id).cloned().unwrap_or_else(|| Arc::from(id));
let (change, now, id) = (change_filters.clone(), table.filters.clone(), id.to_owned());
let tag_id = id_of(&format!("bar-filter-{id}"));
let mut tag = Tag::new(&format!("{title}: {}", export::filter_said(filter)))
.variant(TagVariant::Info)
.on_remove(move || {
if let Some(change) = &change {
change(now.clone().without(&id));
}
})
.style(TagPart::Root, |s| s.height(26.0))
.style(TagPart::Label, |s| s.font_size(12.0));
if let Some(tag_id) = tag_id {
tag = tag.id(tag_id);
}
bar = bar.item(ToolbarItem::element(tag));
}
let filtering: Vec<(Arc<str>, Arc<str>)> = table
.columns
.iter()
.filter(|column| column.filter.is_some())
.map(|column| (column.id.clone(), column.title.clone()))
.collect();
if !filtering.is_empty() && change_filters.is_some() {
let (open, anchor) = state.bar_filter.clone();
let menu = Menu::new(open.clone(), anchor.clone())
.label(&words.filter)
.items(filtering.into_iter().map(|(id, title)| {
let host = state.clone();
MenuItem::new(&title).on_select(move || {
*host.filters.column.lock() = Some(id.clone());
host.filter_open.set(true);
host.rebuild();
})
}))
.build(¤t_theme());
let mut button = Button::new(&words.filter)
.icon(icons::PLUS)
.variant(ButtonVariant::Outline)
.size(ButtonSize::Xs)
.style(ButtonPart::Root, |s| s.height(26.0).padding_x(8.0).gap(4.0))
.style(ButtonPart::Icon, |s| s.square(12.0))
.style(ButtonPart::Label, |s| s.font_size(12.0))
.on_click(move |_| open.update(|open| *open = !*open));
if let Some(id) = id_of("bar-filter") {
button = button.id(id);
}
bar = bar.item(ToolbarItem::element(
Row::new()
.overflow_visible()
.ref_element(anchor)
.child(button.build(¤t_theme()))
.child(menu),
));
}
bar = bar.item(Toolbar::spacer());
let rebuild = state.clone();
bar = bar.item(
ToggleGroup::new(
state.bar_density.clone(),
[
Choice::new(2u8, &words.comfortable).icon(icons::ROWS_2).icon_only(true),
Choice::new(3u8, &words.default).icon(icons::ROWS_3).icon_only(true),
Choice::new(4u8, &words.compact).icon(icons::ROWS_4).icon_only(true),
],
)
.on_change(move |_| {
*rebuild.bar_chose.lock() = true;
rebuild.rebuild();
})
.style(ToggleGroupPart::Item, |s| s.square(30.0))
.label(&words.density)
.id(id_of("bar-density").unwrap_or_else(|| "bar-density".to_owned())),
);
if let (Some(arranged), Some(change)) = (table.arranged.clone(), table.layout_changer()) {
let (open, anchor) = state.bar_columns.clone();
let (layout, titles) = &*arranged;
let shown = layout.columns.iter().filter(|place| !place.hidden).count();
let menu = Menu::new(open.clone(), anchor.clone())
.label(&words.columns)
.items(titles.iter().map(|(id, title)| {
let hidden = layout.place(id).is_some_and(|place| place.hidden);
let (change, layout, id) = (change.clone(), layout.clone(), id.clone());
MenuItem::new(title)
.checked(!hidden)
.disabled(!hidden && shown == 1)
.on_select(move || change(layout.clone().with_hidden(&id, !hidden)))
}))
.build(¤t_theme());
let mut button = Button::new(&words.columns)
.trailing_icon(icons::CHEVRON_DOWN)
.variant(ButtonVariant::Outline)
.style(ButtonPart::Root, |s| s.height(30.0).padding_start(14.0).padding_end(10.0))
.on_click(move |_| open.update(|open| *open = !*open));
if let Some(id) = id_of("bar-columns") {
button = button.id(id);
}
bar = bar.item(ToolbarItem::element(
Row::new()
.overflow_visible()
.ref_element(anchor)
.child(button.build(¤t_theme()))
.child(menu),
));
}
if table.export {
let (open, anchor) = state.bar_export.clone();
let selected = *state.export_selected.lock();
let export = |scope: ExportScope, format: ExportFormat| {
let host = state.clone();
move || {
let now = host.export_now.lock().clone();
if let Some(now) = now {
now(scope, format);
}
}
};
let labels = table.words.export.clone();
let menu = Menu::new(open.clone(), anchor.clone())
.label(&words.export)
.item(MenuItem::new(&labels.shown_csv).on_select(export(ExportScope::Shown, ExportFormat::Csv)))
.item(MenuItem::new(&labels.shown_tsv).on_select(export(ExportScope::Shown, ExportFormat::Tsv)))
.item(
MenuItem::new(&labels.selected_csv)
.disabled(!selected)
.on_select(export(ExportScope::Selected, ExportFormat::Csv)),
)
.item(
MenuItem::new(&labels.selected_tsv)
.disabled(!selected)
.on_select(export(ExportScope::Selected, ExportFormat::Tsv)),
)
.build(¤t_theme());
let mut button = Button::new(&words.export)
.icon(icons::DOWNLOAD)
.variant(ButtonVariant::Outline)
.style(ButtonPart::Root, |s| s.height(30.0).padding_x(10.0))
.on_click(move |_| open.update(|open| *open = !*open));
if let Some(id) = id_of("bar-export") {
button = button.id(id);
}
bar = bar.item(ToolbarItem::element(
Row::new()
.overflow_visible()
.ref_element(anchor)
.child(button.build(¤t_theme()))
.child(menu),
));
}
if let Some(id) = id_of("bar") {
bar = bar.id(id);
}
bar.key("grid-bar").mount(ctx)
}
fn find_bar(&self, ctx: &mut Ctx, table: &Table<R, K>) -> Element {
let state = &self.state;
if state.find_query.get_untracked() != *table.search {
state.find_query.set(table.search.to_string());
}
let matches = state.search.lock().matches();
let (write, heard) = (table.write_search.clone(), table.on_search_change.clone());
let (next, previous) = (state.clone(), state.clone());
let mut bar = super::find_bar::FindBar::new(state.find_query.clone())
.open(state.find_open.clone())
.match_case(state.find_case.clone())
.whole_word(state.find_word.clone())
.matches(matches.current.map_or(0, |current| current + 1), matches.count)
.on_query(move |query: &str| {
if let Some(write) = &write {
write(query.to_owned());
}
for handler in &heard {
handler(query);
}
})
.on_next(move || {
next.step_match(1);
next.rebuild();
})
.on_previous(move || {
previous.step_match(-1);
previous.rebuild();
});
if let Some(with) = &table.find_bar_with {
bar = with(bar);
}
bar.mount(ctx)
}
}
impl<R: Send + Sync + 'static, K: Clone + Eq + Hash + Send + Sync + 'static> Component for TableHost<R, K> {
type Props = TableProps<R, K>;
fn create(ctx: &mut Ctx) -> Self {
Self {
state: Arc::new(HostState {
scroll: ScrollState::new(),
tracks: Mutex::new(None),
built: Mutex::new(Vec::new()),
columns_built: Mutex::new(None),
focused_column: Mutex::new(None),
resized: Mutex::new(HashMap::new()),
draft_text: ctx.signal(String::new()),
draft_number: ctx.signal(None),
draft_choice: ctx.signal(0),
editing: Mutex::new(None),
pending_focus: Mutex::new(None),
cell_refs: Mutex::new(HashMap::new()),
scroll_ref: ElementRef::new(),
drag_anchor: Mutex::new(None),
drag_last: Mutex::new(None),
menu_open: Mutex::new(None),
menu_anchor: ElementRef::new(),
submenu_open: ctx.signal(false),
submenu_anchor: ElementRef::new(),
export_open: ctx.signal(false),
export_anchor: ElementRef::new(),
bar_query: ctx.signal(String::new()),
bar_density: ctx.signal(0_u8),
bar_filter: (ctx.signal(false), ElementRef::new()),
bar_columns: (ctx.signal(false), ElementRef::new()),
bar_export: (ctx.signal(false), ElementRef::new()),
export_now: Mutex::new(None),
export_selected: Mutex::new(false),
own_search: Mutex::new(String::new()),
bar_chose: Mutex::new(false),
header_refs: Mutex::new(HashMap::new()),
summaries: Mutex::new(HashMap::new()),
header_drop: Mutex::new(None),
lines: Mutex::new(Arc::new(Lines::default())),
key_index: Mutex::default(),
kept_lines: Mutex::default(),
heights: Arc::default(),
filter_open: ctx.signal(false),
filter_anchor: ElementRef::new(),
filters: FilterState::default(),
search: Mutex::default(),
find_open: ctx.signal(false),
find_query: ctx.signal(String::new()),
find_case: ctx.signal(false),
find_word: ctx.signal(false),
find_regex: ctx.signal(false),
own_id: {
static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
Arc::from(format!(
"grid-{}",
NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
))
},
source: Mutex::new(None),
source_query: Mutex::new(None),
group_toggle: Mutex::new(None),
tree_toggle: Mutex::new(None),
detail_toggle: Mutex::new(None),
metrics: Mutex::new(Metrics::default()),
focused: Mutex::new(None),
revealed: Mutex::new(None),
revision: ctx.signal(0_u64),
}),
own_range: Arc::new(Mutex::new(None)),
own_layout: Arc::new(Mutex::new(None)),
own_open: Arc::new(Mutex::new(Vec::new())),
own_expanded: Arc::new(Mutex::new(Vec::new())),
own_details: Arc::new(Mutex::new(Vec::new())),
_marker: PhantomData,
}
.started(ctx)
}
fn render(&self, ctx: &mut Ctx) -> impl Into<Element> {
let mut table = ctx.props::<TableProps<R, K>>().table.lock().clone();
if table.grid && table.id.is_none() {
table.id = Some(self.state.own_id.clone());
}
if let Some(source) = table.source.clone() {
let query = GridQuery {
sort: table.sort.clone(),
filters: table.filters.clone(),
search: table.search.to_string(),
};
let (rows, _) = source.rows(&mut self.state.source.lock(), &query);
table.rows = rows;
table.group_by.clear();
if let Some(query) = source.untold(&mut self.state.source.lock()) {
*self.state.source_query.lock() = Some((query, table.on_query_change.clone()));
}
}
let _ = self.state.revision.get();
table.resized = Arc::new(self.state.resized.lock().clone());
if table.grid && table.write_cell_range.is_none() {
table.cell_range = self.own_range.lock().clone();
let (own, state) = (self.own_range.clone(), self.state.clone());
table.write_cell_range = Some(Arc::new(move |next| {
*own.lock() = next;
state.rebuild();
}));
}
if !table.group_by.is_empty() && table.write_open.is_none() {
table.open_groups = self.own_open.lock().clone();
let (own, state) = (self.own_open.clone(), self.state.clone());
table.write_open = Some(Arc::new(move |next| {
*own.lock() = next;
state.rebuild();
}));
}
if table.grid && table.toolbar {
if table.write_search.is_none() {
table.search = Arc::from(self.state.own_search.lock().as_str());
let (own, state) = (self.state.clone(), self.state.clone());
table.write_search = Some(Arc::new(move |next| {
*own.own_search.lock() = next;
state.rebuild();
}));
}
let chosen = self.state.bar_density.get();
if *self.state.bar_chose.lock() {
table.density = Some(density_of(chosen));
} else {
let now = density_code(table.density.unwrap_or_else(|| current_theme().density()));
if chosen != now {
self.state.bar_density.set(now);
}
}
}
if table.tree_parent.is_some() && table.write_expanded.is_none() {
table.expanded = self.own_expanded.lock().clone();
let (own, state) = (self.own_expanded.clone(), self.state.clone());
table.write_expanded = Some(Arc::new(move |next| {
*own.lock() = next;
state.rebuild();
}));
}
if table.detail.is_some() && table.write_details.is_none() {
table.details_open = self.own_details.lock().clone();
let (own, state) = (self.own_details.clone(), self.state.clone());
table.write_details = Some(Arc::new(move |next| {
*own.lock() = next;
state.rebuild();
}));
}
table.find_grouping();
if table.grid {
if table.write_column_layout.is_none() {
table.column_layout = self.own_layout.lock().clone();
let (own, state) = (self.own_layout.clone(), self.state.clone());
table.write_column_layout = Some(Arc::new(move |next| {
*own.lock() = Some(next);
state.rebuild();
}));
}
let columns = std::mem::take(&mut table.columns);
let full = table.column_layout.clone().unwrap_or_default().full(&columns);
let titles = full
.columns
.iter()
.filter_map(|place| {
let column = columns.iter().find(|column| column.id == place.id)?;
Some((column.id.clone(), column.title.clone()))
})
.collect();
table.columns = full.arrange(columns);
table.arranged = Some(Arc::new((full, titles)));
}
let theme = current_theme();
let state = &self.state;
let specs = table.track_specs(&theme);
let tracks = {
let mut held = state.tracks.lock();
match &*held {
Some((kept, tracks)) if *kept == specs => tracks.clone(),
_ => {
let tracks = ColumnTracks::new(specs.clone());
*held = Some((specs, tracks.clone()));
*state.heights.lock() = Heights::default();
tracks
}
}
};
let recipe = table.resolve(&theme, &table.case());
let row_height = px(recipe.part(TablePart::Row).rest().height, &theme).unwrap_or(0.0);
let header_height = px(recipe.part(TablePart::Header).rest().height, &theme).unwrap_or(0.0);
let lines = {
let mut kept = state.kept_lines.lock();
let wanted = (
table
.grouping
.iter()
.map(|column| column.id.clone())
.collect::<Vec<_>>(),
table.open_groups.clone(),
table.summarized(),
table.filters.clone(),
{
use std::hash::Hasher;
let mut hasher = std::collections::hash_map::DefaultHasher::new();
(table.tree_parent.is_some(), &table.expanded).hash(&mut hasher);
(table.detail.is_some(), &table.details_open).hash(&mut hasher);
hasher.finish()
},
);
match &*kept {
Some((rows, held, lines))
if held == &wanted
&& rows
.downcast_ref::<Arc<Vec<R>>>()
.is_some_and(|rows| Arc::ptr_eq(rows, &table.rows)) =>
{
lines.clone()
}
_ => {
let lines = Arc::new(table.lines());
*kept = Some((Arc::new(table.rows.clone()), wanted, lines.clone()));
lines
}
}
};
*state.lines.lock() = lines.clone();
let count = lines.len();
{
let mut heights = state.heights.lock();
if !heights.is_for(row_height, count) {
*heights = Heights::new(row_height, count);
}
}
let geometry = Geometry::of(&recipe);
let pins = table.pins();
let lead_tracks = table.lead_tracks();
*state.metrics.lock() = Metrics {
row_height,
header_height,
count,
disabled: table.disabled,
padding_start: if pins.0 > 0 || table.numbered() {
0.0
} else {
geometry.padding_start
},
padding_end: if pins.1 > 0 { 0.0 } else { geometry.padding_end },
lead_tracks,
pins,
};
let columns_built = state.columns_at(state.scroll.scroll_x()).map(Arc::new);
*state.columns_built.lock() = columns_built.clone();
let searched = (!table.search.is_empty() && table.source.is_none()).then(|| {
let options = super::highlight::FindOptions {
match_case: state.find_case.get() || table.search_options.match_case,
whole_word: state.find_word.get() || table.search_options.whole_word,
regex: state.find_regex.get() || table.search_options.regex,
};
let texts: Vec<Option<TextFn<R>>> = table
.columns
.iter()
.map(|column| match &column.content {
Content::Text(text) => Some(text.clone()),
_ => None,
})
.collect();
let ids = table.columns.iter().map(|column| column.id.clone()).collect();
let mut search = state.search.lock();
search.heard = table.on_matches_change.clone();
let found = search.find(&table.rows, &lines, ids, &texts, &table.search, options);
(found, search.current)
});
if searched.is_none() {
let mut search = state.search.lock();
search.heard = table.on_matches_change.clone();
search.find(
&table.rows,
&lines,
Vec::new(),
&[],
"",
super::highlight::FindOptions::default(),
);
}
let window = (row_height > 0.0).then(|| {
let (first, last) = state.range(OVERSCAN).unwrap_or((0, FIRST_ROWS.min(count)));
let focused = state.focused.lock().filter(|index| *index < count);
let mut indices: Vec<usize> = (first..last.min(count)).collect();
if let Some(focused) = focused
&& !indices.contains(&focused)
{
indices.push(focused);
indices.sort_unstable();
}
*state.built.lock() = indices.clone();
let refs: HashMap<usize, ElementRef> = indices.iter().map(|index| (*index, ElementRef::new())).collect();
if table.tall() {
for (position, reference) in &refs {
let (watcher, position) = (state.clone(), *position);
reference.observe_rect_before_paint(move |rect| {
if watcher.measured(position, rect.height) {
watcher.rebuild();
}
});
}
}
let cell_refs: HashMap<(usize, usize), ElementRef> = if table.grid {
let built = |column: usize| columns_built.as_ref().is_none_or(|built| built[column]);
indices
.iter()
.filter_map(|position| lines.rank_at(*position))
.flat_map(|row| {
(0..table.columns.len())
.filter(|column| built(*column))
.map(move |column| ((row, column), ElementRef::new()))
})
.collect()
} else {
HashMap::new()
};
*state.cell_refs.lock() = cell_refs.clone();
let editor_ref = ElementRef::new();
let pending = *state.pending_focus.lock();
match pending {
Some(FocusAim::Editor) => {
ctx.focus(&editor_ref);
*state.pending_focus.lock() = None;
}
Some(FocusAim::Cell(row, column)) => match cell_refs.get(&(row, column)) {
Some(target) => {
ctx.focus(target);
*state.pending_focus.lock() = None;
}
None
if lines
.position_of(row)
.is_some_and(|position| !indices.contains(&position)) =>
{
state.reveal(lines.position_of(row).unwrap_or(row))
}
None => *state.pending_focus.lock() = None,
},
None => {}
}
let watcher = state.clone();
let on_scroll: Arc<dyn Fn(ScrollEvent) + Send + Sync> = Arc::new(move |event: ScrollEvent| {
let metrics = *watcher.metrics.lock();
let scroll_y = (watcher.scroll.scroll_y() - event.delta_y).max(0.0);
let Some((first, last)) = watcher.range_at(scroll_y, 0) else {
return;
};
let built = watcher.built.lock().clone();
let scroll_x = (watcher.scroll.scroll_x() - event.delta_x).max(0.0);
if (first.saturating_sub(OVERSCAN / 2)..(last + OVERSCAN / 2).min(metrics.count))
.any(|index| !built.contains(&index))
|| watcher.needs_columns(scroll_x)
{
watcher.rebuild();
}
});
Window {
indices,
focused,
row_height,
scroll: state.scroll.clone(),
refs,
cell_refs,
editor_ref,
columns: columns_built,
host: Some(Arc::new(HostLink { state: state.clone() })),
rows: state.clone(),
lines: lines.clone(),
on_scroll: Some(on_scroll),
search: searched.clone(),
}
});
let slots = table.source.clone().map(|source| {
if let Some(window) = &window
&& let (Some(first), Some(last)) = (window.indices.first(), window.indices.last())
{
source.want(&mut state.source.lock(), *first, *last);
}
let slots = source.slots(&mut state.source.lock());
let (again, retried) = (source.clone(), state.clone());
let retry: Arc<dyn Fn(usize) + Send + Sync> = Arc::new(move |index| {
again.retry(&mut retried.source.lock(), index);
retried.rebuild();
});
(slots, retry)
});
table.slots = slots;
let find = table.find_bar.then(|| self.find_bar(ctx, &table));
let view = table.view(&theme, tracks, window);
let mut element = match theme.renderer::<Table<R, K>>() {
Some(renderer) => renderer(view),
None => view.render(),
};
if table.grid && table.toolbar {
let bar = self.grid_bar(ctx, &table);
element = Column::new()
.spacing(8.0)
.width(Dimension::Pct(100.0))
.child(bar)
.child(element)
.into();
}
if !table.find_bar && table.search.is_empty() {
return element;
}
let (keys, opens) = (state.clone(), table.find_bar);
let mut stack = components::Stack::new()
.width(Dimension::Pct(100.0))
.on_key_down(move |event: KeyboardEvent| {
let command = event.ctrl || event.meta;
if event.key == "F3" {
event.prevent_default();
keys.step_match(if event.shift { -1 } else { 1 });
keys.rebuild();
} else if opens && command && !event.alt && (event.code == "KeyF" || event.key.eq_ignore_ascii_case("f")) {
event.prevent_default();
keys.find_open.set(true);
}
})
.child(element);
if let Some(bar) = find {
stack = stack.child(bar);
}
stack.into()
}
fn after_layout(&self) {
if self.state.needs_rows() || self.state.needs_columns(self.state.scroll.scroll_x()) {
self.state.rebuild();
}
let props_source = self.state.source_query.lock().take();
if let Some((query, heard)) = props_source {
for handler in &heard {
handler(&query);
}
}
let untold = self.state.search.lock().untold();
if let Some((matches, heard)) = untold {
for handler in &heard {
handler(matches);
}
}
}
}
impl<R: Send + Sync + 'static, K: Clone + Eq + Hash + Send + Sync + 'static> crate::ui::Styled for Table<R, K> {
type Component = Self;
fn rules(self, rules: &crate::ui::Recipe) -> Self {
Self::rules(self, rules)
}
fn state(self, state: impl Into<crate::ui::Name>, on: bool) -> Self {
Self::state(self, state, on)
}
}
impl<R: Send + Sync + 'static, K: Send + Sync + 'static> Themed for Table<R, K> {
const NAME: &'static str = "table";
type Renderer = TableRenderer;
fn parts() -> crate::ui::Declared {
TablePart::declared()
}
fn states() -> crate::ui::Declared {
TableState::declared()
}
fn recipe() -> Recipe {
use PaletteColor::{Background, Foreground, Highlight, Muted, MutedForeground, Ring, StateHover, StatePressed};
use TablePart::{
Count, Empty, FilterIcon, FilterLabel, FilterRow, Footer, Header, HeaderCell, Root, Row, Select, SortIcon,
SortOrder,
};
use TableState::{Disabled, Last, Numeric, Selectable, Selected, Sortable, Sorted};
let line = || Line::inside(BorderSize::Sm, PaletteColor::Border);
let range_edge = || Line::inside(BorderSize::Md, Ring);
Recipe::new()
.base(Root, |s| {
s.width(Length::Fill)
.radius(RadiusSize::Lg)
.border(line())
.background(Background)
.foreground(Foreground)
})
.base(TablePart::Scroll, |s| s.radius(RadiusSize::Lg))
.state(TableState::Footer, TablePart::Scroll, |s| {
s.corners(RadiusSize::Lg, RadiusSize::Lg, 0.0, 0.0)
})
.base(Header, |s| {
s.height(40.0)
.padding_x(16.0)
.gap(16.0)
.background(PaletteColor::Bar)
.underline(line())
})
.base(HeaderCell, |s| {
s.gap(4.0)
.typography(TypographyStyle::Body)
.font_size(13.0)
.weight(FontWeight::Medium)
.foreground(MutedForeground)
})
.base(SortIcon, |s| s.square(IconSize::Sm))
.base(FilterIcon, |s| s.square(IconSize::Sm).foreground(Foreground))
.base(FilterLabel, |s| {
s.typography(TypographyStyle::Body)
.font_size(12.0)
.foreground(MutedForeground)
})
.base(FilterRow, |s| {
s.height(44.0)
.padding_x(16.0)
.gap(16.0)
.background(Background)
.underline(line())
})
.base(SortOrder, |s| {
s.typography(TypographyStyle::Mono)
.font_size(11.0)
.foreground(MutedForeground)
})
.base(TablePart::Resizer, |s| s.width(8.0).cursor(CursorIcon::ColResize))
.base(TablePart::ResizeLine, |s| s.width(2.0).radius(RadiusSize::Full))
.base(TablePart::MenuTrigger, |s| {
fading(
s.square(24.0)
.radius(RadiusSize::Sm)
.foreground(MutedForeground)
.cursor(CursorIcon::Pointer)
.opacity(0.0),
)
})
.within(TablePart::MenuTrigger, |s| s.opacity(1.0))
.state(TableState::Open, TablePart::MenuTrigger, |s| s.opacity(1.0).background(Muted))
.hovered(TablePart::MenuTrigger, |s| s.veil(StateHover).foreground(Foreground))
.state(TableState::DropBefore, TablePart::DropLine, |s| s.start_line(range_edge()))
.state(TableState::DropAfter, TablePart::DropLine, |s| s.end_line(range_edge()))
.within_hovered(TablePart::ResizeLine, |s| s.background(Ring))
.within_pressed(TablePart::ResizeLine, |s| s.background(Ring))
.state(Sortable, HeaderCell, |s| fading(s.radius(RadiusSize::Sm).cursor(CursorIcon::Pointer)))
.hovered(HeaderCell, |s| s.foreground(Foreground))
.focus_visible(HeaderCell, |s| s.focus_ring())
.state(Sorted, HeaderCell, |s| s.foreground(Foreground))
.base(Row, |s| {
fading(
s.height(44.0)
.padding_x(16.0)
.gap(16.0)
.underline(line())
.cursor(CursorIcon::Pointer),
)
})
.hovered(Row, |s| s.veil(StateHover))
.pressed(Row, |s| s.veil(StatePressed))
.focus_visible(Row, |s| s.outline(Outline::new(BorderSize::Md, Ring).offset(-2.0)))
.state(Selected, Row, |s| s.background(Highlight))
.state(Last, Row, |s| s.underline(Line::inside(0.0, PaletteColor::Border)))
.state(Selectable, Header, |s| s.gap(12.0))
.state(Selectable, Row, |s| s.gap(12.0))
.base(TablePart::Cell, |s| {
s.typography(TypographyStyle::Body)
.font_size(13.0)
.foreground(Foreground)
})
.state(TableState::Mono, TablePart::Cell, |s| s.font_family(FontFamily::Mono))
.state(TableState::Muted, TablePart::Cell, |s| s.foreground(MutedForeground))
.state(Numeric, TablePart::Cell, |s| {
s.font_family(FontFamily::Mono)
.font_size(12.0)
.foreground(MutedForeground)
})
.base(Select, |s| s.width(16.0).cursor(CursorIcon::Pointer))
.base(TablePart::RowNumber, |s| {
s.font_family(FontFamily::Mono)
.font_size(12.0)
.foreground(MutedForeground)
})
.state(Selectable, TablePart::RowNumber, |s| s.cursor(CursorIcon::Pointer))
.state(Selected, TablePart::RowNumber, |s| s.foreground(Foreground))
.when(Selector::new().state(TableState::Pinned).within().hovered(), TablePart::RowNumber, |s| {
s.veil(StateHover)
})
.when(Selector::new().state(TableState::Pinned).within().pressed(), TablePart::RowNumber, |s| {
s.veil(StatePressed)
})
.focus_visible(TablePart::Cell, |s| s.outline(Outline::new(BorderSize::Md, Ring).offset(-2.0)))
.base(TablePart::Editor, |s| s.width(Length::Fill))
.state(TableState::InRange, TablePart::Cell, |s| s.background(PaletteColor::Selection))
.state(TableState::RangeTop, TablePart::Cell, |s| s.top_line(range_edge()))
.state(TableState::RangeBottom, TablePart::Cell, |s| s.underline(range_edge()))
.state(TableState::RangeStart, TablePart::Cell, |s| s.start_line(range_edge()))
.state(TableState::RangeEnd, TablePart::Cell, |s| s.end_line(range_edge()))
.when(Selector::new().state(TableState::Pinned).within().hovered(), TablePart::Cell, |s| {
s.veil(StateHover)
})
.when(Selector::new().state(TableState::Pinned).within().pressed(), TablePart::Cell, |s| {
s.veil(StatePressed)
})
.when(Selector::new().state(TableState::Pinned).within().hovered(), Select, |s| s.veil(StateHover))
.when(Selector::new().state(TableState::Pinned).within().pressed(), Select, |s| s.veil(StatePressed))
.base(TablePart::GroupRow, |s| {
fading(
s.height(44.0)
.background(Muted)
.underline(line())
.cursor(CursorIcon::Pointer),
)
})
.hovered(TablePart::GroupRow, |s| s.veil(StateHover))
.pressed(TablePart::GroupRow, |s| s.veil(StatePressed))
.focus_visible(TablePart::GroupRow, |s| s.outline(Outline::new(BorderSize::Md, Ring).offset(-2.0)))
.base(TablePart::Chevron, |s| s.square(IconSize::Sm).foreground(MutedForeground))
.base(TablePart::Detail, |s| {
s.padding_x(16.0)
.padding_y(12.0)
.background(Muted)
.underline(line())
})
.base(TablePart::TreeToggle, |s| {
fading(
s.square(IconSize::Sm)
.radius(RadiusSize::Sm)
.cursor(CursorIcon::Pointer)
.foreground(MutedForeground),
)
})
.hovered(TablePart::TreeToggle, |s| s.foreground(Foreground))
.base(TablePart::GroupLabel, |s| {
s.typography(TypographyStyle::Body)
.font_size(13.0)
.weight(FontWeight::Medium)
.foreground(Foreground)
})
.base(TablePart::GroupCount, |s| {
s.font_family(FontFamily::Mono)
.font_size(12.0)
.foreground(MutedForeground)
})
.density(Density::Compact, TablePart::GroupRow, |s| s.height(Density::Default))
.density(Density::Comfortable, TablePart::GroupRow, |s| s.height(52.0))
.density(Density::Touch, TablePart::GroupRow, |s| s.height(52.0))
.base(TablePart::Summary, |s| {
s.height(44.0)
.padding_x(16.0)
.gap(16.0)
.background(Muted)
.top_line(line())
})
.state(Selectable, TablePart::Summary, |s| s.gap(12.0))
.base(TablePart::SummaryLabel, |s| {
s.typography(TypographyStyle::Body)
.font_size(12.0)
.foreground(MutedForeground)
})
.base(TablePart::SummaryValue, |s| {
s.typography(TypographyStyle::Body)
.font_size(13.0)
.weight(FontWeight::Medium)
.foreground(Foreground)
})
.density(Density::Compact, TablePart::Summary, |s| s.height(Density::Default))
.density(Density::Comfortable, TablePart::Summary, |s| s.height(52.0))
.density(Density::Touch, TablePart::Summary, |s| s.height(52.0))
.base(Empty, |s| s.width(Length::Fill))
.base(Footer, |s| s.min_height(44.0).padding_start(16.0).padding_end(8.0))
.base(Count, |s| {
s.typography(TypographyStyle::Body)
.font_size(13.0)
.foreground(MutedForeground)
})
.density(Density::Compact, Row, |s| s.height(Density::Default))
.density(Density::Compact, Header, |s| s.height(32.0))
.density(Density::Comfortable, Row, |s| s.height(52.0))
.density(Density::Comfortable, Header, |s| s.height(48.0))
.density(Density::Touch, Row, |s| s.height(52.0))
.density(Density::Touch, Header, |s| s.height(48.0))
.state(Disabled, Root, |s| s.opacity(OpacityLevel::Disabled))
.state(Disabled, Row, |s| s.cursor(CursorIcon::Default))
}
}
fn density_code(density: Density) -> u8 {
match density {
Density::Comfortable | Density::Touch => 2,
Density::Compact => 4,
_ => 3,
}
}
fn density_of(code: u8) -> Density {
match code {
2 => Density::Comfortable,
4 => Density::Compact,
_ => Density::Default,
}
}