use std::{collections::HashMap, sync::Arc};
use super::{TablePart, glyph, icons, pressable};
use crate::{
app::events::{KeyboardEvent, MouseEvent},
components::Row,
core::ElementRef,
layout::{
Alignment,
layout_kind::{Justify, Sticky},
},
node::Element,
ui::recipe::{Name, ResolvedPart, ResolvedRecipe},
};
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct GroupKey {
pub values: Vec<String>,
}
impl crate::app::component::DevtoolsInspectable for GroupKey {}
impl GroupKey {
pub fn new<S: AsRef<str>>(values: impl IntoIterator<Item = S>) -> Self {
Self {
values: values.into_iter().map(|value| value.as_ref().to_owned()).collect(),
}
}
pub fn level(&self) -> usize {
self.values.len()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Shown {
Row(usize),
Group(usize),
Summary(usize),
Detail(usize),
}
#[derive(Clone, Debug, Default)]
pub(super) struct Tree {
pub level: Vec<u32>,
pub parent: Vec<Option<usize>>,
pub branch: Vec<bool>,
pub open: Vec<bool>,
}
#[derive(Clone, Debug)]
pub(super) struct GroupLine {
pub key: GroupKey,
pub column: Arc<str>,
pub count: usize,
pub open: bool,
pub rows: Vec<usize>,
}
#[derive(Clone, Debug, Default)]
pub(super) struct Lines {
lines: Option<Vec<Shown>>,
order: Option<Arc<Vec<usize>>>,
position_of_rank: Option<Vec<usize>>,
ranks: usize,
rank_of_index: std::sync::OnceLock<Vec<usize>>,
pub groups: Vec<GroupLine>,
pub depth: usize,
pub passed: Option<Arc<Vec<usize>>>,
pub tree: Option<Arc<Tree>>,
}
impl Lines {
pub fn flat(count: usize) -> Self {
Self {
ranks: count,
..Self::default()
}
}
pub fn tree(order: Vec<usize>, tree: Tree) -> Self {
Self {
ranks: order.len(),
order: Some(Arc::new(order)),
tree: Some(Arc::new(tree)),
..Self::default()
}
}
pub fn with_details(mut self, open: impl Fn(usize) -> bool) -> Self {
let mut lines = Vec::with_capacity(self.len());
let mut position_of_rank = vec![0; self.ranks];
for position in 0..self.len() {
let Some(line) = self.line(position) else {
continue;
};
lines.push(line);
if let Shown::Row(rank) = line {
position_of_rank[rank] = lines.len() - 1;
if open(rank) {
lines.push(Shown::Detail(rank));
}
}
}
self.lines = Some(lines);
self.position_of_rank = Some(position_of_rank);
self
}
pub fn rows(order: Arc<Vec<usize>>) -> Self {
Self {
ranks: order.len(),
order: Some(order),
..Self::default()
}
}
pub fn len(&self) -> usize {
self.lines.as_ref().map_or(self.ranks, Vec::len)
}
pub fn line(&self, position: usize) -> Option<Shown> {
match &self.lines {
Some(lines) => lines.get(position).copied(),
None => (position < self.ranks).then_some(Shown::Row(position)),
}
}
pub fn ranks(&self) -> usize {
self.ranks
}
pub fn row_of_rank(&self, rank: usize) -> Option<usize> {
if rank >= self.ranks {
return None;
}
match &self.order {
Some(order) => order.get(rank).copied(),
None => Some(rank),
}
}
pub fn position_of(&self, rank: usize) -> Option<usize> {
if rank >= self.ranks {
return None;
}
match &self.position_of_rank {
Some(positions) => positions.get(rank).copied(),
None => Some(rank),
}
}
pub fn rank_of_index(&self, index: usize) -> Option<usize> {
let Some(order) = &self.order else {
return (index < self.ranks).then_some(index);
};
let ranks = self.rank_of_index.get_or_init(|| {
let mut ranks = vec![usize::MAX; order.iter().copied().max().map_or(0, |most| most + 1)];
for (rank, index) in order.iter().enumerate() {
ranks[*index] = rank;
}
ranks
});
ranks.get(index).copied().filter(|rank| *rank != usize::MAX)
}
pub fn grouped(
rows: Vec<usize>,
columns: &[Arc<str>],
summaries: bool,
values: &dyn Fn(usize, usize) -> String,
open: &dyn Fn(&GroupKey) -> bool,
) -> Self {
if columns.is_empty() {
return Self::rows(Arc::new(rows));
}
let mut built = Built::default();
built.add(&rows, 0, &[], columns, summaries, values, open);
Self {
ranks: built.order.len(),
lines: Some(built.lines),
order: Some(Arc::new(built.order)),
position_of_rank: Some(built.position_of_rank),
rank_of_index: std::sync::OnceLock::new(),
groups: built.groups,
depth: columns.len(),
passed: None,
tree: None,
}
}
pub fn rank_at(&self, position: usize) -> Option<usize> {
match self.line(position)? {
Shown::Row(rank) => Some(rank),
Shown::Group(_) | Shown::Summary(_) | Shown::Detail(_) => None,
}
}
pub fn level(&self, position: usize) -> u32 {
match self.line(position) {
Some(Shown::Group(group)) => self.groups[group].key.level() as u32,
Some(Shown::Row(rank) | Shown::Detail(rank)) if self.tree.is_some() => {
self
.tree
.as_ref()
.and_then(|tree| tree.level.get(rank))
.copied()
.unwrap_or(0)
+ 1
}
_ => self.depth as u32 + 1,
}
}
}
#[derive(Default)]
struct Built {
lines: Vec<Shown>,
order: Vec<usize>,
position_of_rank: Vec<usize>,
groups: Vec<GroupLine>,
}
impl Built {
#[allow(clippy::too_many_arguments)]
fn add(
&mut self,
rows: &[usize],
level: usize,
above: &[String],
columns: &[Arc<str>],
summaries: bool,
values: &dyn Fn(usize, usize) -> String,
open: &dyn Fn(&GroupKey) -> bool,
) {
if level == columns.len() {
for row in rows {
self.position_of_rank.push(self.lines.len());
self.lines.push(Shown::Row(self.order.len()));
self.order.push(*row);
}
return;
}
let mut groups: Vec<(String, Vec<usize>)> = Vec::new();
let mut place: HashMap<String, usize> = HashMap::new();
for row in rows {
let value = values(*row, level);
match place.get(&value) {
Some(at) => groups[*at].1.push(*row),
None => {
place.insert(value.clone(), groups.len());
groups.push((value, vec![*row]));
}
}
}
for (value, members) in groups {
let mut path = above.to_vec();
path.push(value);
let key = GroupKey { values: path.clone() };
let is_open = open(&key);
let group = self.groups.len();
self.lines.push(Shown::Group(group));
self.groups.push(GroupLine {
key,
column: columns[level].clone(),
count: members.len(),
open: is_open,
rows: members.clone(),
});
if is_open {
self.add(&members, level + 1, &path, columns, summaries, values, open);
if summaries {
self.lines.push(Shown::Summary(group));
}
}
}
}
}
pub struct TableGroup {
pub position: usize,
pub key: GroupKey,
pub title: Arc<str>,
pub count: usize,
pub open: bool,
pub entry: bool,
pub(super) recipe: ResolvedRecipe,
pub(super) toggle: Arc<dyn Fn(bool) + Send + Sync>,
pub(super) element: ElementRef,
pub(super) grid: bool,
pub(super) indent: f32,
pub(super) name: String,
pub(super) id: Option<Arc<str>>,
}
impl TableGroup {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part)
}
pub fn value(&self) -> &str {
self.key.values.last().map_or("", String::as_str)
}
pub fn render(self) -> Element {
let part = self.part(TablePart::GroupRow);
let open = self.open;
let (press, keyed) = (self.toggle.clone(), self.toggle.clone());
let chevron = glyph(
&self.part(TablePart::Chevron),
Name::new(if open {
icons::CHEVRON_DOWN
} else {
icons::CHEVRON_RIGHT
}),
false,
);
let label = self.part(TablePart::GroupLabel);
let count = self.part(TablePart::GroupCount);
let name = self.name.clone();
let element = self.element.clone();
let mut row = pressable(&part, false)
.justify(Justify::Start)
.align_items(Alignment::Stretch)
.ref_element(self.element.clone())
.focus_row(self.position)
.focus_level(self.key.level() as u32)
.focus_expanded(open, {
let toggle = self.toggle.clone();
move |open| toggle(open)
})
.focus_entry(self.entry)
.focus_label(self.value().to_owned())
.describe("a11y_role", "row")
.describe("a11y_rowindex", (self.position + 2).to_string())
.describe("a11y_level", self.key.level().to_string())
.describe("a11y_expanded", if open { "true" } else { "false" })
.describe("a11y_name", name)
.key(format!("group-{}", self.key.values.join("\u{1f}")))
.on_click(move |event: MouseEvent| {
event.stop_propagation();
press(!open);
})
.on_key_down(move |event: KeyboardEvent| {
if !element.focused() || event.composing || event.alt || event.ctrl || event.meta {
return;
}
if matches!(event.key.as_str(), "Enter" | " ") {
event.prevent_default();
keyed(!open);
}
});
if self.grid {
row = row.tab_index(0);
}
if let Some(id) = &self.id {
row = row.id(id.clone());
}
row
.child(
Row::new()
.align_items(Alignment::Center)
.spacing(8.0)
.padding_left(self.indent)
.sticky(Sticky::left(0.0))
.child(chevron)
.child(label.text(self.value()).nowrap())
.child(count.text(&self.count.to_string()).nowrap()),
)
.into()
}
}