use crate::tree::{RNode, try_with_tree, with_tree};
use day_reactive::Scope;
use day_spec::{
ListSource, RawHandle,
props::{RowDelta, RowHeight},
};
use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::rc::Rc;
pub struct ListDriver {
pub row_height: RowHeight,
pub track_viewport: bool,
pub track_reader: bool,
pub len: Box<dyn Fn() -> usize>,
pub token_at: Box<dyn Fn(usize) -> u64>,
pub build: Box<dyn Fn(usize, RNode) -> BuiltRow>,
pub reorder: Option<ListReorderDriver>,
pub delete: Option<ListDeleteDriver>,
pub swipe: Option<ListSwipeDriver>,
pub sections: Option<ListSectionsDriver>,
pub supplements: ListSupplements,
}
pub type SupplementBuild = Box<dyn Fn(RNode) -> BuiltRow>;
#[derive(Default)]
pub struct ListSupplements {
pub header: Option<SupplementBuild>,
pub footer: Option<SupplementBuild>,
pub empty: Option<SupplementBuild>,
pub padding: day_spec::Insets,
}
impl ListSupplements {
fn shape(&self) -> SupplementShape {
SupplementShape {
pad_top: self.padding.top > 0.0,
header: self.header.is_some(),
empty: self.empty.is_some(),
footer: self.footer.is_some(),
pad_bottom: self.padding.bottom > 0.0,
}
}
pub(crate) fn any(&self) -> bool {
let shape = self.shape();
shape.pad_top || shape.header || shape.empty || shape.footer || shape.pad_bottom
}
fn build(&self, which: Supplement, anchor: RNode) -> BuiltRow {
let build = match which {
Supplement::Header => self.header.as_ref(),
Supplement::Footer => self.footer.as_ref(),
Supplement::Empty => self.empty.as_ref(),
Supplement::PadTop | Supplement::PadBottom => None,
};
match build {
Some(build) => build(anchor),
None => BuiltRow {
scope: Scope::child(),
rebind: Rc::new(|_| {}),
},
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Supplement {
PadTop,
Header,
Empty,
Footer,
PadBottom,
}
impl Supplement {
fn token(self) -> u64 {
0x5DA7_5C0F_F5E7_0000
| match self {
Supplement::PadTop => 1,
Supplement::Header => 2,
Supplement::Empty => 3,
Supplement::Footer => 4,
Supplement::PadBottom => 5,
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
struct SupplementShape {
pad_top: bool,
header: bool,
empty: bool,
footer: bool,
pad_bottom: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CellKind {
Item,
Header,
Extra(Supplement),
}
pub struct ListSectionsDriver {
pub key_at: Box<dyn Fn(usize) -> u64>,
pub build: Box<dyn Fn(usize, RNode) -> BuiltRow>,
}
pub struct ListReorderDriver {
pub can_move: Box<dyn Fn(usize, usize) -> i64>,
pub moved: Box<dyn Fn(usize, usize)>,
}
pub struct ListDeleteDriver {
pub can_delete: Box<dyn Fn(usize) -> bool>,
pub deleted: Box<dyn Fn(usize)>,
}
pub struct ListSwipeDriver {
pub actions_at: Box<dyn Fn(usize, day_spec::SwipeEdge) -> Vec<day_spec::ListSwipeAction>>,
pub performed: Box<dyn Fn(usize, day_spec::SwipeEdge, usize)>,
}
pub struct BuiltRow {
pub scope: Scope,
pub rebind: Rc<dyn Fn(usize)>,
}
pub(crate) struct BoundCell {
pub anchor: RNode,
pub active: bool,
pub scope: Scope,
pub rebind: Rc<dyn Fn(usize)>,
pub native_width: Option<f64>,
pub laid_width: Option<f64>,
pub laid_height: Option<f64>,
pub kind: CellKind,
pub token: u64,
pub pinned: bool,
}
pub(crate) struct ListState {
pub driver: Rc<ListDriver>,
pub cells: HashMap<usize, BoundCell>,
pub sections: Option<Rc<SectionMap>>,
pub showed_empty: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum DisplayRow {
Header(usize),
Item(usize),
Extra(Supplement),
}
struct DisplayLayout {
rows: Vec<DisplayRow>,
display: Vec<usize>,
heads: Vec<(usize, u64)>,
}
impl DisplayLayout {
fn solve(n: usize, key_at: Option<&dyn Fn(usize) -> u64>, shape: SupplementShape) -> Self {
let mut rows = Vec::with_capacity(n + n / 4 + 5);
let mut display = Vec::with_capacity(n);
let mut heads = Vec::new();
if shape.pad_top {
rows.push(DisplayRow::Extra(Supplement::PadTop));
}
if shape.header {
rows.push(DisplayRow::Extra(Supplement::Header));
}
if n == 0 && shape.empty {
rows.push(DisplayRow::Extra(Supplement::Empty));
}
let mut seen: HashMap<u64, u64> = HashMap::new();
let mut previous = None;
for i in 0..n {
if let Some(key_at) = key_at {
let key = key_at(i);
if previous != Some(key) {
let nth = seen.entry(key).or_default();
heads.push((rows.len(), SectionMap::header_token(key, *nth)));
*nth += 1;
rows.push(DisplayRow::Header(i));
previous = Some(key);
}
}
display.push(rows.len());
rows.push(DisplayRow::Item(i));
}
if shape.footer {
rows.push(DisplayRow::Extra(Supplement::Footer));
}
if shape.pad_bottom {
rows.push(DisplayRow::Extra(Supplement::PadBottom));
}
DisplayLayout {
rows,
display,
heads,
}
}
fn tokens(&self, token_at: &dyn Fn(usize) -> u64) -> Vec<u64> {
let mut heads = self.heads.iter();
self.rows
.iter()
.map(|row| match row {
DisplayRow::Item(i) => token_at(*i),
DisplayRow::Header(_) => heads.next().map_or(0, |(_, token)| *token),
DisplayRow::Extra(which) => which.token(),
})
.collect()
}
}
pub const SPLICE_MAX_DELTAS: usize = 512;
#[must_use]
pub fn diff_rows(old: &[u64], new: &[u64]) -> Option<Vec<RowDelta>> {
if old == new {
return Some(Vec::new());
}
if old.is_empty() || new.is_empty() {
return None;
}
let mut new_at: HashMap<u64, usize> = HashMap::with_capacity(new.len());
for (i, token) in new.iter().enumerate() {
if new_at.insert(*token, i).is_some() {
return None;
}
}
let mut seen = std::collections::HashSet::with_capacity(old.len());
let mut survivors: Vec<usize> = Vec::with_capacity(old.len().min(new.len()));
let mut deltas = Vec::new();
for (i, token) in old.iter().enumerate().rev() {
if !seen.insert(*token) {
return None;
}
match new_at.get(token) {
Some(at) => survivors.push(*at),
None => deltas.push(RowDelta::Remove(i)),
}
}
survivors.reverse();
if survivors.is_empty() {
return None;
}
let still = longest_increasing(&survivors);
let changes = deltas.len() + (new.len() - survivors.len()) + (survivors.len() - still.len());
if changes > SPLICE_MAX_DELTAS {
return None;
}
let mut keeps = vec![false; new.len()];
for at in &still {
keeps[*at] = true;
}
let mut survives = vec![false; new.len()];
for at in &survivors {
survives[*at] = true;
}
let mut work = survivors;
for i in (0..new.len()).rev() {
if keeps[i] {
continue;
}
let before = |work: &[usize]| {
work.iter()
.position(|at| *at == i + 1)
.unwrap_or(work.len())
};
if survives[i] {
let from = work.iter().position(|at| *at == i)?;
work.remove(from);
let to = before(&work);
work.insert(to, i);
if from != to {
deltas.push(RowDelta::Move(from, to));
}
} else {
let to = before(&work);
work.insert(to, i);
deltas.push(RowDelta::Insert(to));
}
}
Some(deltas)
}
fn longest_increasing(seq: &[usize]) -> Vec<usize> {
let mut tails: Vec<usize> = Vec::new();
let mut previous: Vec<Option<usize>> = vec![None; seq.len()];
for (i, value) in seq.iter().enumerate() {
let k = tails.partition_point(|t| seq[*t] < *value);
previous[i] = k.checked_sub(1).map(|k| tails[k]);
if k == tails.len() {
tails.push(i);
} else {
tails[k] = i;
}
}
let mut run = Vec::with_capacity(tails.len());
let mut at = tails.last().copied();
while let Some(i) = at {
run.push(seq[i]);
at = previous[i];
}
run.reverse();
run
}
pub(crate) struct SectionMap {
driver: Rc<ListDriver>,
rows: RefCell<Vec<DisplayRow>>,
display: RefCell<Vec<usize>>,
heads: RefCell<Vec<(usize, u64)>>,
stale: Cell<bool>,
}
impl SectionMap {
fn new(driver: Rc<ListDriver>) -> Self {
SectionMap {
driver,
rows: RefCell::new(Vec::new()),
display: RefCell::new(Vec::new()),
heads: RefCell::new(Vec::new()),
stale: Cell::new(true),
}
}
pub(crate) fn invalidate(&self) {
self.stale.set(true);
}
fn ensure(&self) {
let driver = &self.driver;
let n = (driver.len)();
if !self.stale.get() && self.display.borrow().len() == n {
return;
}
let key_at = driver.sections.as_ref().map(|s| &*s.key_at);
let layout = DisplayLayout::solve(n, key_at, driver.supplements.shape());
*self.rows.borrow_mut() = layout.rows;
*self.display.borrow_mut() = layout.display;
*self.heads.borrow_mut() = layout.heads;
self.stale.set(false);
}
pub(crate) fn len(&self) -> usize {
self.ensure();
self.rows.borrow().len()
}
pub(crate) fn row(&self, display: usize) -> Option<DisplayRow> {
self.ensure();
self.rows.borrow().get(display).copied()
}
pub(crate) fn item_of(&self, display: usize) -> Option<usize> {
match self.row(display)? {
DisplayRow::Item(i) => Some(i),
DisplayRow::Header(_) | DisplayRow::Extra(_) => None,
}
}
pub(crate) fn items_in(&self, first: usize, last: usize) -> std::ops::Range<usize> {
self.ensure();
let display = self.display.borrow();
let start = display.partition_point(|d| *d < first);
let end = display.partition_point(|d| *d <= last);
start..end.max(start)
}
pub(crate) fn is_supplement(&self, display: usize) -> bool {
matches!(self.row(display), Some(DisplayRow::Extra(_)))
}
pub(crate) fn supplement_row(&self, which: Supplement) -> Option<usize> {
self.ensure();
self.rows
.borrow()
.iter()
.position(|row| *row == DisplayRow::Extra(which))
}
pub(crate) fn lead(&self) -> usize {
self.ensure();
self.display.borrow().first().copied().unwrap_or_else(|| {
self.rows
.borrow()
.iter()
.take_while(|row| {
!matches!(
row,
DisplayRow::Extra(Supplement::Footer | Supplement::PadBottom)
)
})
.count()
})
}
pub(crate) fn display_of(&self, item: usize) -> Option<usize> {
self.ensure();
self.display.borrow().get(item).copied()
}
pub(crate) fn span(&self, display: usize) -> Option<SectionSpan> {
let item = self.item_of(display)?;
let heads = self.heads.borrow();
let items = self.display.borrow();
let (first, last) = if heads.is_empty() {
(*items.first()?, *items.last()?)
} else {
let section = heads
.partition_point(|(h, _)| *h <= display)
.checked_sub(1)?;
let last = match heads.get(section + 1) {
Some((next, _)) => next - 1,
None => *items.last()?,
};
(heads[section].0 + 1, last)
};
Some(SectionSpan {
first,
last,
headers: display - item,
})
}
pub(crate) fn header_token_at(&self, display: usize) -> Option<u64> {
self.ensure();
let heads = self.heads.borrow();
let at = heads.binary_search_by_key(&display, |(h, _)| *h).ok()?;
Some(heads[at].1)
}
fn header_token(key: u64, nth: u64) -> u64 {
(key ^ nth.wrapping_mul(0x9E37_79B9_7F4A_7C15)).rotate_left(29) ^ 0xD1B5_4A32_D192_ED03
}
fn move_within(&self, from: usize, to: usize) -> Option<(SectionSpan, usize, usize)> {
let span = self.span(from)?;
let to = to.clamp(span.first, span.last);
Some((span, from - span.headers, to - span.headers))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct SectionSpan {
pub first: usize,
pub last: usize,
pub headers: usize,
}
impl SectionSpan {
fn display_of(&self, item: usize) -> Option<usize> {
let display = item + self.headers;
(self.first..=self.last)
.contains(&display)
.then_some(display)
}
}
day_reactive::tls_slots! {
list;
static SECTION_MAPS: RefCell<HashMap<day_spec::NodeId, std::rc::Weak<SectionMap>>> =
RefCell::new(HashMap::new());
static SCRIPTED_REORDERS: RefCell<HashMap<day_spec::NodeId, ScriptedReorder>> =
RefCell::new(HashMap::new());
}
fn section_map(node: RNode) -> Option<Rc<SectionMap>> {
let id = crate::tree::rnode_to_id(node);
SECTION_MAPS.with(|m| m.borrow().get(&id).and_then(std::rc::Weak::upgrade))
}
pub(crate) fn register_sections(node: RNode, driver: Rc<ListDriver>) -> Rc<SectionMap> {
let map = Rc::new(SectionMap::new(driver));
SECTION_MAPS.with(|m| {
let mut m = m.borrow_mut();
m.retain(|_, w| w.strong_count() > 0);
m.insert(crate::tree::rnode_to_id(node), Rc::downgrade(&map));
});
map
}
pub(crate) fn translate_native_event(
id: day_spec::NodeId,
ev: day_spec::Event,
) -> Option<day_spec::Event> {
use day_spec::Event;
if !matches!(
ev,
Event::SelectionChanged(_) | Event::SelectionSet(_) | Event::ListActivated(_)
) {
return Some(ev);
}
let Some(map) = SECTION_MAPS.with(|m| m.borrow().get(&id).and_then(std::rc::Weak::upgrade))
else {
return Some(ev);
};
match ev {
Event::SelectionChanged(i) if i >= 0 => map
.item_of(i as usize)
.map(|i| Event::SelectionChanged(i as i64)),
Event::SelectionSet(rows) => Some(Event::SelectionSet(
rows.iter()
.filter(|r| **r >= 0)
.filter_map(|r| map.item_of(*r as usize))
.map(|i| i as i64)
.collect(),
)),
Event::ListActivated(i) => map.item_of(i).map(Event::ListActivated),
other => Some(other),
}
}
pub enum CellStep {
Build {
anchor: RNode,
},
Rebind {
rebind: Rc<dyn Fn(usize)>,
anchor: RNode,
},
}
pub fn install_list(node: RNode, driver: ListDriver) {
with_tree(|t| t.install_list(node, driver));
}
pub fn list_reload(node: RNode) {
with_tree(|t| t.list_reload(node));
}
pub fn list_splice(node: RNode, deltas: Vec<RowDelta>) {
with_tree(|t| t.list_splice(node, deltas));
}
#[derive(Clone, Copy, Debug)]
pub struct ListRows<'a> {
pub tokens: &'a [u64],
pub sections: Option<&'a [u64]>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ListSync {
Unchanged,
Spliced(usize),
Reloaded,
}
pub fn list_sync(node: RNode, old: ListRows<'_>, new: ListRows<'_>) -> ListSync {
let Some(driver) = with_tree(|t| t.list_driver(node)) else {
return ListSync::Unchanged;
};
let shape = driver.supplements.shape();
let display = |rows: ListRows<'_>| {
let keys = rows.sections;
let key_at = |i: usize| keys.and_then(|k| k.get(i)).copied().unwrap_or_default();
let key_at: Option<&dyn Fn(usize) -> u64> = keys.is_some().then_some(&key_at);
DisplayLayout::solve(rows.tokens.len(), key_at, shape)
.tokens(&|i| rows.tokens.get(i).copied().unwrap_or_default())
};
let outcome = match diff_rows(&display(old), &display(new)) {
Some(deltas) if deltas.is_empty() => ListSync::Unchanged,
Some(deltas) => {
let count = deltas.len();
with_tree(|t| t.list_splice_rows(node, deltas));
ListSync::Spliced(count)
}
None => {
list_reload(node);
ListSync::Reloaded
}
};
if outcome != ListSync::Reloaded {
list_refresh_rows(node);
}
outcome
}
pub struct LiveCell {
pub key: usize,
pub token: u64,
pub kind: CellKind,
pub rebind: Rc<dyn Fn(usize)>,
}
pub fn list_refresh_rows(node: RNode) {
let Some((driver, cells)) = with_tree(|t| {
let driver = t.list_driver(node)?;
Some((driver, t.list_live_cells(node)))
}) else {
return;
};
if cells.is_empty() {
return;
}
let map = section_map(node);
let mut wanted: HashMap<u64, Vec<usize>> = HashMap::with_capacity(cells.len());
for (at, cell) in cells.iter().enumerate() {
wanted.entry(cell.token).or_default().push(at);
}
let mut found: Vec<Option<usize>> = vec![None; cells.len()];
match &map {
Some(map) => {
for display in 0..map.len() {
let (token, item) = match map.row(display) {
Some(DisplayRow::Item(i)) => ((driver.token_at)(i), i),
Some(DisplayRow::Header(first)) => {
(map.header_token_at(display).unwrap_or_default(), first)
}
Some(DisplayRow::Extra(which)) => (which.token(), 0),
None => continue,
};
for at in wanted.get(&token).into_iter().flatten() {
found[*at] = Some(item);
}
}
}
None => {
for i in 0..(driver.len)() {
for at in wanted.get(&(driver.token_at)(i)).into_iter().flatten() {
found[*at] = Some(i);
}
}
}
}
let mut touched = Vec::with_capacity(cells.len());
for (cell, item) in cells.iter().zip(found) {
if let Some(item) = item {
if !matches!(cell.kind, CellKind::Extra(_)) {
(cell.rebind)(item);
}
touched.push(cell.key);
}
}
day_reactive::flush_sync();
with_tree(|t| {
for key in touched {
t.list_layout_cell(node, key);
}
});
}
pub fn list_scroll_to_end(node: RNode, animated: bool) {
with_tree(|t| t.list_scroll(node, None, day_spec::RowAlign::Nearest, animated));
}
pub fn list_scroll_to_row(node: RNode, row: usize, align: day_spec::RowAlign, animated: bool) {
with_tree(|t| t.list_scroll(node, Some(row), align, animated));
}
pub fn list_set_selected(node: RNode, rows: Vec<usize>) {
with_tree(|t| t.list_set_selected(node, rows));
}
pub fn list_set_editing(node: RNode, on: bool) {
with_tree(|t| t.list_set_editing(node, on));
}
pub fn list_try_reorder(node: RNode, from: usize, to: usize) -> Result<usize, &'static str> {
let hook = SCRIPTED_REORDERS.with(|m| m.borrow().get(&crate::tree::rnode_to_id(node)).cloned());
if let Some(hook) = hook {
return hook(from, to);
}
let driver = with_tree(|t| t.list_driver(node)).ok_or("no list at this node")?;
let Some(re) = driver.reorder.as_ref() else {
return Err("list is not reorderable");
};
let len = (driver.len)();
if from >= len || to >= len {
return Err("row index out of bounds");
}
let span = section_map(node).and_then(|map| {
let span = map.span(map.display_of(from)?)?;
Some((map, span))
});
let to = match &span {
Some((map, span)) => {
let display = map.display_of(to).unwrap_or(span.last);
display.clamp(span.first, span.last) - span.headers
}
None => to,
};
let accepted = (re.can_move)(from, to);
if accepted < 0 {
return Err("reorder denied by the guard");
}
let accepted = (accepted as usize).min(len - 1);
if let Some((_, span)) = &span
&& span.display_of(accepted).is_none()
{
return Err("reorder would leave the row's section");
}
if accepted != from {
(re.moved)(from, accepted);
}
list_reload(node);
Ok(accepted)
}
type ScriptedReorder = Rc<dyn Fn(usize, usize) -> Result<usize, &'static str>>;
pub fn set_scripted_reorder(
node: RNode,
reorder: impl Fn(usize, usize) -> Result<usize, &'static str> + 'static,
) {
let id = crate::tree::rnode_to_id(node);
SCRIPTED_REORDERS.with(|m| m.borrow_mut().insert(id, Rc::new(reorder)));
}
pub fn list_try_delete(node: RNode, index: usize) -> Result<(), &'static str> {
let driver = with_tree(|t| t.list_driver(node)).ok_or("no list at this node")?;
let Some(del) = driver.delete.as_ref() else {
return Err("list is not deletable");
};
if index >= (driver.len)() {
return Err("row index out of bounds");
}
if !(del.can_delete)(index) {
return Err("delete denied by the guard");
}
(del.deleted)(index);
list_reload(node);
Ok(())
}
pub fn list_try_swipe(
node: RNode,
index: usize,
edge: day_spec::SwipeEdge,
action: usize,
expect: Option<&str>,
) -> Result<String, String> {
let driver = with_tree(|t| t.list_driver(node)).ok_or("no list at this node")?;
let Some(sw) = driver.swipe.as_ref() else {
return Err("list has no swipe actions".into());
};
if index >= (driver.len)() {
return Err("row index out of bounds".into());
}
let offer = (sw.actions_at)(index, edge);
let Some(a) = offer.get(action) else {
return Err("no such action in this row's offer".into());
};
if let Some(want) = expect
&& a.label != want
{
return Err(format!(
"the offer holds {:?}, expected {want:?} — not pressed",
a.label
));
}
let label = a.label.clone();
(sw.performed)(index, edge, action);
Ok(label)
}
type ViewportReports = (
Option<Rc<dyn Fn(usize)>>,
Option<Rc<dyn Fn(day_spec::ListViewport)>>,
Rc<Cell<Option<ViewportKey>>>,
);
type ViewportKey = (usize, usize, Option<u64>, usize);
fn driver_viewport(
node: RNode,
driver: &Rc<ListDriver>,
sections: Option<Rc<SectionMap>>,
) -> ViewportReports {
let previous: Rc<Cell<Option<ViewportKey>>> = Rc::new(Cell::new(None));
if !driver.track_viewport {
return (None, None, previous);
}
let report = {
let (driver, previous) = (driver.clone(), previous.clone());
Rc::new(
move |first: usize, last: Option<usize>, end_distance: Option<f64>| {
let n = (driver.len)();
let rows = match (§ions, last) {
(Some(map), Some(last)) => map.items_in(first, last),
(Some(map), None) => {
let start = map.items_in(first, first).start;
start..(start + 1).min(n)
}
(None, Some(last)) => first.min(n)..(last + 1).min(n),
(None, None) => first.min(n)..(first + 1).min(n),
};
let rows = rows.start..rows.end.max(rows.start);
let key = (rows.start, rows.end, end_distance.map(f64::to_bits), n);
if previous.replace(Some(key)) != Some(key) {
crate::tree::enqueue_event(
crate::tree::rnode_to_id(node),
day_spec::Event::ListViewport { rows, end_distance },
);
}
},
)
};
let first_only = {
let report = report.clone();
Rc::new(move |row: usize| report(row, None, None)) as Rc<dyn Fn(usize)>
};
let full = Rc::new(move |v: day_spec::ListViewport| {
report(
v.first,
Some(v.last.max(v.first)),
Some(v.end_distance.max(0.0)),
);
}) as Rc<dyn Fn(day_spec::ListViewport)>;
(Some(first_only), Some(full), previous)
}
pub(crate) fn make_source(
node: RNode,
driver: &Rc<ListDriver>,
sections: Option<&Rc<SectionMap>>,
) -> ListSource {
let row_of = {
let sections = sections.cloned();
move |display: usize| match §ions {
Some(map) => map.row(display),
None => Some(DisplayRow::Item(display)),
}
};
let item_of = {
let row_of = row_of.clone();
move |display: usize| match row_of(display) {
Some(DisplayRow::Item(i)) => Some(i),
_ => None,
}
};
let (first_visible, viewport, previous_report) =
driver_viewport(node, driver, sections.cloned());
let sectioned = driver.sections.is_some();
let token_at: Rc<dyn Fn(usize) -> u64> = {
let (d, row_of, sections) = (driver.clone(), row_of.clone(), sections.cloned());
Rc::new(move |i| match row_of(i) {
Some(DisplayRow::Item(i)) => (d.token_at)(i),
Some(DisplayRow::Header(first)) => sections
.as_ref()
.and_then(|map| map.header_token_at(i))
.unwrap_or_else(|| (d.token_at)(first)),
Some(DisplayRow::Extra(which)) => which.token(),
None => (d.token_at)(i),
})
};
let reader_scroll = driver.track_reader.then(|| {
let id = crate::tree::rnode_to_id(node);
Rc::new(move || {
previous_report.set(None);
crate::tree::enqueue_event(id, day_spec::Event::ListReaderScrolled);
}) as Rc<dyn Fn()>
});
ListSource {
first_visible,
viewport,
reader_scroll,
is_supplement: sections.filter(|_| driver.supplements.any()).map(|map| {
let map = map.clone();
Rc::new(move |i| map.is_supplement(i)) as Rc<dyn Fn(usize) -> bool>
}),
len: {
let (d, sections) = (driver.clone(), sections.cloned());
Rc::new(move || match §ions {
Some(map) => map.len(),
None => (d.len)(),
})
},
token_at: token_at.clone(),
is_header: sections.filter(|_| sectioned).map(|map| {
let map = map.clone();
Rc::new(move |i| matches!(map.row(i), Some(DisplayRow::Header(_))))
as Rc<dyn Fn(usize) -> bool>
}),
bind_row: bind_with(
node,
driver.clone(),
row_of.clone(),
token_at.clone(),
false,
),
bind_pinned: bind_with(node, driver.clone(), row_of.clone(), token_at, true),
layout_cell: Rc::new(move |cell, width| {
let _ = try_with_tree(|t| t.list_layout_cell_width(node, cell as usize, width));
}),
cell_height: Rc::new(move |cell| {
try_with_tree(|t| t.list_cell_height(node, cell as usize)).unwrap_or(0.0)
}),
recycle: Rc::new(move |cell| {
let _ = try_with_tree(|t| t.list_recycle_cell(node, cell as usize));
}),
release: Rc::new(move |cell| {
let key = cell as usize;
crate::tree::run_posted_or_defer(Box::new(move || {
let _ = try_with_tree(|t| t.list_release_cell(node, key));
}));
}),
delete: driver
.delete
.as_ref()
.filter(|_| !sectioned)
.map(|_| day_spec::ListDelete {
can_delete: {
let (d, item_of) = (driver.clone(), item_of.clone());
Rc::new(move |i| {
item_of(i).is_some_and(|i| {
(d.delete.as_ref().expect("mapped from Some").can_delete)(i)
})
})
},
delete_row: {
let (d, item_of) = (driver.clone(), item_of.clone());
Rc::new(move |i| {
if let Some(i) = item_of(i) {
(d.delete.as_ref().expect("mapped from Some").deleted)(i);
}
})
},
}),
reorder: driver.reorder.as_ref().map(|_| day_spec::ListReorder {
can_move: {
let (d, sections) = (driver.clone(), sections.cloned());
Rc::new(move |from, to| {
let re = d.reorder.as_ref().expect("mapped from Some");
let Some(map) = §ions else {
return (re.can_move)(from, to);
};
let Some((span, from, to)) = map.move_within(from, to) else {
return -1;
};
let accepted = (re.can_move)(from, to);
usize::try_from(accepted)
.ok()
.and_then(|i| span.display_of(i))
.map_or(-1, |display| display as i64)
})
},
move_row: {
let (d, sections) = (driver.clone(), sections.cloned());
Rc::new(move |from, to| {
let re = d.reorder.as_ref().expect("mapped from Some");
let Some(map) = §ions else {
return (re.moved)(from, to);
};
if let Some((_, from, to)) = map.move_within(from, to) {
(re.moved)(from, to);
map.invalidate();
}
})
},
}),
swipe: driver.swipe.as_ref().map(|_| day_spec::ListSwipe {
actions_at: {
let (d, item_of) = (driver.clone(), item_of.clone());
Rc::new(move |i, e| match item_of(i) {
Some(i) => (d.swipe.as_ref().expect("mapped from Some").actions_at)(i, e),
None => Vec::new(),
})
},
perform: {
let (d, item_of) = (driver.clone(), item_of.clone());
Rc::new(move |i, e, a| {
if let Some(i) = item_of(i) {
(d.swipe.as_ref().expect("mapped from Some").performed)(i, e, a);
}
})
},
}),
}
}
fn bind_with(
node: RNode,
d: Rc<ListDriver>,
row_of: impl Fn(usize) -> Option<DisplayRow> + 'static,
token_of: Rc<dyn Fn(usize) -> u64>,
pinned: bool,
) -> Rc<dyn Fn(usize, RawHandle)> {
Rc::new(move |index, cell| {
let key = cell as usize;
let (kind, at) = match row_of(index) {
Some(DisplayRow::Header(first)) => (CellKind::Header, first),
Some(DisplayRow::Item(i)) => (CellKind::Item, i),
Some(DisplayRow::Extra(which)) => (CellKind::Extra(which), 0),
None => (CellKind::Item, index),
};
let token = token_of(index);
let Some(step) = try_with_tree(|t| t.list_prepare_cell(node, key, cell, kind, token))
else {
return;
};
match step {
CellStep::Build { anchor } => {
let built = match (kind, d.sections.as_ref()) {
(CellKind::Header, Some(s)) => (s.build)(at, anchor),
(CellKind::Extra(which), _) => d.supplements.build(which, anchor),
_ => (d.build)(at, anchor),
};
with_tree(|t| t.list_store_cell(node, key, anchor, built, kind, token));
}
CellStep::Rebind { rebind, .. } => {
if !matches!(kind, CellKind::Extra(_)) {
rebind(at);
}
}
}
day_reactive::flush_sync();
with_tree(|t| {
t.list_layout_cell(node, key);
if pinned {
t.list_pin_cell(node, key);
}
});
})
}
#[cfg(test)]
mod tests {
use super::*;
fn apply(old: &[u64], new: &[u64], deltas: &[RowDelta]) -> Vec<u64> {
let mut rows: Vec<Option<u64>> = old.iter().copied().map(Some).collect();
for delta in deltas {
match *delta {
RowDelta::Insert(at) => rows.insert(at, None),
RowDelta::Remove(at) => {
rows.remove(at);
}
RowDelta::Move(from, to) => {
let row = rows.remove(from);
rows.insert(to, row);
}
}
}
assert_eq!(rows.len(), new.len(), "row count after {deltas:?}");
rows.iter()
.zip(new)
.map(|(row, want)| row.unwrap_or(*want))
.collect()
}
fn check(old: &[u64], new: &[u64]) -> Vec<RowDelta> {
let deltas = diff_rows(old, new).expect("a splice");
assert_eq!(
apply(old, new, &deltas),
new,
"{old:?} -> {new:?} by {deltas:?}"
);
deltas
}
#[test]
fn equal_lists_need_no_delta() {
assert_eq!(diff_rows(&[1, 2, 3], &[1, 2, 3]), Some(Vec::new()));
assert_eq!(diff_rows(&[], &[]), Some(Vec::new()));
}
#[test]
fn an_append_is_one_insert_at_the_end() {
assert_eq!(check(&[1, 2, 3], &[1, 2, 3, 4]), vec![RowDelta::Insert(3)]);
}
#[test]
fn a_prepend_is_one_insert_at_the_top() {
assert_eq!(check(&[1, 2, 3], &[9, 1, 2, 3]), vec![RowDelta::Insert(0)]);
}
#[test]
fn inserts_in_the_middle_are_sequential() {
let deltas = check(&[1, 2, 3], &[1, 7, 8, 2, 3]);
assert_eq!(deltas.len(), 2);
assert!(deltas.iter().all(|d| matches!(d, RowDelta::Insert(_))));
}
#[test]
fn removals_run_from_the_bottom_up() {
assert_eq!(
check(&[1, 2, 3, 4, 5], &[1, 3, 5]),
vec![RowDelta::Remove(3), RowDelta::Remove(1)]
);
}
#[test]
fn one_row_moved_is_one_move() {
assert_eq!(
check(&[1, 2, 3, 4], &[2, 3, 4, 1]),
vec![RowDelta::Move(0, 3)]
);
assert_eq!(
check(&[1, 2, 3, 4], &[4, 1, 2, 3]),
vec![RowDelta::Move(3, 0)]
);
assert_eq!(check(&[1, 2, 3, 4, 5], &[1, 4, 2, 3, 5]).len(), 1);
}
#[test]
fn a_swap_of_neighbors_is_one_move() {
assert_eq!(check(&[1, 2, 3], &[1, 3, 2]).len(), 1);
}
#[test]
fn a_reversal_moves_all_but_one_row() {
let deltas = check(&[1, 2, 3, 4, 5], &[5, 4, 3, 2, 1]);
assert_eq!(deltas.len(), 4);
assert!(deltas.iter().all(|d| matches!(d, RowDelta::Move(..))));
}
#[test]
fn mixed_changes_apply_in_order() {
check(&[1, 2, 3, 4, 5, 6], &[6, 9, 2, 8, 4, 1]);
check(&[10, 20, 30], &[30, 15, 10, 5]);
check(&[1, 2, 3, 4, 5, 6, 7, 8], &[8, 1, 3, 2, 11, 7, 12]);
}
#[test]
fn every_small_permutation_with_edits_round_trips() {
let mut seed: u64 = 0x2545_F491_4F6C_DD1D;
let mut next = move |bound: usize| {
seed ^= seed << 13;
seed ^= seed >> 7;
seed ^= seed << 17;
(seed % bound as u64) as usize
};
for round in 0..400 {
let n = 1 + next(12);
let old: Vec<u64> = (0..n as u64).collect();
let mut new = old.clone();
for _ in 0..next(6) {
if !new.is_empty() {
let at = next(new.len());
new.remove(at);
}
}
for k in 0..next(6) {
let at = next(new.len() + 1);
new.insert(at, 1000 + round * 10 + k as u64);
}
for _ in 0..next(5) {
if new.len() > 1 {
let (a, b) = (next(new.len()), next(new.len()));
new.swap(a, b);
}
}
match diff_rows(&old, &new) {
Some(deltas) => assert_eq!(apply(&old, &new, &deltas), new, "{old:?} -> {new:?}"),
None => assert!(
new.is_empty() || !new.iter().any(|t| old.contains(t)),
"{old:?} -> {new:?} should splice"
),
}
}
}
#[test]
fn what_a_splice_cannot_say_reloads() {
assert_eq!(diff_rows(&[], &[1]), None);
assert_eq!(diff_rows(&[1], &[]), None);
assert_eq!(diff_rows(&[1, 2], &[3, 4]), None);
assert_eq!(diff_rows(&[1, 1, 2], &[1, 2]), None);
assert_eq!(diff_rows(&[1, 2], &[1, 2, 2]), None);
}
#[test]
fn a_change_past_the_limit_reloads() {
let old: Vec<u64> = (0..2000).collect();
let mut grown = old.clone();
grown.extend(5000..5000 + SPLICE_MAX_DELTAS as u64);
assert_eq!(check(&old, &grown).len(), SPLICE_MAX_DELTAS);
grown.push(9999);
assert_eq!(diff_rows(&old, &grown), None);
let reversed: Vec<u64> = old.iter().rev().copied().collect();
assert_eq!(diff_rows(&old, &reversed), None);
}
#[test]
fn the_longest_run_keeps_still() {
assert_eq!(longest_increasing(&[3, 0, 1, 2]), vec![0, 1, 2]);
assert_eq!(longest_increasing(&[0, 1, 2]), vec![0, 1, 2]);
assert_eq!(longest_increasing(&[2, 1, 0]).len(), 1);
assert_eq!(longest_increasing(&[]), [] as [usize; 0]);
}
fn shape(header: bool, empty: bool, footer: bool) -> SupplementShape {
SupplementShape {
header,
empty,
footer,
..SupplementShape::default()
}
}
#[test]
fn sections_put_a_header_before_each_run_of_one_key() {
let keys = [7_u64, 7, 8, 7];
let key_at = |i: usize| keys[i];
let layout = DisplayLayout::solve(4, Some(&key_at), SupplementShape::default());
assert_eq!(
layout.rows,
vec![
DisplayRow::Header(0),
DisplayRow::Item(0),
DisplayRow::Item(1),
DisplayRow::Header(2),
DisplayRow::Item(2),
DisplayRow::Header(3),
DisplayRow::Item(3),
]
);
assert_eq!(layout.display, vec![1, 2, 4, 6]);
assert_ne!(layout.heads[0].1, layout.heads[2].1);
}
#[test]
fn supplements_surround_the_items_and_the_empty_state_stands_in_for_them() {
let layout = DisplayLayout::solve(2, None, shape(true, true, true));
assert_eq!(
layout.rows,
vec![
DisplayRow::Extra(Supplement::Header),
DisplayRow::Item(0),
DisplayRow::Item(1),
DisplayRow::Extra(Supplement::Footer),
]
);
let empty = DisplayLayout::solve(0, None, shape(true, true, true));
assert_eq!(
empty.rows,
vec![
DisplayRow::Extra(Supplement::Header),
DisplayRow::Extra(Supplement::Empty),
DisplayRow::Extra(Supplement::Footer),
]
);
}
#[test]
fn a_sectioned_change_diffs_headers_with_the_rows() {
let tokens = |layout: &DisplayLayout, items: &[u64]| layout.tokens(&|i| items[i]);
let (old_items, old_keys) = ([1_u64, 2, 3], [10_u64, 10, 20]);
let (new_items, new_keys) = ([1_u64, 2, 3, 4], [10_u64, 10, 20, 20]);
let old = DisplayLayout::solve(3, Some(&|i| old_keys[i]), SupplementShape::default());
let new = DisplayLayout::solve(4, Some(&|i| new_keys[i]), SupplementShape::default());
let (old, new) = (tokens(&old, &old_items), tokens(&new, &new_items));
assert_eq!(check(&old, &new), vec![RowDelta::Insert(5)]);
let newer_keys = [10_u64, 10, 20, 30];
let newer = DisplayLayout::solve(4, Some(&|i| newer_keys[i]), SupplementShape::default());
let newer = tokens(&newer, &new_items);
assert_eq!(check(&old, &newer).len(), 2);
let (fewer_items, fewer_keys) = ([1_u64, 2], [10_u64, 10]);
let fewer = DisplayLayout::solve(2, Some(&|i| fewer_keys[i]), SupplementShape::default());
let fewer = tokens(&fewer, &fewer_items);
assert_eq!(check(&old, &fewer).len(), 2);
}
#[test]
fn the_first_row_replaces_the_empty_state_by_a_splice() {
let empty = DisplayLayout::solve(0, None, shape(true, true, false));
let one = DisplayLayout::solve(1, None, shape(true, true, false));
let (old, new) = (empty.tokens(&|_| 0), one.tokens(&|_| 42));
let deltas = check(&old, &new);
assert_eq!(deltas.len(), 2);
}
}