use std::collections::HashSet;
use crate::theme::Theme;
use iced::alignment::Horizontal;
use iced::widget::{
Space, button, checkbox, column, container, pick_list, row, rule, scrollable, text, text_input,
};
use iced::{Alignment, Element, Length, Padding};
use crate::widgets::h_overflow::HOverflow;
use crate::widgets::min_width::MinWidth;
pub struct DataColumn<'a, T, Message> {
header: String,
width: Length,
col_min_width: Option<f32>,
cell: Box<dyn Fn(&T, usize) -> Element<'a, Message> + 'a>,
sort_key: Option<String>,
align_x: Horizontal,
}
impl<'a, T, Message> DataColumn<'a, T, Message> {
pub fn new(
header: impl Into<String>,
cell: impl Fn(&T, usize) -> Element<'a, Message> + 'a,
) -> Self {
Self {
header: header.into(),
width: Length::Fill,
col_min_width: None,
cell: Box::new(cell),
sort_key: None,
align_x: Horizontal::Left,
}
}
pub fn width(mut self, width: Length) -> Self {
self.width = width;
self
}
pub fn col_min_width(mut self, min: f32) -> Self {
self.col_min_width = Some(min);
self
}
pub fn sortable(mut self, key: impl Into<String>) -> Self {
self.sort_key = Some(key.into());
self
}
pub fn align(mut self, align: Horizontal) -> Self {
self.align_x = align;
self
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SortDirection {
Ascending,
Descending,
}
impl SortDirection {
pub fn toggle(self) -> Self {
match self {
Self::Ascending => Self::Descending,
Self::Descending => Self::Ascending,
}
}
pub fn arrow(self) -> &'static str {
match self {
Self::Ascending => " \u{25B2}",
Self::Descending => " \u{25BC}",
}
}
}
#[derive(Debug, Clone)]
pub struct SortState {
pub key: String,
pub direction: SortDirection,
}
const PAGE_SIZES: &[usize] = &[10, 25, 50, 100];
const SELECT_COL_WIDTH: f32 = 40.0;
pub struct DataTable<'a, T, Message> {
columns: Vec<DataColumn<'a, T, Message>>,
rows: &'a [T],
selected: Option<&'a HashSet<usize>>,
sort: Option<&'a SortState>,
page: usize,
page_size: usize,
show_select_column: bool,
show_separators: bool,
search_query: &'a str,
min_width: Option<f32>,
frozen_columns: usize,
body_height: Option<f32>,
}
impl<'a, T, Message: Clone + 'a> DataTable<'a, T, Message> {
pub fn new(columns: Vec<DataColumn<'a, T, Message>>, rows: &'a [T]) -> Self {
Self {
columns,
rows,
selected: None,
sort: None,
page: 0,
page_size: 25,
show_select_column: false,
show_separators: true,
search_query: "",
min_width: None,
frozen_columns: 0,
body_height: None,
}
}
pub fn selected(mut self, indices: &'a HashSet<usize>) -> Self {
self.selected = Some(indices);
self
}
pub fn sort_state(mut self, state: &'a SortState) -> Self {
self.sort = Some(state);
self
}
pub fn page(mut self, page: usize) -> Self {
self.page = page;
self
}
pub fn page_size(mut self, size: usize) -> Self {
self.page_size = size;
self
}
pub fn select_column(mut self, show: bool) -> Self {
self.show_select_column = show;
self
}
pub fn separators(mut self, show: bool) -> Self {
self.show_separators = show;
self
}
pub fn search(mut self, query: &'a str) -> Self {
self.search_query = query;
self
}
pub fn min_width(mut self, min: f32) -> Self {
self.min_width = Some(min);
self
}
pub fn frozen_columns(mut self, n: usize) -> Self {
self.frozen_columns = n;
self
}
pub fn body_height(mut self, h: f32) -> Self {
self.body_height = Some(h);
self
}
fn is_selected(&self, idx: usize) -> bool {
self.selected.is_some_and(|s| s.contains(&idx))
}
pub fn overflow_min_width(&self) -> f32 {
self.effective_min_width()
}
fn effective_min_width(&self) -> f32 {
if let Some(m) = self.min_width {
return m;
}
let mut total = 0.0;
if self.show_select_column {
total += SELECT_COL_WIDTH;
}
for col in &self.columns {
total += match col.width {
Length::Fixed(px) => px,
_ => col.col_min_width.unwrap_or(0.0),
};
}
total
}
#[allow(clippy::too_many_arguments)]
pub fn view_split(
self,
theme: &'a Theme,
on_row_press: impl Fn(usize) -> Message + 'a,
on_sort: impl Fn(String) -> Message + 'a,
on_select: impl Fn(usize) -> Message + 'a,
on_select_all: Message,
on_page_change: impl Fn(usize) -> Message + 'a,
on_page_size_change: impl Fn(usize) -> Message + 'a,
on_search: impl Fn(String) -> Message + 'a,
) -> (
Element<'a, Message>,
Element<'a, Message>,
Element<'a, Message>,
) {
let total_rows = self.rows.len();
let total_pages = if total_rows == 0 {
1
} else {
total_rows.div_ceil(self.page_size)
};
let page = self.page.min(total_pages.saturating_sub(1));
let start = page * self.page_size;
let end = (start + self.page_size).min(total_rows);
let page_rows = &self.rows[start..end];
let content_width = Length::Fill;
let min_w = self.effective_min_width();
let header_el = self.build_header(
theme,
&on_sort,
&on_select_all,
0..self.columns.len(),
self.show_select_column,
content_width,
);
let body_el = self.build_body(
theme,
page_rows,
start,
&on_row_press,
&on_select,
0..self.columns.len(),
self.show_select_column,
content_width,
);
let (header_el, body_el): (Element<'a, Message>, Element<'a, Message>) = if min_w > 0.0 {
(
HOverflow::new(header_el, min_w).into(),
HOverflow::new(body_el, min_w).into(),
)
} else {
(header_el, body_el)
};
let divider = || rule::horizontal(1).style(theme.rule(&["divider"]));
let footer = {
let showing = if total_rows == 0 {
text("No rows").size(12)
} else {
text(format!("{}\u{2013}{} of {}", start + 1, end, total_rows)).size(12)
};
let size_options: Vec<String> = PAGE_SIZES.iter().map(|s| s.to_string()).collect();
let current_size = self.page_size.to_string();
let page_size_picker =
pick_list(size_options, Some(current_size), move |val: String| {
on_page_size_change(val.parse::<usize>().unwrap_or(25))
})
.text_size(12)
.style(theme.pick_list(&["select"]))
.menu_style(theme.menu(&["select-menu"]));
let mut prev_btn = button(text("<").size(12)).style(theme.button(&["button", "ghost"]));
if page > 0 {
prev_btn = prev_btn.on_press(on_page_change(page - 1));
}
let mut next_btn = button(text(">").size(12)).style(theme.button(&["button", "ghost"]));
if page + 1 < total_pages {
next_btn = next_btn.on_press(on_page_change(page + 1));
}
container(
row![
showing,
Space::new().width(Length::Fill),
page_size_picker,
row![
prev_btn,
text(format!("Page {} / {}", page + 1, total_pages)).size(12),
next_btn
]
.spacing(8)
.align_y(Alignment::Center)
]
.spacing(12)
.align_y(Alignment::Center)
.width(Length::Fill),
)
.style(theme.container(&["table-footer"]))
.padding([8, 12])
.width(Length::Fill)
};
let _ = on_search;
let footer_el: Element<'a, Message> = column![divider(), footer]
.width(Length::Fill)
.spacing(0)
.into();
(header_el, body_el, footer_el)
}
#[allow(clippy::too_many_arguments)]
pub fn view(
self,
theme: &'a Theme,
on_row_press: impl Fn(usize) -> Message + 'a,
on_sort: impl Fn(String) -> Message + 'a,
on_select: impl Fn(usize) -> Message + 'a,
on_select_all: Message,
on_page_change: impl Fn(usize) -> Message + 'a,
on_page_size_change: impl Fn(usize) -> Message + 'a,
on_search: impl Fn(String) -> Message + 'a,
) -> Element<'a, Message> {
let total_rows = self.rows.len();
let total_pages = if total_rows == 0 {
1
} else {
total_rows.div_ceil(self.page_size)
};
let page = self.page.min(total_pages.saturating_sub(1));
let start = page * self.page_size;
let end = (start + self.page_size).min(total_rows);
let page_rows = &self.rows[start..end];
let content_width = Length::Fill;
let search_bar = container(
text_input("Search...", self.search_query)
.on_input(on_search)
.padding(6)
.style(theme.text_input(&["input"])),
)
.padding([0, 8]);
let full_header = self.build_header(
theme,
&on_sort,
&on_select_all,
0..self.columns.len(),
self.show_select_column,
content_width,
);
let full_body = self.build_body(
theme,
page_rows,
start,
&on_row_press,
&on_select,
0..self.columns.len(),
self.show_select_column,
content_width,
);
let body_area: Element<'a, Message> = if let Some(h) = self.body_height {
scrollable(full_body)
.style(theme.scrollable(&["scroll"]))
.height(Length::Fixed(h))
.into()
} else {
full_body
};
let footer = {
let showing = if total_rows == 0 {
text("No rows").size(12)
} else {
text(format!("{}\u{2013}{} of {}", start + 1, end, total_rows)).size(12)
};
let size_options: Vec<String> = PAGE_SIZES.iter().map(|s| s.to_string()).collect();
let current_size = self.page_size.to_string();
let page_size_picker =
pick_list(size_options, Some(current_size), move |val: String| {
let size = val.parse::<usize>().unwrap_or(25);
on_page_size_change(size)
})
.text_size(12)
.style(theme.pick_list(&["select"]))
.menu_style(theme.menu(&["select-menu"]));
let mut prev_btn = button(text("<").size(12)).style(theme.button(&["button", "ghost"]));
if page > 0 {
prev_btn = prev_btn.on_press(on_page_change(page - 1));
}
let mut next_btn = button(text(">").size(12)).style(theme.button(&["button", "ghost"]));
if page + 1 < total_pages {
next_btn = next_btn.on_press(on_page_change(page + 1));
}
let page_label = text(format!("Page {} / {}", page + 1, total_pages)).size(12);
let nav = row![prev_btn, page_label, next_btn]
.spacing(8)
.align_y(Alignment::Center);
container(
row![
showing,
Space::new().width(Length::Fill),
page_size_picker,
nav
]
.spacing(12)
.align_y(Alignment::Center)
.width(Length::Fill),
)
.style(theme.container(&["table-footer"]))
.padding([8, 12])
.width(Length::Fill)
};
let divider = || rule::horizontal(1).style(theme.rule(&["divider"]));
let min_w = self.effective_min_width();
let table_core: Element<'a, Message> = column![full_header, divider(), body_area]
.width(Length::Fill)
.spacing(0)
.into();
let table_core: Element<'a, Message> = if min_w > 0.0 {
HOverflow::new(table_core, min_w).into()
} else {
table_core
};
column![search_bar, table_core, divider(), footer]
.width(Length::Fill)
.spacing(0)
.into()
}
fn build_header(
&self,
theme: &'a Theme,
on_sort: &(impl Fn(String) -> Message + 'a),
on_select_all: &Message,
col_range: std::ops::Range<usize>,
include_select: bool,
row_width: Length,
) -> Element<'a, Message> {
let mut header_row = row![].spacing(0).width(row_width);
if include_select && self.show_select_column {
let total_rows = self.rows.len();
let total_pages = if total_rows == 0 {
1
} else {
total_rows.div_ceil(self.page_size)
};
let page = self.page.min(total_pages.saturating_sub(1));
let start = page * self.page_size;
let end = (start + self.page_size).min(total_rows);
let page_rows = &self.rows[start..end];
let all_on_page = !page_rows.is_empty() && (start..end).all(|i| self.is_selected(i));
let sa_msg = on_select_all.clone();
header_row = header_row.push(
container(
checkbox(all_on_page)
.on_toggle(move |_| sa_msg.clone())
.style(theme.checkbox(&["checkbox"])),
)
.width(Length::Fixed(SELECT_COL_WIDTH))
.center_y(Length::Shrink)
.padding([4, 8]),
);
}
for i in col_range {
let col = &self.columns[i];
let sort_arrow = self
.sort
.filter(|s| col.sort_key.as_deref() == Some(s.key.as_str()))
.map(|s| s.direction.arrow())
.unwrap_or("");
let header_text = text(format!("{}{}", col.header, sort_arrow)).size(13);
let header_cell = container(header_text)
.width(col.width)
.padding([8, 12])
.align_x(col.align_x);
if let Some(ref key) = col.sort_key {
let msg = on_sort(key.clone());
let btn = button(header_cell)
.on_press(msg)
.padding(0)
.width(col.width)
.style(theme.button(&["table-header"]));
if let Some(min) = col.col_min_width {
header_row = header_row.push(MinWidth::new(btn, min));
} else {
header_row = header_row.push(btn);
}
} else if let Some(min) = col.col_min_width {
header_row = header_row.push(MinWidth::new(header_cell, min));
} else {
header_row = header_row.push(header_cell);
}
}
container(header_row)
.style(theme.container(&["table-header"]))
.width(row_width)
.into()
}
fn build_body(
&self,
theme: &'a Theme,
page_rows: &'a [T],
start: usize,
on_row_press: &(impl Fn(usize) -> Message + 'a),
on_select: &(impl Fn(usize) -> Message + 'a),
col_range: std::ops::Range<usize>,
include_select: bool,
row_width: Length,
) -> Element<'a, Message> {
let mut body_col = column![].spacing(0).width(row_width);
for (page_idx, row_data) in page_rows.iter().enumerate() {
let abs_idx = start + page_idx;
let is_selected = self.is_selected(abs_idx);
let mut data_row = row![].spacing(0).width(row_width);
if include_select && self.show_select_column {
let sel_msg = on_select(abs_idx);
data_row = data_row.push(
container(
checkbox(is_selected)
.on_toggle(move |_| sel_msg.clone())
.style(theme.checkbox(&["checkbox"])),
)
.width(Length::Fixed(SELECT_COL_WIDTH))
.center_y(Length::Shrink)
.padding([4, 8]),
);
}
for i in col_range.clone() {
let col = &self.columns[i];
let cell_content = (col.cell)(row_data, abs_idx);
let cell = container(cell_content)
.width(col.width)
.padding([8, 12])
.align_x(col.align_x);
if let Some(min) = col.col_min_width {
data_row = data_row.push(MinWidth::new(cell, min));
} else {
data_row = data_row.push(cell);
}
}
let row_classes: &[&str] = if is_selected {
&["table-row", "selected"]
} else {
&["table-row"]
};
body_col = body_col.push(
button(data_row)
.on_press(on_row_press(abs_idx))
.padding(Padding::ZERO)
.width(row_width)
.style(theme.button(row_classes)),
);
if self.show_separators && page_idx < page_rows.len() - 1 {
body_col = body_col.push(rule::horizontal(1).style(theme.rule(&["divider"])));
}
}
body_col.into()
}
}